Javavoid addMessageListener(V2NIMMessageListener listener);

Objective-C- (void)addMessageListener:(id<V2NIMMessageListener>)listener;

C++virtual void addMessageListener(V2NIMMessageListener listener) = 0;

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

V2NIMMessageListener messageListener = new V2NIMMessageListener() {

    @Override
    public void onSendMessage(V2NIMMessage message) {

    }

    @Override
    public void onReceiveMessages(List<V2NIMMessage> messages) {

    }

    @Override
    public void onReceiveP2PMessageReadReceipts(List<V2NIMP2PMessageReadReceipt> readReceipts) {

    }

    @Override
    public void onReceiveTeamMessageReadReceipts(List<V2NIMTeamMessageReadReceipt> readReceipts) {

    }

    @Override
    public void onMessageRevokeNotifications(List<V2NIMMessageRevokeNotification> revokeNotifications) {

    }

    @Override
    public void onMessagePinNotification(V2NIMMessagePinNotification pinNotification) {

    }

    @Override
    public void onMessageQuickCommentNotification(V2NIMMessageQuickCommentNotification quickCommentNotification) {

    }

    @Override
    public void onMessageDeletedNotifications(List<V2NIMMessageDeletedNotification> messageDeletedNotifications) {

    }

    @Override
    public void onClearHistoryNotifications(List<V2NIMClearHistoryNotification> clearHistoryNotifications) {

    }
};
v2MessageService.addMessageListener(messageListener);

Objective-C[[[NIMSDK sharedSDK] v2MessageService] addMessageListener:listener];

C++V2NIMMessageListener listener;
listener.onReceiveMessages = [](nstd::vector<V2NIMMessage> messages) {
    // receive messages
};
listener.onReceiveP2PMessageReadReceipts = [](nstd::vector<V2NIMP2PMessageReadReceipt> readReceipts) {
    // receive p2p message read receipts
};
listener.onReceiveTeamMessageReadReceipts = [](nstd::vector<V2NIMTeamMessageReadReceipt> readReceipts) {
    // receive team message read receipts
};
listener.onMessageRevokeNotifications = [](nstd::vector<V2NIMMessageRevokeNotification> revokeNotifications) {
    // receive message revoke notifications
};
listener.onMessagePinNotification = [](V2NIMMessagePinNotification pinNotification) {
    // receive message pin notification
};
listener.onMessageQuickCommentNotification = [](V2NIMMessageQuickCommentNotification quickCommentNotification) {
    // receive message quick comment notification
};
listener.onMessageDeletedNotifications = [](nstd::vector<V2NIMMessageDeletedNotification> messageDeletedNotification) {
    // receive message deleted notifications
};
listener.onClearHistoryNotifications = [](nstd::vector<V2NIMClearHistoryNotification> clearHistoryNotification) {
    // receive clear history notifications
};
messageService.addMessageListener(listener);

Javavoid removeMessageListener(V2NIMMessageListener listener);

Objective-C- (void)removeMessageListener:(id<V2NIMMessageListener>)listener;

C++virtual void removeMessageSendListener(V2NIMMessageListener listener) = 0;

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

v2MessageService.removeMessageListener(messageListener);

Objective-C[[[NIMSDK sharedSDK] v2MessageService] removeMessageListener:listener];

C++V2NIMMessageListener listener;
conversationService.addMessageListener(listener);
messageService.removeMessageListener(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;
  /**
   * 继承自 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 的监听事件方法。
   */
  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;
  /**
   * 继承自 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 的监听事件方法
   */
  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;
  /**
   * 继承自 EventEmitter3 的取消监听方法
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 EventEmitter3 的移除事件方法
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void;
}

TypeScriptnim.V2NIMMessageService.on("onSendMessage", function (message: V2NIMMessage) {})
nim.V2NIMMessageService.on("onReceiveMessages", function (messages: V2NIMMessage[]) {})
nim.V2NIMMessageService.on("onReceiveP2PMessageReadReceipts", function (readReceipts: V2NIMP2PMessageReadReceipt[]) {})
nim.V2NIMMessageService.on("onReceiveTeamMessageReadReceipts", function (readReceipts: V2NIMTeamMessageReadReceipt[]) {})
nim.V2NIMMessageService.on("onMessageRevokeNotifications", function (revokeNotifications: V2NIMMessageRevokeNotification[]) {})
nim.V2NIMMessageService.on("onMessagePinNotification", function (pinNotification: V2NIMMessagePinNotification) {})
nim.V2NIMMessageService.on("onMessageQuickCommentNotification", function (quickCommentNotification: V2NIMMessageQuickCommentNotification) {})
nim.V2NIMMessageService.on("onMessageDeletedNotifications", function (messageDeletedNotifications: V2NIMMessageDeletedNotification[]) {})
nim.V2NIMMessageService.on("onClearHistoryNotifications", function (clearHistoryNotifications: V2NIMClearHistoryNotification[]) {})

TypeScriptv2.messageService.on("sendMessage", function (message: V2NIMMessage) {})
v2.messageService.on("receiveMessages", function (messages: V2NIMMessage[]) {})
v2.messageService.on("receiveP2PMessageReadReceipts", function (readReceipts: V2NIMP2PMessageReadReceipt[]) {})
v2.messageService.on("receiveTeamMessageReadReceipts", function (readReceipts: V2NIMTeamMessageReadReceipt[]) {})
v2.messageService.on("messageRevokeNotifications", function (revokeNotifications: V2NIMMessageRevokeNotification[]) {})
v2.messageService.on("messagePinNotification", function (pinNotification: V2NIMMessagePinNotification) {})
v2.messageService.on("messageQuickCommentNotification", function (quickCommentNotification: V2NIMMessageQuickCommentNotification) {})
v2.messageService.on("messageDeletedNotifications", function (messageDeletedNotifications: V2NIMMessageDeletedNotification[]) {})
v2.messageService.on("clearHistoryNotifications", function (clearHistoryNotifications: V2NIMClearHistoryNotification[]) {})

TypeScriptnim.messageService.on("onSendMessage", function (message: V2NIMMessage) {})
nim.messageService.on("onReceiveMessages", function (messages: V2NIMMessage[]) {})
nim.messageService.on("onReceiveP2PMessageReadReceipts", function (readReceipts: V2NIMP2PMessageReadReceipt[]) {})
nim.messageService.on("onReceiveTeamMessageReadReceipts", function (readReceipts: V2NIMTeamMessageReadReceipt[]) {})
nim.messageService.on("onMessageRevokeNotifications", function (revokeNotifications: V2NIMMessageRevokeNotification[]) {})
nim.messageService.on("onMessagePinNotification", function (pinNotification: V2NIMMessagePinNotification) {})
nim.messageService.on("onMessageQuickCommentNotification", function (quickCommentNotification: V2NIMMessageQuickCommentNotification) {})
nim.messageService.on("onMessageDeletedNotifications", function (messageDeletedNotifications: V2NIMMessageDeletedNotification[]) {})
nim.messageService.on("onClearHistoryNotifications", function (clearHistoryNotifications: V2NIMClearHistoryNotification[]) {})

TypeScriptoff<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void

TypeScriptoff<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void

TypeScriptoff<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void

TypeScriptnim.V2NIMMessageService.off("onSendMessage", function (message: V2NIMMessage) {})
nim.V2NIMMessageService.off("onReceiveMessages", function (messages: V2NIMMessage[]) {})
nim.V2NIMMessageService.off("onReceiveP2PMessageReadReceipts", function (readReceipts: V2NIMP2PMessageReadReceipt[]) {})
nim.V2NIMMessageService.off("onReceiveTeamMessageReadReceipts", function (readReceipts: V2NIMTeamMessageReadReceipt[]) {})
nim.V2NIMMessageService.off("onMessageRevokeNotifications", function (revokeNotifications: V2NIMMessageRevokeNotification[]) {})
nim.V2NIMMessageService.off("onMessagePinNotification", function (pinNotification: V2NIMMessagePinNotification) {})
nim.V2NIMMessageService.off("onMessageQuickCommentNotification", function (quickCommentNotification: V2NIMMessageQuickCommentNotification) {})
nim.V2NIMMessageService.off("onMessageDeletedNotifications", function (messageDeletedNotifications: V2NIMMessageDeletedNotification[]) {})
nim.V2NIMMessageService.off("onClearHistoryNotifications", function (clearHistoryNotifications: V2NIMClearHistoryNotification[]) {})

TypeScriptv2.messageService.off("sendMessage", function (message: V2NIMMessage) {})
v2.messageService.off("receiveMessages", function (messages: V2NIMMessage[]) {})
v2.messageService.off("receiveP2PMessageReadReceipts", function (readReceipts: V2NIMP2PMessageReadReceipt[]) {})
v2.messageService.off("receiveTeamMessageReadReceipts", function (readReceipts: V2NIMTeamMessageReadReceipt[]) {})
v2.messageService.off("messageRevokeNotifications", function (revokeNotifications: V2NIMMessageRevokeNotification[]) {})
v2.messageService.off("messagePinNotification", function (pinNotification: V2NIMMessagePinNotification) {})
v2.messageService.off("messageQuickCommentNotification", function (quickCommentNotification: V2NIMMessageQuickCommentNotification) {})
v2.messageService.off("messageDeletedNotifications", function (messageDeletedNotifications: V2NIMMessageDeletedNotification[]) {})
v2.messageService.off("clearHistoryNotifications", function (clearHistoryNotifications: V2NIMClearHistoryNotification[]) {})

TypeScriptnim.messageService.off("onSendMessage", function (message: V2NIMMessage) {})
nim.messageService.off("onReceiveMessages", function (messages: V2NIMMessage[]) {})
nim.messageService.off("onReceiveP2PMessageReadReceipts", function (readReceipts: V2NIMP2PMessageReadReceipt[]) {})
nim.messageService.off("onReceiveTeamMessageReadReceipts", function (readReceipts: V2NIMTeamMessageReadReceipt[]) {})
nim.messageService.off("onMessageRevokeNotifications", function (revokeNotifications: V2NIMMessageRevokeNotification[]) {})
nim.messageService.off("onMessagePinNotification", function (pinNotification: V2NIMMessagePinNotification) {})
nim.messageService.off("onMessageQuickCommentNotification", function (quickCommentNotification: V2NIMMessageQuickCommentNotification) {})
nim.messageService.off("onMessageDeletedNotifications", function (messageDeletedNotifications: V2NIMMessageDeletedNotification[]) {})
nim.messageService.off("onClearHistoryNotifications", function (clearHistoryNotifications: V2NIMClearHistoryNotification[]) {})

Javavoid sendMessage(V2NIMMessage message,
                 String conversationId,
                 V2NIMSendMessageParams params,
                 V2NIMSuccessCallback<V2NIMSendMessageResult> success,
                 V2NIMFailureCallback failure,
                 V2NIMProgressCallback progress);

Objective-C- (void)sendMessage:(V2NIMMessage *)message
     conversationId:(NSString *)conversationId
             params:(nullable V2NIMSendMessageParams *)params
            success:(nullable V2NIMSendMessageSuccess)success
            failure:(nullable V2NIMFailureCallback)failure
           progress:(nullable V2NIMProgressCallback)progress;

C++virtual void sendMessage(V2NIMMessage message,
    nstd::string conversationId,
    V2NIMSendMessageParams params,
    V2NIMSuccessCallback<V2NIMSendMessageResult> success,
    V2NIMFailureCallback failure,
    V2NIMProgressCallback progress) = 0;

TypeScriptsendMessage(
  message: V2NIMMessage,
  conversationId: string,
  params?: V2NIMSendMessageParams,
  progress?: (percentage: number) => void
): Promise<V2NIMSendMessageResult>

TypeScriptsendMessage(message, conversationId, params, progressCallback): Promise<V2NIMSendMessageResult>

TypeScriptsendMessage(
message: V2NIMMessage,
conversationId: string,
params?: V2NIMSendMessageParams,
progress?: (percentage: number) => void
): Promise<V2NIMSendMessageResult>

Java
 V2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

    V2NIMMessage v2Message = V2NIMMessageCreator.createTextMessage("xxx");
    String conversationId = V2NIMConversationIdUtil.conversationId("xxx", V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);

    V2NIMMessageAntispamConfig antispamConfig = V2NIMMessageAntispamConfig.V2NIMMessageAntispamConfigBuilder.builder()
        // TODO: 根据实际情况配置
        //                .withAntispamBusinessId()
        //                .withAntispamCheating()
        //                .withAntispamCustomMessage()
        //                .withAntispamEnabled()
        //                .withAntispamExtension()
        .build();

    V2NIMMessageConfig messageConfig = V2NIMMessageConfig.V2NIMMessageConfigBuilder.builder()
        // TODO: 根据实际情况配置
        //                .withLastMessageUpdateEnabled()
        //                .withHistoryEnabled()
        //                .withOfflineEnabled()
        //                .withOnlineSyncEnabled()
        //                .withReadReceiptEnabled()
        //                .withRoamingEnabled()
        //                .withUnreadEnabled()
        .build();

    V2NIMMessagePushConfig pushConfig = V2NIMMessagePushConfig.V2NIMMessagePushConfigBuilder.builder()
        // TODO: 根据实际情况配置
        //                .withContent()
        //                .withForcePush()
        //                .withForcePushAccountIds()
        //                .withForcePushContent()
        //                .withPayload()
        //                .withPushEnabled()
        //                .withPushNickEnabled()
        .build();

    V2NIMMessageRobotConfig robotConfig = V2NIMMessageRobotConfig.V2NIMMessageRobotConfigBuilder.builder()
        // TODO: 根据实际情况配置
        //                .withAccountId()
        //                .withCustomContent()
        //                .withFunction()
        //                .withTopic()
        .build();

    V2NIMMessageRouteConfig routeConfig = V2NIMMessageRouteConfig.V2NIMMessageRouteConfigBuilder.builder()
        // TODO: 根据实际情况配置
        //                .withRouteEnabled()
        //                .withRouteEnvironment()
        .build();

    V2NIMMessageAIConfigParams aiConfig = new V2NIMMessageAIConfigParams("aiUserAccountId");
    //设置设置请求大模型的内容
    aiConfig.setContent(new V2NIMAIModelCallContent("msg", 0));
    List<V2NIMAIModelCallMessage> messages = new ArrayList<>();
    messages.add(new V2NIMAIModelCallMessage(V2NIMAIModelRoleType.V2NIM_AI_MODEL_ROLE_TYPE_USER,"msg", 0));
    //设置上下文信息
    aiConfig.setMessages(messages);
    //设置提示词变量占位符替换，JSON 格式的字符串，用于填充 prompt 中的变量。如果 V2NIMAIUser 中的 modelConfig.prompt 定义了变量，则必填
    aiConfig.setPromptVariables("{key:value}");
    V2NIMAIModelConfigParams modelConfigParams = new V2NIMAIModelConfigParams();
    modelConfigParams.setPrompt("prompt");
    modelConfigParams.setMaxTokens(1000);
    modelConfigParams.setTopP(1.0);
    modelConfigParams.setTemperature(0.5);
    //设置大模型配置参数，会覆盖默认配置
    aiConfig.setModelConfigParams(modelConfigParams);

    V2NIMSendMessageParams sendMessageParams = V2NIMSendMessageParams.V2NIMSendMessageParamsBuilder.builder()
        .withAIConfig(aiConfig)
        // TODO: 根据实际情况配置
        //                .withAntispamConfig(antispamConfig)
        //                .withClientAntispamEnabled()
        //                .withClientAntispamReplace()
        //                .withMessageConfig(messageConfig)
        //                .withPushConfig(pushConfig)
        //                .withRobotConfig(robotConfig)
        //                .withRouteConfig(routeConfig)
        .build();

    v2MessageService.sendMessage(v2Message, conversationId, sendMessageParams,
        new V2NIMSuccessCallback<V2NIMSendMessageResult>() {
            @Override
            public void onSuccess(V2NIMSendMessageResult v2NIMSendMessageResult) {
                // TODO: 发送成功
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
                // TODO: 发送失败
            }
        },
        new V2NIMProgressCallback() {
            @Override
            public void onProgress(int progress) {
                // TODO: 发送进度
            }
        });
}

Objective-CV2NIMMessage *v2Message = [[V2NIMMessage alloc] init];
V2NIMSendMessageParams *sendParams = [[V2NIMSendMessageParams alloc] init];
    [NIMSDK.sharedSDK.v2MessageService sendMessage:v2Message conversationId:@"conversationId" params:sendParams success:^(V2NIMSendMessageResult * _Nonnull result) {
        // 成功回调
    } failure:^(V2NIMError * _Nonnull error) {
        // 失败回调
    } progress:^(NSUInteger) {
        // 进度
    }];
}];

C++v2::V2NIMMessage message;
v2::V2NIMSendMessageParams sendMessageParams;
messageService.sendMessage(
    message, conversationId, sendMessageParams,
    [=](v2::V2NIMSendMessageResult result) {
        // 成功回调                                          auto detailString = xpack::json::encode(result);

    },
    [=](v2::V2NIMError error) {
// upload progress

    },
    [=](uint32_t progress) {
// upload progress

    }); 先使用 MessageCreator 模块下的接口创建消息\n2. 上传进度点开 detail [sendMessage::progress]"));

TypeScriptconst messageBeforeSend = nim.V2NIMMessageCreator.createTextMessage("hello world")
const conversationId = nim.V2NIMConversationIdUtil.p2pConversationId('ACCOUND_ID')
const paramsForAIConfig = {
  "accountId": "YOUR_AI_ACCOUNT_ID",
  "content": {
    "msg": "YOUR_CONTENT_MSG",
    "type": 0
  }
}
const message = await nim.V2NIMMessageService.sendMessage(
  messageBeforeSend,
  conversationId,
  {
    "aiConfig": paramsForAIConfig,
    "messageConfig": {},
    "routeConfig": {},
    "pushConfig": {},
    "antispamConfig": {},
    "robotConfig": {},
    "clientAntispamEnabled": true,
    "clientAntispamReplace": "******"
  }
)

TypeScriptconst message = v2.messageCreator.createTextMessage('Hello NTES IM')
const result = await v2.messageService.sendMessage(message, conversationId, params, progressCallback)

TypeScripttry {
  const message: V2NIMMessage = nim.messageCreator.createTextMessage("hello")
  const res: V2NIMSendMessageResult = await nim.messageService.sendMessage(message, 'test1|1|test2')
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<V2NIMSendMessageResult> 消息发送结果

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

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

无。

Javavoid modifyMessage(V2NIMMessage message, V2NIMModifyMessageParams params, V2NIMSuccessCallback<V2NIMModifyMessageResult> success, V2NIMFailureCallback failure);

Objective-C-(void)modifyMessage:(V2NIMMessage *)message
              params:(V2NIMModifyMessageParams *)params
             success:(nullable V2NIMModifyMessageSuccess)success
             failure:(nullable V2NIMFailureCallback)failure;

C++virtual void v2::V2NIMMessageService::modifyMessage(const V2NIMMessage & message,
                                                    const V2NIMModifyMessageParams & params,
                                                    const V2NIMSuccessCallback<const V2NIMModifyMessageResult &> & success,
                                                    const V2NIMFailureCallback & failure)

TypeScriptmodifyMessage(message: V2NIMMessage, params: V2NIMModifyMessageParams): Promise<V2NIMModifyMessageResult>

TypeScriptmodifyMessage(message, params): Promise<V2NIMModifyMessageResult>

TypeScriptmodifyMessage(message: V2NIMMessage, params: V2NIMModifyMessageParams): Promise<V2NIMModifyMessageResult>

JavaString newMessageText = "new message text";
int newSubType = 1;
String newServerExtension = "{\"key\":\"value\"}";
boolean clientAntispamEnabled = true;
String clientAntispamReplace = "replace text";

V2NIMMessageAntispamConfig antispamConfig = V2NIMMessageAntispamConfig.V2NIMMessageAntispamConfigBuilder.builder()
   // TODO: 根据实际情况配置
   //                .withAntispamBusinessId()
   //                .withAntispamCheating()
   //                .withAntispamCustomMessage()
   //                .withAntispamEnabled()
   //                .withAntispamExtension()
   .build();

V2NIMMessagePushConfig pushConfig = V2NIMMessagePushConfig.V2NIMMessagePushConfigBuilder.builder()
   // TODO: 根据实际情况配置
   //                .withContent()
   //                .withForcePush()
   //                .withForcePushAccountIds()
   //                .withForcePushContent()
   //                .withPayload()
   //                .withPushEnabled()
   //                .withPushNickEnabled()
   .build();

V2NIMMessageRouteConfig routeConfig = V2NIMMessageRouteConfig.V2NIMMessageRouteConfigBuilder.builder()
   // TODO: 根据实际情况配置
   //                .withRouteEnabled()
   //                .withRouteEnvironment()
   .build();

V2NIMModifyMessageParams modifyMessageParams = V2NIMModifyMessageParamsBuilder.builder()
   .withText(newMessageText)
   .withSubType(newSubType)
   .withServerExtension(newServerExtension)
   //仅支持地理位置消息附件和自定义消息附件的修改
   .withAttachment(createLocationMessageAttachment())
   .withAntispamConfig(antispamConfig)
   .withRouteConfig(routeConfig)
   .withPushConfig(pushConfig)
   .withClientAntispamEnabled(clientAntispamEnabled)
   .withClientAntispamReplace(clientAntispamReplace)
   .build();
V2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);
v2MessageService.modifyMessage(getMessage(), modifyMessageParams, new V2NIMSuccessCallback<V2NIMModifyMessageResult>() {
  @Override
  public void onSuccess(V2NIMModifyMessageResult v2NIMModifyMessageResult) {
   if (v2NIMModifyMessageResult.getErrorCode() == 200) {
    //修改成功
   }else{
    //修改失败,可能触发的反垃圾
   }
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   //修改失败
  }
});

Objective-CV2NIMModifyMessageParams *params = [[V2NIMModifyMessageParams alloc] init];
// 更新消息内容
params.text = @"modified text";
// 仅位置消息和自定义消息可以更新附件
params.attachment = modifiedAttachment;
// 更新消息的服务器扩展字段
params.serverExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2MessageService modifyMessage:message params:params success:^(V2NIMModifyMessageResult *result) {
        // 更新消息成功
    } failure:^(V2NIMError *error) {
        // 更新消息失败
    }];

C++auto params = V2NIMModifyMessageParams();
messageService.modifyMessage(
    message,
    params,
    [](V2NIMModifyMessageResult result) {
        // modify message succeeded
    },
    [](V2NIMError error) {
        // modify message failed, handle error
    });

TypeScriptlet message = nim.V2NIMMessageCreator.createTextMessage("origin text")
message = await nim.V2NIMMessageService.sendMessage(message, 'YOUR_CONVERSATION_ID')
await nim.V2NIMMessageService.modifyMessage(message, {
    "text": "modified text"
})

TypeScriptconst result = await v2.messageService.modifyMessage(message, {
    text: 'Hello NTES IM'
})

TypeScriptlet message = nim.messageCreator.createTextMessage("origin text")
const params: V2NIMModifyMessageParams = {
  subType: this.subType,
  text: this.text,
  serverExtension: this.serverExtension
} as V2NIMModifyMessageParams

const result = await nim.messageService.modifyMessage(message, params)

无返回值。

Promise<V2NIMModifyMessageResult> 更新消息结果

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

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

无。

Javavoid revokeMessage(V2NIMMessage message, V2NIMMessageRevokeParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)revokeMessage:(V2NIMMessage *)message
         revokeParams:(V2NIMMessageRevokeParams *)revokeParams
              success:(nullable V2NIMSuccessCallback)success
              failure:(nullable V2NIMFailureCallback)failure;

C++virtual void revokeMessage(V2NIMMessage message,
        V2NIMMessageRevokeParams params,
        V2NIMSuccessCallback<void> success,
        V2NIMFailureCallback failure) = 0;

TypeScriptrevokeMessage(message: V2NIMMessage, params?: V2NIMMessageRevokeParams): Promise<void>

TypeScriptrevokeMessage(message, params): Promise<void>

TypeScriptrevokeMessage(message: V2NIMMessage, params?: V2NIMMessageRevokeParams): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

// V2NIMMessage revokeMessage = ; // 被撤回的消息
// 根据实际情况配置
V2NIMMessageRevokeParams revokeParams = V2NIMMessageRevokeParams.V2NIMMessageRevokeParamsBuilder.builder()
.withEnv()
.withExtension()
.withPostscript()
.withPushContent()
.withPushPayload()
.build();

v2MessageService.revokeMessage(revokeMessage, revokeParams,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {
                // TODO: 撤回成功
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
                // TODO: 撤回失败
            }
        });

Objective-CV2NIMMessageRevokeParams *revokeParams = [[V2NIMMessageRevokeParams alloc] init];

[[[NIMSDK sharedSDK] v2MessageService] revokeMessage:message
                                        revokeParams:revokeParams
                                              success:^{
                                            // 发送成功回调
                                            }
                                              failure:^(V2NIMError * _Nonnull error) {
                                            // 发送失败回调，error 包含错误原因
}];

C++V2NIMMessage message;
// ...
V2NIMMessageRevokeParams params;
messageService.revokeMessage(
    message,
    params,
    []() {
        // revoke message succeeded
    },
    [](V2NIMError error) {
        // revoke message failed, handle error
    }
);

TypeScripttry {
  await nim.V2NIMMessageService.revokeMessage(message)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.revokeMessage(message, {})
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.revokeMessage(message)
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。消息撤回成功，返回 onMessageRevokeNotifications 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

消息撤回成功，返回 onMessageRevokeNotifications 回调。

消息撤回成功，返回 messageRevokeNotifications 回调。

Javavoid getMessageList(V2NIMMessageListOption option, V2NIMSuccessCallback<List<V2NIMMessage>> success, V2NIMFailureCallback failure);

Objective-C- (void)getMessageList:(V2NIMMessageListOption *)option
               success:(nullable V2NIMGetMessageListSuccess)success
               failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getMessageList(V2NIMMessageListOption option,
    V2NIMSuccessCallback<nstd::vector<V2NIMMessage>> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetMessageList(option: V2NIMMessageListOption): Promise<V2NIMMessage[]>

TypeScriptgetMessageList(option): Promise<V2NIMMessage[]>

TypeScriptgetMessageList(option: V2NIMMessageListOption): Promise<V2NIMMessage[]>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

V2NIMConversationType conversationType = V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P;
String conversationId = V2NIMConversationIdUtil.conversationId("xxx", conversationType);

V2NIMMessageListOption listOption = V2NIMMessageListOption.V2NIMMessageListOptionBuilder.builder(conversationId)
        // TODO: 根据实际情况配置
//                .withAnchorMessage()
//                .withBeginTime()
//                .withDirection()
//                .withEndTime()
//                .withLimit()
//                .withMessageTypes()
//                .withStrictMode()
        .build();

v2MessageService.getMessageList(listOption,
        new V2NIMSuccessCallback<List<V2NIMMessage>>() {
            @Override
            public void onSuccess(List<V2NIMMessage> v2NIMMessages) {
                // TODO: 成功
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
                // TODO: 失败
            }
        });

Objective-CV2NIMMessageListOption *option = [[V2NIMMessageListOption alloc] init];
[[[NIMSDK sharedSDK] v2MessageService] getMessageList:option
                                              success:^(NSArray<V2NIMMessage *> * _Nonnull result) {
    //result 返回消息数组
}
                                              failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++V2NIMMessageListOption option;
option.limit = 10;
messageService.getMessageList(
    option,
    [](nstd::vector<V2NIMMessage> messages) {
        for (auto&& message : messages) {
            // do something
        }
    },
    [](V2NIMError error) {
        // get message list failed, handle error
    });

TypeScripttry {
  const res: V2NIMMessage[] = await nim.V2NIMMessageService.getMessageList({
    "conversationId": "cjhz1|1|cs6",
    "limit": 50,
    "anchorMessage": {
      "messageServerId": "111",
      "createTime": 0
    },
    "direction": 0
})
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  const messages = await v2.messageService.getMessageList({
    conversationId: 'conversationId'
})
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  const res: V2NIMMessage[] = await nim.messageService.getMessageList({
    "conversationId": "cjhz1|1|cs6",
    "limit": 50,
    "anchorMessage": {
      "messageServerId": "111",
      "createTime": 0
    },
    "direction": 0
})
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<V2NIMMessage[]> 消息列表

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

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

无。

Javavoid getMessageListByIds(List<String> messageClientIds, V2NIMSuccessCallback<List<V2NIMMessage>> success, V2NIMFailureCallback failure);

Objective-C- (void)getMessageListByIds:(NSArray<NSString *> *)messageClientIds
                    success:(nullable V2NIMGetMessageListSuccess)success
                    failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getMessageListByIds(nstd::vector<nstd::string> messageClientIds,
        V2NIMSuccessCallback<nstd::vector<V2NIMMessage>> success,
        V2NIMFailureCallback failure) = 0;

TypeScriptgetMessageListByIds(messageClientIds: string[]): Promise<V2NIMMessage[]>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

List<String> messageClientIds = new ArrayList<>();
// TODO
// messageClientIds.add("xxx");

v2MessageService.getMessageListByIds(messageClientIds,
        new V2NIMSuccessCallback<List<V2NIMMessage>>() {
            @Override
            public void onSuccess(List<V2NIMMessage> v2NIMMessages) {

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

            }
        });

Objective-CNSArray *messageClientIds = @[@"messageClientId1",@"messageClientId2",@"messageClientIdn"];

[[[NIMSDK sharedSDK] v2MessageService] getMessageListByIds:messageClientIds
                                                    success:^(NSArray<V2NIMMessage *> * _Nonnull result) {
    //result 返回消息数组

}
                                                    failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++nstd::vector<nstd::string> messageClientIds;
// ...
messageService.getMessageListByIds(
    messageClientIds,
    [](nstd::vector<V2NIMMessage> messages) {
        for (auto&& message : messages) {
            // do something
        }
    },
    [](V2NIMError error) {
        // get message list by ids failed, handle error
    });

TypeScriptconst messageIds: string[] //消息 ID 数组
const result = await nim.messageService.getMessageListByIds(messageIds)

无返回值。

Promise<V2NIMMessage[]> 消息列表

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

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

无。

Javavoid deleteMessage(V2NIMMessage message, String serverExtension, boolean onlyDeleteLocal, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)deleteMessage:(V2NIMMessage *)message
      serverExtension:(NSString *)serverExtension
      onlyDeleteLocal:(BOOL)onlyDeleteLocal
              success:(nullable V2NIMSuccessCallback)success
              failure:(nullable V2NIMFailureCallback)failure;

C++virtual void deleteMessage(V2NIMMessage message,
    nstd::optional<nstd::string> serverExtension,
    bool onlyDeleteLocal,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptdeleteMessage(message: V2NIMMessage, serverExtension?: string): Promise<void>

TypeScriptdeleteMessage(message, serverExtension, onlyDeleteLocal): Promise<void>

TypeScriptdeleteMessage(message: V2NIMMessage, serverExtension?: string): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

//    V2NIMMessage deleteMessage = ; // 被删除的消息

v2MessageService.deleteMessage(deleteMessage, "xxx", false,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

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

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] deleteMessage:message
                                      serverExtension:@"json String"
                                      onlyDeleteLocal:YES
                                              success:^{
}
                                              failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++V2NIMMessage message;
// ...
messageService.deleteMessage(
    message,
    "serverExtension",
    false,
    []() {
        // delete message succeeded
    },
    [](V2NIMError error) {
        // delete message failed, handle error
    });

TypeScripttry {
  await nim.V2NIMMessageService.deleteMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.deleteMessage(message, 'serverExtension', true)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.deleteMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>

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

删除成功，返回 onMessageDeletedNotifications 回调。

删除成功，返回 messageDeletedNotifications 回调。

Javavoid deleteMessages(List<V2NIMMessage> messages, String serverExtension, boolean onlyDeleteLocal, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)deleteMessages:(NSArray<V2NIMMessage *> *)messages
       serverExtension:(NSString *)serverExtension
       onlyDeleteLocal:(BOOL)onlyDeleteLocal
               success:(nullable V2NIMSuccessCallback)success
               failure:(nullable V2NIMFailureCallback)failure;

C++virtual void deleteMessages(nstd::vector<V2NIMMessage> messages,
    nstd::optional<nstd::string> serverExtension,
    bool onlyDeleteLocal,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptdeleteMessages(messages: V2NIMMessage[], serverExtension?: string): Promise<void>

TypeScriptdeleteMessages(messages, serverExtension, onlyDeleteLocal): Promise<void>

TypeScriptdeleteMessages(messages: V2NIMMessage[], serverExtension?: string): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

//   List<V2NIMMessage> messages = ; // 被删除的消息

v2MessageService.deleteMessages(messages, "xxx", false,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

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

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] deleteMessages:@[message]
                                      serverExtension:@"json String"
                                      onlyDeleteLocal:YES
                                              success:^{
}
                                              failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++nstd::vector<V2NIMMessage> messages
// ...
messageService.deleteMessages(
    messages,
    "serverExtension",
    false,
    []() {
        // delete messages succeeded
    },
    [](V2NIMError error) {
        // delete messages failed, handle error
    });

TypeScripttry {
  await nim.V2NIMMessageService.deleteMessages(messages, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.deleteMessages(messages, 'serverExtension', true)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.deleteMessages(messages, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。每一条消息删除成功，返回 onMessageDeletedNotifications 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

每一条消息删除成功，返回 onMessageDeletedNotifications 回调。

每一条消息删除成功，返回 messageDeletedNotifications 回调。

Javavoid clearHistoryMessage(V2NIMClearHistoryMessageOption option, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)clearHistoryMessage:(V2NIMClearHistoryMessageOption *)option
                    success:(nullable V2NIMSuccessCallback)success
                    failure:(nullable V2NIMFailureCallback)failure;

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

TypeScriptclearHistoryMessage(option: V2NIMClearHistoryMessageOption): Promise<void>

TypeScriptclearHistoryMessage(option): Promise<void>

TypeScriptclearHistoryMessage(option: V2NIMClearHistoryMessageOption): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

V2NIMConversationType conversationType = V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P;
String conversationId = V2NIMConversationIdUtil.conversationId("xxx", conversationType);

V2NIMClearHistoryMessageOption clearOption = V2NIMClearHistoryMessageOption.V2NIMClearHistoryMessageOptionBuilder.builder(conversationId)
        // TODO: 根据实际情况配置
//                .withDeleteRoam()
//                .withExtension()
//                .withOnlineSync()
        .build();

v2MessageService.clearHistoryMessage(clearOption,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

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

            }
        });

Objective-CV2NIMClearHistoryMessageOption *clearOption = [[V2NIMClearHistoryMessageOption alloc] init];
[[[NIMSDK sharedSDK] v2MessageService] clearHistoryMessage:clearOption
                                                    success:^{

} failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++V2NIMClearHistoryMessageOption option;
option.conversationId = V2NIMConversationIdUtil::p2pConversationId("target_account_id");
messageService.clearHistoryMessage(
    option,
    []() {
        // clear history message succeeded
    },
    [](V2NIMError error) {
        // clear history message failed, handle error
    });

TypeScripttry {
  await nim.V2NIMMessageService.clearHistoryMessage({conversationId: 'me|1|another'})
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.clearHistoryMessage(option)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.clearHistoryMessage({conversationId: 'me|1|another'})
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。清空消息成功，返回 onClearHistoryNotifications 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

清空消息成功，返回 onClearHistoryNotifications 回调。

清空消息成功，返回 clearHistoryNotifications 回调。

Javavoid updateMessageLocalExtension(V2NIMMessage message, String localExtension, V2NIMSuccessCallback<V2NIMMessage> success, V2NIMFailureCallback failure);

Objective-C- (void)updateMessageLocalExtension:(V2NIMMessage *)message
                     localExtension:(NSString *)localExtension
                            success:(nullable V2NIMUpdateLocalExtensionSuccess)success
                            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updateMessageLocalExtension(V2NIMMessage message,
    nstd::string localExtension,
    V2NIMSuccessCallback<V2NIMMessage> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptupdateMessageLocalExtension(message, localExtension): Promise<V2NIMMessage>

TypeScriptupdateMessageLocalExtension(message: V2NIMMessage, localExtension: string): Promise<V2NIMMessage>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

// V2NIMMessage updateMessage = ; // 被更新的消息
v2MessageService.updateMessageLocalExtension(updateMessage, "xxx",
        new V2NIMSuccessCallback<V2NIMMessage>() {
            @Override
            public void onSuccess(V2NIMMessage v2NIMMessage) {

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

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] updateMessageLocalExtension:message
                                                    localExtension:@"update local ext"
                                                           success:^(V2NIMMessage * _Nonnull result) {
    //result 更新后消息
}
                                                           failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++V2NIMMessage message;
// ...
messageService.updateMessageLocalExtension(
    message,
    "localExtension",
    [](V2NIMMessage message) {
        // update message local extension succeeded
    },
    [](V2NIMError error) {
        // update message local extension failed, handle error
    });

TypeScriptconst message = await v2.messageService.updateMessageLocalExtension(message, 'localExtension')

TypeScriptconst result = await nim.messageService.updateMessageLocalExtension(sendMessage, 'extension')

无返回值。

Promise<V2NIMMessage> 更新的消息对象

• 请求成功，返回 V2NIMSuccessCallback 回调，包含更新后的 V2NIMMessage。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

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

无。

Javavoid insertMessageToLocal(V2NIMMessage message, String conversationId, String senderId, long createTime, V2NIMSuccessCallback<NIMMessage> success, V2NIMFailureCallback failure);

Objective-C- (void)insertMessageToLocal:(V2NIMMessage *)message
              conversationId:(NSString *)conversationId
                    senderId:(NSString*)senderId
                  createTime:(NSTimeInterval)createTime
                     success:(nullable V2NIMInertMessagSuccess)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void insertMessageToLocal(V2NIMMessage message,
    nstd::string conversationId,
    nstd::string senderId,
    uint64_t createTime,
    V2NIMSuccessCallback<V2NIMMessage> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptinsertMessageToLocal(message, conversationId, senderId, createTime): Promise<V2NIMMessage>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

// 构建被插入的消息
V2NIMMessage v2NIMMessage = V2NIMMessageCreator.createTextMessage("xxx");

V2NIMConversationType conversationType = V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P;
String conversationId = V2NIMConversationIdUtil.conversationId("xxx", conversationType);

v2MessageService.insertMessageToLocal(v2NIMMessage, conversationId, "xxx", 0,
        new V2NIMSuccessCallback<NIMMessage>() {
            @Override
            public void onSuccess(NIMMessage nimMessage) {

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

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] insertMessageToLocal:message
                                           conversationId:@"conversaionId"
                                                 senderId:@"senderId"
                                               createTime:1698809881
                                                  success:^(V2NIMMessage * _Nonnull result) {
    // result 插入消息成功
} failure:^(V2NIMError * _Nonnull error) {
    // error 包含错误原因
}];

C++auto conversationId = V2NIMConversationIdUtil::p2pConversationId("target_account_id");
auto message = V2NIMMessageCreator::createTextMessage("hello world");
messageService.insertMessageToLocal(
    message,
    conversationId,
    "target_account_id",
    0,
    [](V2NIMMessage message) {
        // Insert local message succeeded
    },
    [](V2NIMError error) {
        // Insert local message failed, handle error
});

TypeScriptconst message = await v2.messageService.insertMessageToLocal(message, conversationId, senderId, createTime)

TypeScriptconst messageResult:V2NIMMessage = await nim.messageService.insertMessageToLocal(message, conversationId)

无返回值。

Promise<V2NIMMessage> 插入的消息对象

• 请求成功，返回 V2NIMSuccessCallback 回调，包含插入的 V2NIMMessage。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

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

无。

Javavoid cancelMessageAttachmentUpload(V2NIMMessage message, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)cancelMessageAttachmentUpload:(V2NIMMessage *)message
                              success:(nullable V2NIMSuccessCallback)success
                              failure:(nullable V2NIMFailureCallback)failure;

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

TypeScriptcancelMessageAttachmentUpload(message: V2NIMMessage): Promise<void>

TypeScriptcancelMessageAttachmentUpload(message): Promise<void>

TypeScriptcancelMessageAttachmentUpload(message: V2NIMMessage): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

v2MessageService.cancelMessageAttachmentUpload(message,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {
            // cancel succeeded
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
            // cancel failed, handle error
            }
        });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] cancelMessageAttachmentUpload:message
                                                             success:^{
    //取消成功
}
                                                             failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++V2NIMMessage message;
// more code
messageService.cancelMessageAttachmentUpload(
    message,
    []() {
        // cancel message attachment upload succeeded
    },
    [](V2NIMError error) {
        // cancel message attachment upload failed, handle error
    });

TypeScripttry {
  await nim.V2NIMMessageService.cancelMessageAttachmentUpload(message)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.cancelMessageAttachmentUpload(message)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.cancelMessageAttachmentUpload(message)
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>

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

无。

Javavoid replyMessage(V2NIMMessage message,
                  V2NIMMessage replyMessage,
                  V2NIMSendMessageParams params,
                  V2NIMSuccessCallback<V2NIMSendMessageResult> success,
                  V2NIMFailureCallback failure,
                  V2NIMProgressCallback progress);

Objective-C- (void)replyMessage:(V2NIMMessage *)message
        replyMessage:(V2NIMMessage *)replyMessage
              params:(V2NIMSendMessageParams *)params
             success:(nullable V2NIMSendMessageSuccess)success
             failure:(nullable V2NIMFailureCallback)failure
            progress:(nullable V2NIMProgressCallback)progress;

C++virtual void replyMessage(V2NIMMessage message,
    V2NIMMessage replyMessage,
    V2NIMSendMessageParams params,
    V2NIMSuccessCallback<V2NIMSendMessageResult> success,
    V2NIMFailureCallback failure,
    V2NIMProgressCallback progress) = 0;

TypeScriptreplyMessage(
  message: V2NIMMessage,
  replyMessage: V2NIMMessage,
  params?: V2NIMSendMessageParams,
  progress?: (percentage: number) => void
): Promise<V2NIMSendMessageResult>

TypeScriptreplyMessage(message, replyMessage, params, progressCallback): Promise<V2NIMSendMessageResult>

TypeScriptreplyMessage(
 message: V2NIMMessage,
 replyMessage: V2NIMMessage,
 params?: V2NIMSendMessageParams,
 progress?: (percentage: number) => void
): Promise<V2NIMSendMessageResult>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

V2NIMMessage v2Message = V2NIMMessageCreator.createTextMessage("xxx");
// V2NIMMessage replyMessage = ; // 被回复的消息

// 根据实际情况配置
V2NIMMessageAntispamConfig antispamConfig = V2NIMMessageAntispamConfig.V2NIMMessageAntispamConfigBuilder.builder()
.withAntispamBusinessId()
.withAntispamCheating()
.withAntispamCustomMessage()
.withAntispamEnabled()
.withAntispamExtension()
.build();

// 根据实际情况配置
V2NIMMessageConfig messageConfig = V2NIMMessageConfig.V2NIMMessageConfigBuilder.builder()
.withLastMessageUpdateEnabled()
.withHistoryEnabled()
.withOfflineEnabled()
.withOnlineSyncEnabled()
.withReadReceiptEnabled()
.withRoamingEnabled()
.withUnreadEnabled()
.build();

// 根据实际情况配置
V2NIMMessagePushConfig pushConfig = V2NIMMessagePushConfig.V2NIMMessagePushConfigBuilder.builder()
.withContent()
.withForcePush()
.withForcePushAccountIds()
.withForcePushContent()
.withPayload()
.withPushEnabled()
.withPushNickEnabled()
.build();

// 根据实际情况配置
V2NIMMessageRobotConfig robotConfig = V2NIMMessageRobotConfig.V2NIMMessageRobotConfigBuilder.builder()
.withAccountId()
.withCustomContent()
.withFunction()
.withTopic()
.build();

// 根据实际情况配置
V2NIMMessageRouteConfig routeConfig = V2NIMMessageRouteConfig.V2NIMMessageRouteConfigBuilder.builder()
.withRouteEnabled()
.withRouteEnvironment()
.build();

// 根据实际情况配置
V2NIMSendMessageParams sendMessageParams = V2NIMSendMessageParams.V2NIMSendMessageParamsBuilder.builder()
.withAntispamConfig(antispamConfig)
.withClientAntispamEnabled()
.withClientAntispamReplace()
.withMessageConfig(messageConfig)
.withPushConfig(pushConfig)
.withRobotConfig(robotConfig)
.withRouteConfig(routeConfig)
.build();

v2MessageService.replyMessage(v2Message, replyMessage, sendMessageParams,
    new V2NIMSuccessCallback<V2NIMSendMessageResult>() {
        @Override
        public void onSuccess(V2NIMSendMessageResult v2NIMSendMessageResult) {
            // TODO: 发送成功
        }
    },
    new V2NIMFailureCallback() {
        @Override
        public void onFailure(V2NIMError error) {
            // TODO: 发送失败
        }
    },
    new V2NIMProgressCallback() {
        @Override
        public void onProgress(int progress) {
            // TODO: 发送进度
        }
    });

Objective-CV2NIMMessage *replyMessage = [V2NIMMessageCreator createTextMessage:@"reply message"];
// 消息见参数设置文档
V2NIMSendMessageParams *params = [[V2NIMSendMessageParams alloc] init];

[[[NIMSDK sharedSDK] v2MessageService] sendMessage:replyMessage
                                    conversationId:@"conversationId"
                                            params:params
                                           success:^(V2NIMSendMessageResult * _Nonull result) {
                                            // 发送成功回调
                                            }
                                           failure:^(V2NIMError * _Nonnull error) {
                                            // 发送失败回调，error 包含错误原因
                                            }
                                          progress:^(NSUInteger progress) {
                                            // 发送进行
}];

V2NIMMessage *message = [V2NIMMessageCreator createTextMessage:@"message"];

[[[NIMSDK sharedSDK] v2MessageService] replyMessage:message
                                       replyMessage:replyMessage
                                             params:params
                                            success:^(V2NIMSendMessageResult * _Nonnull result) {
                                            // 发送成功回调
                                            }
                                            failure:^(V2NIMError * _Nonnull error) {
                                            // 发送失败回调，error 包含错误原因
                                            }
                                           progress:^(NSUInteger progress) {
                                          // 发送进行
}];

C++auto message = V2NIMMessageCreator::createTextMessage("hello world");
auto params = V2NIMSendMessageParams();
messageService.replyMessage(
    message,
    replyMessage,
    params,
    [](V2NIMSendMessageResult result) {
        // reply message succeeded
    },
    [](V2NIMError error) {
        // reply message failed, handle error
    },
    [](uint32_t progress) {
        // upload progress
    });

TypeScripttry {
  const message: V2NIMMessage = nim.V2NIMMessageCreator.createTextMessage("reply text")
  const result: V2NIMSendMessageResult = await nim.V2NIMMessageService.replyMessage(message, repliedMessage)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  const replyMessage = v2.messageCreator.createTextMessage('Hello NTES IM')
  const result = await v2.messageService.replyMessage(message, replyMessage, params, progressCallback)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  const message: V2NIMMessage = nim.messageCreator.createTextMessage("reply text")
  const result: V2NIMSendMessageResult = await nim.messageService.replyMessage(message, repliedMessage)
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<V2NIMSendMessageResult> 消息发送结果

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

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

无。

Javavoid getMessageListByRefers(List<V2NIMMessageRefer> messageRefers, V2NIMSuccessCallback<List<V2NIMMessage>> success, V2NIMFailureCallback failure);

Objective-C- (void)getMessageListByRefers:(NSArray<V2NIMMessageRefer *> *)messageRefers
                       success:(nullable V2NIMGetMessageListSuccess)success
                       failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getMessageListByRefers(nstd::vector<V2NIMMessageRefer> messageRefers,
    V2NIMSuccessCallback<nstd::vector<V2NIMMessage>> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetMessageListByRefers(messageRefers: V2NIMMessageRefer[]): Promise<V2NIMMessage[]>

TypeScriptgetMessageListByRefers(messageRefers): Promise<V2NIMMessage[]>

TypeScriptgetMessageListByRefers(messageRefers: V2NIMMessageRefer[]): Promise<V2NIMMessage[]>

Objective-CV2NIMMessageRefer *refer1 = [[V2NIMMessageRefer alloc] init];
V2NIMMessageRefer *refer2 = [[V2NIMMessageRefer alloc] init];
V2NIMMessageRefer *refern = [[V2NIMMessageRefer alloc] init];
NSArray *refers = @[refer1, refer2, refern];
[[[NIMSDK sharedSDK] v2MessageService] getMessageListByRefers:refers
                                                      success:^(NSArray<V2NIMMessage *> * _Nonnull result) {
    // result 返回消息数组
}
                                                      failure:^(V2NIMError * _Nonnull error) {
    // error 包含错误原因
}];

C++nstd::vector<V2NIMMessageRefer> messageRefers;
// ...
messageService.getMessageListByRefers(
    messageRefers,
    [](nstd::vector<V2NIMMessage> messages) {
        for (auto&& message : messages) {
            // do something
        }
    },
    [](V2NIMError error) {
        // get message list by refers failed, handle error
    });

TypeScripttry {
  const res: V2NIMMessage[] = await nim.V2NIMMessageService.getMessageListByRefers(
      [{
         senderId: 'me',
         receiverId: 'another',
         messageClientId: 'messageClientId',
         messageServerId: 'messageServerId',
         conversationType: 1,
         conversationId: 'me|1|another',
         createTime: 232312
      }]
  )
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  const messages = await v2.messageService.getMessageListByRefers(messageRefers)
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  const res: V2NIMMessage[] = await nim.messageService.getMessageListByRefers(
      [{
         senderId: 'me',
         receiverId: 'another',
         messageClientId: 'messageClientId',
         messageServerId: 'messageServerId',
         conversationType: 1,
         conversationId: 'me|1|another',
         createTime: 232312
      }]
  )
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<V2NIMMessage> Thread 父消息和根消息列表

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

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

无。

Javavoid pinMessage(V2NIMMessage message, String serverExtension, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)pinMessage:(V2NIMMessage *)message
   serverExtension:(NSString *)serverExtension
           success:(nullable V2NIMSuccessCallback)success
           failure:(nullable V2NIMFailureCallback)failure;

C++virtual void pinMessage(V2NIMMessage message,
    nstd::optional<nstd::string> serverExtension,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptpinMessage(message: V2NIMMessage, serverExtension?: string): Promise<void>

TypeScriptpinMessage(message, serverExtension): Promise<void>

TypeScriptpinMessage(message: V2NIMMessage, serverExtension?: string): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

// V2NIMMessage pinMessage = ; // 被 pin 的消息
v2MessageService.pinMessage(pinMessage, "xxx",
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {
            // success
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
            // failed, handle error
            }
        });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] pinMessage:message
                                  serverExtension:@"json string"
                                          success:^{

}
                                          failure:^(V2NIMError * _Nonnull error) {
    // error 包含错误原因
}];

C++V2NIMMessage message;
// ...
messageService.pinMessage(
    message,
    "serverExtension",
    []() {
        // pin message succeeded
    },
    [](V2NIMError error) {
        // pin message failed, handle error
    });

TypeScripttry {
  await nim.V2NIMMessageService.pinMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.pinMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.pinMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。PIN 成功，返回 onMessagePinNotification 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

PIN 成功，返回 onMessagePinNotification 回调。

PIN 成功，返回 messagePinNotification 回调。

Javavoid unpinMessage(V2NIMMessageRefer messageRefer, String serverExtension, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)unpinMessage:(V2NIMMessageRefer *)messageRefer
     serverExtension:(NSString *)serverExtension
             success:(nullable V2NIMSuccessCallback)success
             failure:(nullable V2NIMFailureCallback)failure;

C++virtual void unpinMessage(V2NIMMessageRefer messageRefer,
    nstd::optional<nstd::string> serverExtension,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptunpinMessage(messageRefer: V2NIMMessageRefer, serverExtension?: string): Promise<void>

TypeScriptunpinMessage(messageRefer, serverExtension): Promise<void>

TypeScriptunpinMessage(messageRefer: V2NIMMessageRefer, serverExtension?: string): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

// V2NIMMessageRefer unpinMessageRefer // 被 unpin 的消息引用
v2MessageService.unpinMessage(unpinMessageRefer, "xxx",
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {
            // success
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
            // failed, handle error
            }
        });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] unpinMessage:message
                                        serverExtension:@"json string"
                                                success:^{

    }
                                                failure:^(V2NIMError * _Nonnull error) {
        //error 包含错误原因
    }];

C++V2NIMMessageRefer messageRefer;
// ...
messageService.unpinMessage(
    messageRefer,
    "serverExtension",
    []() {
        // unpin message succeeded
    },
    [](V2NIMError error) {
        // unpin message failed, handle error
    });

TypeScripttry {
  await nim.V2NIMMessageService.unpinMessage(messageRefer, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.unpinMessage(messageRefer, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.unpinMessage(messageRefer, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。取消 PIN 成功，返回 onMessagePinNotification 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

取消 PIN 成功，返回 onMessagePinNotification 回调。

取消 PIN 成功，返回 messagePinNotification 回调。

Javavoid updatePinMessage(V2NIMMessage message, String serverExtension, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)updatePinMessage:(V2NIMMessage *)message
         serverExtension:(NSString *)serverExtension
                 success:(nullable V2NIMSuccessCallback)success
                 failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updatePinMessage(V2NIMMessage message,
    nstd::optional<nstd::string> serverExtension,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptupdatePinMessage(message: V2NIMMessage, serverExtension?: string): Promise<void>

TypeScriptupdatePinMessage(message, serverExtension): Promise<void>

TypeScriptupdatePinMessage(message: V2NIMMessage, serverExtension?: string): Promise<void>

JavaV2NIMMessageService v2MessageService = NIMClient.getService(V2NIMMessageService.class);

// V2NIMMessage updateMessage = ; // 被更新的消息
v2MessageService.updatePinMessage(updateMessage, "xxx",
    new V2NIMSuccessCallback<Void>() {
        @Override
        public void onSuccess(Void unused) {

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

        }
    });

Objective-C[[[NIMSDK sharedSDK] v2MessageService] updatePinMessage:message
                                        serverExtension:@"json string"
                                                success:^{

}
                                                failure:^(V2NIMError * _Nonnull error) {
    //error 包含错误原因
}];

C++V2NIMMessage message;
// ...
messageService.updatePinMessage(
    message,
    "serverExtension",
    []() {
        // update pin message succeeded
    },
    [](V2NIMError error) {
        // update pin message failed, handle error
    });

TypeScripttry {
  await nim.V2NIMMessageService.updatePinMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await v2.messageService.updatePinMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

TypeScripttry {
  await nim.messageService.updatePinMessage(message, 'serverExtension')
  // todo Success
} catch (err) {
  // todo error
}

无返回值。

Promise<void>