Javapublic static V2NIMMessage createTextMessage(String text)

Objective-C+ (V2NIMMessage *)createTextMessage:(NSString *)text;

C++static nstd::optional<V2NIMMessage> createTextMessage(nstd::string text);

TypeScriptcreateTextMessage(text: string): V2NIMMessage

TypeScriptcreateTextMessage(text): null | V2NIMMessage

TypeScriptcreateTextMessage(text: string): V2NIMMessage

JavaV2NIMMessage v2TextMessage = V2NIMMessageCreator.createTextMessage("text content");

Objective-CV2NIMMessage *v2Message = [V2NIMMessageCreator createTextMessage：@"hello world"];

C++auto textMessage = V2NIMMessageCreator::createTextMessage("hello world");
if(!textMessage) {
    // create text message failed
}

TypeScripttry {
    const message = nim.V2NIMMessageCreator.createTextMessage('hello world')
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createTextMessage('Hello, world!')
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = nim.messageCreator.createTextMessage('hello world')
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createImageMessage(String imagePath, String name, String sceneName, Integer width, Integer height)

Objective-C+ (V2NIMMessage *)createImageMessage:(NSString *)imagePath
                                name:(nullable NSString *)name
                           sceneName:(nullable NSString *)sceneName
                               width:(int)width
                              height:(int)height;

C++static nstd::optional<V2NIMMessage> createImageMessage(nstd::string imagePath,
    nstd::string name,
    nstd::string sceneName,
    uint32_t width,
    uint32_t height);

TypeScriptcreateImageMessage(imageObj: string | File, name?: string, sceneName?: string, width?: number, height?: number): V2NIMMessage

TypeScriptcreateImageMessage(imagePath, name, sceneName, width, height): null | V2NIMMessage

TypeScriptcreateImageMessage(imagePath: string, name?: string, sceneName?: string, width?: number, height?: number): Promise<V2NIMMessage>

JavaV2NIMMessage v2ImageMessage = V2NIMMessageCreator.createImageMessage(imagePath, name, sceneName, width, height);

Objective-CNSString *imagePath = @ "文件沙盒路径";
V2NIMMessage *message = [V2NIMMessageCreator createImageMessage:imagePath
                                                           name:@"imageName"
                                                      sceneName:@"nim_default_im"
                                                          width:200
                                                         height:200];

C++auto imageMessage = V2NIMMessageCreator::createImageMessage("imagePath", "imageName", V2NIM_STORAGE_SCENE_NAME_DEFAULT_IM, 100,
100); if(!imageMessage) {
    // create image message failed
}

TypeScripttry {
    const message = nim.V2NIMMessageCreator.createImageMessage(document.getElementById('fileInputId').files[0])
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createImageMessage(imagePath, name, sceneName, width, height)
} catch(err) {
    // todo error
}

TypeScripttry {
    const imagePath = "沙盒路径"
    const message = nim.messageCreator.createImageMessage(imagePath)
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createAudioMessage(String audioPath, String name, String sceneName, Integer duration)

Objective-C+ (V2NIMMessage *)createAudioMessage:(NSString *)audioPath
                                name:(nullable NSString *)name
                           sceneName:(nullable NSString *)sceneName
                            duration:(int)duration;

C++static nstd::optional<V2NIMMessage> createAudioMessage(nstd::string audioPath, nstd::string name, nstd::string sceneName, uint32_t duration);

TypeScriptcreateAudioMessage(audioObj: string | File, name?: string, sceneName?: string, duration?: number): V2NIMMessage

TypeScriptcreateAudioMessage(audioPath, name, sceneName, duration): null | V2NIMMessage

TypeScriptcreateAudioMessage(audioPath: string, name?: string, sceneName?: string, duration?: number): Promise<V2NIMMessage>

JavaV2NIMMessage v2AudioMessage = V2NIMMessageCreator.createAudioMessage(audioPath, name, sceneName, duration);

Objective-CNSString *audioPath = @"文件沙盒路径";
V2NIMMessage *message = [V2NIMMessageCreator createAudioMessage:audioPath
                                                           name:@"audioName"
                                                      sceneName:@"nim_default_im"
                                                       duration:2];

C++auto audioMessage = V2NIMMessageCreator::createAudioMessage("audioPath", "audioName", V2NIM_STORAGE_SCENE_NAME_DEFAULT_IM, 100);
    if(!audioMessage) {
        // create audio message failed
}

TypeScripttry {
    const message = nim.V2NIMMessageCreator.createAudioMessage(document.getElementById('fileInputId').files[0])
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createAudioMessage(audioPath, name, sceneName, duration)
} catch(err) {
    // todo error
}

TypeScripttry {
    const audioPath ="文件沙盒路径";
    const message = nim.messageCreator.createAudioMessage(audioPath)
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createVideoMessage(String videoPath, String name, String sceneName, Integer duration, Integer width, Integer height)

Objective-C+ (V2NIMMessage *)createVideoMessage:(NSString *)videoPath
                                name:(nullable NSString *)name
                           sceneName:(nullable NSString *)sceneName
                            duration:(int)duration
                               width:(int)width
                              height:(int)height;

C++static nstd::optional<V2NIMMessage> createVideoMessage(nstd::string videoPath,
    nstd::string name,
    nstd::string sceneName,
    uint32_t duration,
    uint32_t width,
    uint32_t height);

TypeScriptcreateVideoMessage(videoObj: string | File, name?: string, sceneName?: string, duration?: number, width?: number, height?: number): V2NIMMessage

TypeScriptcreateVideoMessage(videoPath, name, sceneName, duration, width, height): null | V2NIMMessage

TypeScriptcreateVideoMessage(videoPath: string, name?: string, sceneName?: string, duration?: number, width?: number, height?: number): Promise<V2NIMMessage>

JavaV2NIMMessage v2VideoMessage = V2NIMMessageCreator.createVideoMessage(videoPath, name, sceneName, duration, width, height);

Objective-CNSString *videoPath = @"文件沙盒路径";
V2NIMMessage *message = [V2NIMMessageCreator createVideoMessage:videoPath
                                                           name:@"name"
                                                      sceneName:@"nim_default_im"
                                                       duration:15
                                                          width:200
                                                         height:200];

C++auto videoMessage = V2NIMMessageCreator::createVideoMessage("videoPath", "videoName", V2NIM_STORAGE_SCENE_NAME_DEFAULT_IM, 100, 100, 100);
if (!videoMessage) {
    // create video message failed
}

TypeScripttry {
    const message = nim.V2NIMMessageCreator.createVideoMessage(document.getElementById('fileInputId').files[0])
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createVideoMessage(videoPath, name, sceneName, duration, width, height)
} catch(err) {
    // todo error
}

TypeScripttry {
    const videoPath = "沙盒路径"
    const message = nim.messageCreator.createVideoMessage(videoPath)
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createFileMessage(String filePath, String name, String sceneName)

Objective-C+ (V2NIMMessage *)createFileMessage:(NSString *)filePath
                               name:(nullable NSString *)name
                          sceneName:(nullable NSString *)sceneName;

C++static nstd::optional<V2NIMMessage> createFileMessage(nstd::string filePath, nstd::string name, nstd::string sceneName);

TypeScriptcreateFileMessage(fileObj: string | File, name?: string, sceneName?: string): V2NIMMessage

TypeScriptcreateFileMessage(filePath, name, sceneName): null | V2NIMMessage

TypeScriptcreateFileMessage(filePath: string, name?: string, sceneName?: string): Promise<V2NIMMessage>

JavaV2NIMMessage v2FileMessage = V2NIMMessageCreator.createFileMessage(filePath, name, sceneName);

Objective-CNSString *filePath = @"文件沙盒路径";
V2NIMMessage *message = [V2NIMMessageCreator createFileMessage:filePath
                                                           name:@"name"
                                                      sceneName:@"nim_default_im"];

C++auto fileMessage = V2NIMMessageCreator::createFileMessage("filePath", "fileName", V2NIM_STORAGE_SCENE_NAME_DEFAULT_IM);
if(!fileMessage) {
    // create file message failed
}

TypeScripttry {
    const message = nim.V2NIMMessageCreator.createFileMessage(document.getElementById('fileInputId').files[0])
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createFileMessage(filePath, name, sceneName)
} catch(err) {
    // todo error
}

TypeScripttry {
    const filePath = "沙盒路径"
    const message = nim.messageCreator.createFileMessage(filePath)
} catch(err) {
    // todo error
}
}

Javapublic static V2NIMMessage createLocationMessage(double latitude, double longitude, String address)

Objective-C+ (V2NIMMessage *)createLocationMessage:(double)latitude
                              longitude:(double)longitude
                                address:(NSString *)address;

C++static nstd::optional<V2NIMMessage> createLocationMessage(double latitude, double longitude, nstd::string address);

TypeScriptcreateLocationMessage(latitude: number, longitude: number, address: string): V2NIMMessage

TypeScriptcreateLocationMessage(latitude, longitude, address): null | V2NIMMessage

TypeScriptcreateLocationMessage(latitude: number, longitude: number, address: string): V2NIMMessage

JavaV2NIMMessage v2LocationMessage = V2NIMMessageCreator.createLocationMessage(latitude,longitude, address);

Objective-CV2NIMMessage *message = [V2NIMMessageCreator createLocationMessage:37.787359
                                                        longitude:-122.408227
                                                        address:@"杭州滨江区网商路 399 号"];

C++auto locationMessage = V2NIMMessageCreator::createLocationMessage(100, 100, "address");
if(!locationMessage) {
    // create location message failed
}

TypeScripttry {
    const message = nim.V2NIMMessageCreator.createLocationMessage(30.25, 120.166664, "HangZhou")
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createLocationMessage(latitude, longitude, address)
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = nim.messageCreator.createLocationMessage(30.25, 120.166664, "HangZhou")
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createCustomMessage(String text, String rawAttachment)

Objective-C+ (V2NIMMessage *)createCustomMessage:(NSString *)text
                        rawAttachment:(NSString *)rawAttachment;

C++static nstd::optional<V2NIMMessage> createCustomMessage(nstd::string text, nstd::string rawAttachment);

TypeScriptcreateCustomMessage(text: string, rawAttachment: string): V2NIMMessage

TypeScriptcreateCustomMessage(text, rawAttachment): null | V2NIMMessage

TypeScriptcreateCustomMessage(text: string, rawAttachment: string): V2NIMMessage

JavaV2NIMMessage v2CustomMessage = V2NIMMessageCreator.createCustomMessage(text, rawAttachment);

Objective-CV2NIMessage *message = [V2NIMMessageCreator createCustomMessage:@"text"
                                                rawAttachment:@"custoom JSON String"];

C++auto customMessage = V2NIMMessageCreator::createCustomMessage("text", R"({"key": "value"})");
if(!customMessage) {
    // create custom message failed
}

TypeScripttry {
    const message = nim.V2NIMMessageCreator.createCustomMessage("text", JSON.stringify({
        strategy: 1
    }))
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createCustomMessage(text, rawAttachment)
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = nim.messageCreator.createCustomMessage("text", JSON.stringify({
        strategy: 1
    }))
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createForwardMessage(V2NIMMessage message)

Objective-C+ (V2NIMMessage *)createForwardMessage:(V2NIMMessage *)message;

C++static nstd::optional<V2NIMMessage> createForwardMessage(V2NIMMessage message);

TypeScriptcreateForwardMessage(message: V2NIMMessage): V2NIMMessage | null

TypeScriptcreateForwardMessage(message): null | V2NIMMessage

TypeScriptcreateForwardMessage(message: V2NIMMessage): V2NIMMessage | null

Java// 被转发的消息
// V2NIMMessage v2Message = ;
V2NIMMessage v2ForwardMessage = V2NIMMessageCreator.createForwardMessage(v2Message);

Objective-CV2NIMMessage *message = [V2NIMMessageCreator createForwardMessage:originalMessage];

C++auto forwardMessage = V2NIMMessageCreator::createForwardMessage(message);
if(!forwardMessage) {
    // create forward message failed
}

TypeScripttry {
    const newMessage = nim.V2NIMMessageCreator.createForwardMessage(message)
} catch(err) {
    // todo error
}

TypeScripttry {
    const message = v2.messageCreator.createForwardMessage(message)
} catch(err) {
    // todo error
}

TypeScripttry {
    const newMessage = nim.messageCreator.createForwardMessage(message)
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createTipsMessage(String text)

Objective-C+ (V2NIMMessage *)createTipsMessage:(NSString *)text;

C++static nstd::optional<V2NIMMessage> createTipsMessage(nstd::string text);

TypeScriptcreateTipsMessage(text: string): V2NIMMessage

TypeScriptcreateTipsMessage(text): null | V2NIMMessage

TypeScriptcreateTipsMessage(text: string): V2NIMMessage

JavaV2NIMMessage v2TipMessage = V2NIMMessageCreator.createTipsMessage("tip content");

Objective-CV2NIMessage *message = [V2NIMMessageCreator createTipsMessage:"tip text"];

C++auto tipMessage = V2NIMMessageCreator::createTipsMessage("text");
if(!tipMessage) {
    // create tip message failed
}

TypeScripttry {
    const newMessage = nim.V2NIMMessageCreator.createTipsMessage("hint")
} catch(err) {
    // todo error
}

TypeScripttry {
    const newMessage = v2.messageCreator.createTipsMessage("hint")
} catch(err) {
    // todo error
}

TypeScripttry {
    const newMessage = nim.messageCreator.createTipsMessage("hint")
} catch(err) {
    // todo error
}

Javapublic static V2NIMMessage createCallMessage(int type, String channelId, int status, List<V2NIMMessageCallDuration> durations, String text);

Objective-C+ (V2NIMMessage *)createCallMessage:(NSString *)text
                               type:(NSInteger)type
                          channelId:(NSString *)channelId
                             status:(NSInteger)status
                          durations:(NSArray <V2NIMMessageCallDuration *>*)durations;

C++nstd::optional< V2NIMMessage > v2::V2NIMMessageCreator::createCallMessage(int32_t type, const nstd::string & channelId, int32_t status, const nstd::vector< V2NIMMessageCallDuration > & durations, const nstd::string & text )

TypeScriptcreateCallMessage(type: number, channelId: string, status: number, durations: V2NIMMessageCallDuration[], text?: string): V2NIMMessage

TypeScriptcreateCallMessage(callType, channelId, status, durations, text): V2NIMMessage

TypeScriptcreateCallMessage(type: number, channelId: string, status: number, durations: V2NIMMessageCallDuration[], text?: string): V2NIMMessage

Javaint type = 1;
String channelId = "123";
int status = 1;
V2NIMMessageCallDuration duration = new V2NIMMessageCallDuration("test", 100);
List<V2NIMMessageCallDuration> durations = new ArrayList<>();
durations.add(duration);
V2NIMMessageCreator.createCallMessage(type, channelId, status, durations,"text");

Objective-Cdurations.accountId = @"accountId";
durations.duration = 60;
[V2NIMMessageCreator createCallMessage:@"text" type:1 channelId:@"channelId" status:1 durations:@[durations]];2NIMMessage *v2msg = [V2NIMMessageCreator createCallMessage:@"text" rawAttachment:@"rawAttachment"];

C++auto callMessage = V2NIMMessageCreator::createCallMessage(1, "channelId", 1, {{"account1", 100}, {"account2", 200}}, "text");
if(!callMessage) {
    // create call message failed
}

TypeScriptnim.V2NIMMessageCreator.createCallMessage(
  1,
  "Channel_ID",
  1,
  [{
    accountId: "AccountID", duration: 5000
  }]
)

TypeScriptv2.messageCreator.createCallMessage(
  1,
  "Channel_ID",
  1,
  [{
    accountId: "AccountID", duration: 5000
  }]
)

TypeScriptconst callMessage: V2NIMMessage = messageCreator.createCallMessage(1, "Channel_ID", 3, [
  { accountId: "accid_1", duration: 1 },
  { accountId: "accid_2", duration: 2 },
  { accountId: "accid_3", duration: 3 },
  { accountId: "accid_4", duration: 4 }
], 'text')

Javapublic static V2NIMMessage createCustomMessageWithAttachment(V2NIMMessageCustomAttachment attachment,int subType) {
    V2NIMMessageImpl message = createV2Message(V2NIMMessageType.V2NIM_MESSAGE_TYPE_CUSTOM);
    message.setAttachment(attachment);
    if (subType > 0) {
        message.setSubType(subType);
    }
    return message;
}

Objective-C+ (V2NIMMessage *)createCustomMessageWithAttachment:(V2NIMMessageCustomAttachment *)attachment
                                            subType:(int)subType;

C++virtual nstd::optional<V2NIMMessage> createCustomMessageWithAttachment(nstd::shared_ptr<V2NIMMessageCustomAttachment> attachment,
        int32_t subType) = 0;

TypeScriptcreateCustomMessageWithAttachment(attachment: V2NIMMessageCustomAttachment, subType?: number): V2NIMMessage

JavaV2NIMMessageCustomAttachment attachment = new V2Test1CustomAttachment();
int subtype = 1;
V2NIMMessageCreator.createCustomMessageWithAttachment(attachment,subtype);

Objective-C@interface MyAttachment: V2NIMMessageCustomAttachment
@end

@implementation MyAttachment

- (void)parse:(NSString *)attach
{
    // your code
}

@end

MyAttachment *attachment = [[MyAttachment alloc] init];
V2NIMMessage *message = [V2NIMMessageCreator createCustomMessageWithAttachment:attachment subType:1];

C++struct V2NIMMessageTempCustomAttachment : public V2NIMMessageCustomAttachment {
     nstd::shared_ptr<V2NIMMessageAttachment> parse(const nstd::string& attach) override {
        // parse attach
    }
}
nstd::shared_ptr<V2NIMMessageTempCustomAttachment> attachment = nstd::make_shared<V2NIMMessageTempCustomAttachment>();
int32_t subType = 1;
auto customMessage = V2NIMMessageCreator::createCustomMessageWithAttachment(attachment, subType);

TypeScriptconst attachment = nim.V2NIMMessageCreator.createCustomMessageWithAttachment(
  {
    "raw": "{\"test\":999}",
    "test": 999,
  },
  1
)