ZIM upgrade Guide

// Assume multipleMessage.messageInfoList[0] is a text message, and multipleMessage.messageInfoList[1] is an image message
ZIMMultipleMessage multipleMessage = (ZIMMultipleMessage) message;
ZIMMediaDownloadConfig config = new ZIMMediaDownloadConfig();
// Specify to download the image message
config.messageInfoIndex = 1;

zim.getInstance().downloadMediaFile(multipleMessage, ZIMMediaFileType.ORIGINAL_FILE, config, new ZIMMediaDownloadedCallback() {
    @Override
    public void onMediaDownloadingProgress(ZIMMessage message, long currentFileSize, long totalFileSize) {
        // Download progress
        // Developers need to check the type of the message and cast it to the corresponding message type
        if (message instanceof ZIMMultipleMessage) {
            ZIMMultipleMessage multipleMessage = (ZIMMultipleMessage) message;
            // Handle multi-item messages
        }
        // Handle other types of messages
        ......
    }

    @Override
    public void onMediaDownloaded(ZIMMessage message, ZIMError errorInfo) {
        // Download complete
        // Developers need to check the type of the message and cast it to the corresponding message type
        if (message instanceof ZIMMultipleMessage) {
            ZIMMultipleMessage multipleMessage = (ZIMMultipleMessage) message;
            // Handle multi-item messages
        }
        // Handle other types of messages
        ......
    }
});

ZIMImageMessage imageMessage = (ZIMImageMessage) message;
ZIMMediaDownloadConfig config = new ZIMMediaDownloadConfig();

zim.getInstance().downloadMediaFile(multipleMessage, ZIMMediaFileType.ORIGINAL_FILE, config, new ZIMMediaDownloadedCallback() {
    @Override
    public void onMediaDownloadingProgress(ZIMMessage message, long currentFileSize, long totalFileSize) {
        // Download progress
        // Developers need to check the type of the message and cast it to the corresponding message type
        if (message instanceof ZIMMultipleMessage) {
            ZIMMultipleMessage multipleMessage = (ZIMMultipleMessage) message;
            // Handle multi-item messages
        }
        // Handle other types of messages
        ......
    }

    @Override
    public void onMediaDownloaded(ZIMMessage message, ZIMError errorInfo) {
        // Download complete
        // Developers need to check the type of the message and cast it to the corresponding message type
        if (message instanceof ZIMMultipleMessage) {
            ZIMMultipleMessage multipleMessage = (ZIMMultipleMessage) message;
            // Handle multi-item messages
        }
        // Handle other types of messages
        ......
    }
});

ZIMImageMessage imageMessage = (ZIMImageMessage) message;

zim.getInstance().downloadMediaFile(imageMessage, ZIMMediaFileType.ORIGINAL_FILE, new ZIMMediaDownloadedCallback() {
    @Override
    public void onMediaDownloadingProgress(ZIMMediaMessage message, long currentFileSize, long totalFileSize) {
        // Download progress 
    }

    @Override
    public void onMediaDownloaded(ZIMMediaMessage message, ZIMError errorInfo) {
        // Download progress
    }
});

// Assume multipleMessage.messageInfoList[0] is a text message, and multipleMessage.messageInfoList[1] is an image message
auto multipleMessage = std::static_pointer_cast<ZIMMultipleMessage>(message);
ZIMMediaDownloadConfig config;
// Specify to download the image message
config.messageInfoIndex = 1;

ZIM::getInstance()->downloadMediaFile(multipleMessage,
                                     ZIMMediaFileType::ZIM_MEDIA_FILE_TYPE_ORIGINAL_FILE,
                                     config,
                                     [=](const std::shared_ptr<ZIMMessage> &message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
                                         // Download Progress
                                         // Developers need to check the type of the message and cast it to the corresponding message type
                                         if (message->getType() == ZIMMessageType::ZIM_MESSAGE_TYPE_MULTIPLE) {
                                             auto multipleMessage = std::static_pointer_cast<ZIMMultipleMessage>(message);
                                             // Handle multi-item messages
                                         }
                                         // Handle other message types
                                         ......
                                     },
                                     [=](const std::shared_ptr<ZIMMessage> &message, const ZIMError &errorInfo) {
                                         // Download completed
                                         // Developers need to check the type of the message and cast it to the corresponding message type
                                         if (message->getType() == ZIMMessageType::ZIM_MESSAGE_TYPE_MULTIPLE) {
                                             auto multipleMessage = std::static_pointer_cast<ZIMMultipleMessage>(message);
                                             // Handle multi-item messages
                                         }
                                         // Handle other message types
                                         ......
                                     });

auto imageMessage = std::static_pointer_cast<ZIMImageMessage>(message);
ZIMMediaDownloadConfig config;

ZIM::getInstance()->downloadMediaFile(imageMessage,
                                     ZIMMediaFileType::ZIM_MEDIA_FILE_TYPE_ORIGINAL_FILE,
                                     config,
                                     [=](const std::shared_ptr<ZIMMessage> &message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
                                         // Download Progress
                                         // Developers need to check the type of the message and cast it to the corresponding message type
                                         if (message->getType() == ZIMMessageType::ZIM_MESSAGE_TYPE_IMAGE) {
                                             auto imageMessage = std::static_pointer_cast<ZIMImageMessage>(message);
                                             // Handle image messages
                                         }
                                         // Handle other message types
                                         ......
                                     },
                                     [=](const std::shared_ptr<ZIMMessage> &message, const ZIMError &errorInfo) {
                                         // Download completed
                                         // Developers need to check the type of the message and cast it to the corresponding message type
                                         if (message->getType() == ZIMMessageType::ZIM_MESSAGE_TYPE_IMAGE) {
                                             auto imageMessage = std::static_pointer_cast<ZIMImageMessage>(message);
                                             // Handle image messages
                                         }
                                         // Handle other message types
                                         ......
                                     });

auto imageMessage = std::static_pointer_cast<ZIMImageMessage>(message);

ZIM::getInstance()->downloadMediaFile(imageMessage,
                                     ZIMMediaFileType::ZIM_MEDIA_FILE_TYPE_ORIGINAL_FILE,
                                     [=](const std::shared_ptr<ZIMMediaMessage> &message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
                                         // Download Progress
                                     },
                                     [=](const std::shared_ptr<ZIMMediaMessage> &message, const ZIMError &errorInfo) {
                                         // Download completed
                                     });;

// Assume multipleMessage.messageInfoList[0] is a text message, and multipleMessage.messageInfoList[1] is an image message
const multipleMessage: ZIMMessageBase = {
    type: ZIMMessageType.Multiple,
    messageInfoList: [
        new ZIMTextMessageLiteInfo({
            text: "Hello, World!"
        }),
        new ZIMImageMessageLiteInfo({
            fileLocalPath: file
        })
    ]
}

const config: ZIMMediaDownloadConfig = {
    // Specify to download the image message
    messageInfoIndex: 1
}

zim.downloadMediaFile(multipleMessage, ZIMMediaFileType.OriginalFile, config, (message: ZIMMessage, currentFileSize: number, totalFileSize: number) => {
    // Download progress
    // Developers need to check the type of the message and cast it to the corresponding message type
    if (message.type === ZIMMessageType.Multiple) {
        const multipleMessage: ZIMMultipleMessage = message as ZIMMultipleMessage
        // Handle multi-item messages
    }
    // Handle other types of messages
    ......

}).then((message: ZIMMessage) => {
    // Download complete
    // Developers need to check the type of the message and cast it to the corresponding message type
    if (message.type === ZIMMessageType.Multiple) {
        const multipleMessage: ZIMMultipleMessage = message as ZIMMultipleMessage
        // Handle multi-item messages
    }
    // Handle other types of messages
    ......
}).catch((errorInfo: ZIMError) => {
    // Failed to download
})

const imageMessage = new ZIMMessageBase({
    type: ZIMMessageType.Image,
    fileLocalPath: file
})

zim.downloadMediaFile(imageMessage, ZIMMediaFileType.OriginalFile, (message: ZIMMessage, currentFileSize: number, totalFileSize: number) => {
    // Download progress
    // Developers need to check the type of the message and cast it to the corresponding message type
    if (message.type === ZIMMessageType.Image) {
        const imageMessage = new ZIMImageMessage(message)
        // Handler image messages
    }
    // Handle other types of messages
    ......
}).then((message: ZIMMessage) => {
    // Download complete
    // Developers need to check the type of the message and cast it to the corresponding message type
    if (message.type === ZIMMessageType.Image) {
        const imageMessage = new ZIMImageMessage(message)
        // Handler image messages
    }
    // Handle other types of messages
    ......
}).catch((errorInfo: ZIMError) => {
    // Failed to download
})

const imageMessage = new ZIMMessageBase({
    type: ZIMMessageType.Image,
    fileLocalPath: file
})

zim.downloadMediaFile(imageMessage, ZIMMediaFileType.OriginalFile, (message: ZIMMediaMessage, currentFileSize: number, totalFileSize: number) => {
    // Download progress
}).then((message: ZIMMediaMessage) => {
    // Download complete
}).catch((errorInfo: ZIMError) => {
    // Failed to download
})

ZIMImageMessage imageMessage = (ZIMImageMessage) message;

zim.getInstance().sendMessage(imageMessage, "TO_CONVERSATION_ID", ZIMConversationType.PEER, new ZIMMessageSentFullCallback() {
    @Override
    public void onMessageSent(ZIMMessage message, ZIMError errorInfo) {
        // Message send result
    }

    @Override
    public void onMediaUploadingProgress(ZIMMediaMessage message, long currentFileSize, long totalFileSize) {
        // Multimedia upload progress
    }

    @Override
    public void onMessageAttached(ZIMMessage message) {
        // Developers can listen to this callback to execute business logic before sending the message
    }
});

ZIMImageMessage imageMessage = (ZIMImageMessage) message;

zim.getInstance().sendMediaMessage(imageMessage, "TO_CONVERSATION_ID", ZIMConversationType.PEER, new ZIMMediaMessageSentCallback() {
    @Override
    public void onMessageSent(ZIMMediaMessage message, ZIMError errorInfo) {
        // Message send result
    }

    @Override
    public void onMediaUploadingProgress(ZIMMediaMessage message, long currentFileSize, long totalFileSize) {
        // Multimedia upload progress
    }

    @Override
    public void onMessageAttached(ZIMMediaMessage message) {
        // Developers can listen to this callback to execute business logic before sending the message
    }
});

auto imageMessage = std::static_pointer_cast<ZIMImageMessage>(message);
ZIMMessageSendConfig config;
config.priority = ZIMMessagePriority::ZIM_MESSAGE_PRIORITY_MEDIUM;

auto notification = std::make_shared<ZIMMessageSendNotification>();
notification->onMessageAttached = [=](const std::shared_ptr<ZIMMessage> &message) {
    // Developers can listen to this callback to execute business logic before sending the message
};
notification->onMediaUploadingProgress = [=](const std::shared_ptr<ZIMMediaMessage> &message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
    // Upload Progress
};

ZIM::getInstance()->sendMessage(imageMessage, 
                               "TO_CONVERSATION_ID", 
                               ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER, 
                               config, 
                               notification, 
                               [=](const std::shared_ptr<ZIMMessage> &message, const ZIMError &errorInfo) {
                                   // Message Send Result
                               });

auto imageMessage = std::static_pointer_cast<ZIMImageMessage>(message);
ZIMMessageSendConfig config;
config.priority = ZIMMessagePriority::ZIM_MESSAGE_PRIORITY_MEDIUM;

auto notification = std::make_shared<ZIMMediaMessageSendNotification>();
notification->onMessageAttached = [=](const std::shared_ptr<ZIMMessage> &message) {
    // Developers can listen to this callback to execute business logic before sending the message
};
notification->onMediaUploadingProgress = [=](const std::shared_ptr<ZIMMediaMessage> &message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
    // Upload Progress
};

ZIM::getInstance()->sendMediaMessage(imageMessage, 
                                     "TO_CONVERSATION_ID", 
                                     ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER, 
                                     config, 
                                     notification, 
                                     [=](const std::shared_ptr<ZIMMessage> &message, const ZIMError &errorInfo) {
                                         // Message Send Result
                                     });

const imageMessage: ZIMMessageBase = {
    type: ZIMMessageType.Image,
    fileLocalPath: file
}

const config: ZIMMessageSendConfig = {
    priority: ZIMMessagePriority.Medium
}

const notification: ZIMMessageSendNotification = {
    onMessageAttached: (message: ZIMMessage) => {
        // Developers can listen to this callback to execute business logic before sending the message
    },
    onMessageUploadingProgress: (message: ZIMMediaMessage, currentFileSize: number, totalFileSize: number) => {
        // Multimedia upload progress
    }
}

zim.sendMessage(imageMessage, "TO_CONVERSATION_ID", ZIMConversationType.Peer, config, notification).then((message: ZIMMessage) => {
    // Message send result
}).catch((errorInfo: ZIMError) => {
    // Message send failed
})

const imageMessage: ZIMMessageBase = {
    type: ZIMMessageType.Image,
    fileLocalPath: file
}

const config: ZIMMessageSendConfig = {
    priority: ZIMMessagePriority.Medium
}

const notification: ZIMMediaMessageSendNotification = {
    onMessageAttached: (message: ZIMMediaMessage) => {
        // Developers can listen to this callback to execute business logic before sending the message

    },
    onMessageUploadingProgress: (message: ZIMMediaMessage, currentFileSize: number, totalFileSize: number) => {
        // Multimedia upload progress
    }
}

zim.sendMediaMessage(imageMessage, "TO_CONVERSATION_ID", ZIMConversationType.Peer, config, notification).then((message: ZIMMessage) => {
    // Message send result
}).catch((errorInfo: ZIMError) => {
    // Message send failed
})

// Cancel userIdA and userIdB separately
List<String> invitees = new ArrayList<>();
invitees.add("userIdA");
invitees.add("userIdB");
ZIMCallCancelConfig cancelConfig = new ZIMCallCancelConfig();
ZIM.getInstance().callCancel(invitees, "callID", cancelConfig, new ZIMCallCancelSentCallback() {
    @Override
    public void onCallCancelSent(String callID, ArrayList<String> errorInvitees, ZIMError errorInfo) {
        
    }
});;

// Cancel the entire call invitation, can be called successfully when none of the callees in the entire call have accepted    
List<String> invitees = new ArrayList<>();
ZIMCallCancelConfig cancelConfig = new ZIMCallCancelConfig();
ZIM.getInstance().callCancel(invitees, "callID", cancelConfig, new ZIMCallCancelSentCallback() {
    @Override
    public void onCallCancelSent(String callID, ArrayList<String> errorInvitees, ZIMError errorInfo) {

    }
});

// Regardless of whether the userID is passed in the userIDs, it is considered as canceling the entire call, can be called successfully when none of the callees in the entire call have accepted
List<String> invitees = new ArrayList<>();
invitees.add("userIdA");
invitees.add("userIdB");
ZIMCallCancelConfig cancelConfig = new ZIMCallCancelConfig();
ZIM.getInstance().callCancel(invitees, "callID", cancelConfig, new ZIMCallCancelSentCallback() {
    @Override
    public void onCallCancelSent(String callID, ArrayList<String> errorInvitees, ZIMError errorInfo) {
        
    }
});;

// Cancel the entire call invitation, can be called successfully when none of the callees in the entire call have accepted    
List<String> invitees = new ArrayList<>();
ZIMCallCancelConfig cancelConfig = new ZIMCallCancelConfig();
ZIM.getInstance().callCancel(invitees, "callID", cancelConfig, new ZIMCallCancelSentCallback() {
    @Override
    public void onCallCancelSent(String callID, ArrayList<String> errorInvitees, ZIMError errorInfo) {

    }
});

// Cancel userIdA and userIdB separately
std::vector<std::string> invitees;
invitees.emplace_back("userIdA");
invitees.emplace_back("userIdB");
ZIMCallCancelConfig config;
zim->callCancel(invitees, "callID", config, [=](const std::string& callID, const std::vector<std::string>& errorInvitees,
    const ZIMError& errorInfo) {
});

// Cancel the entire call invitation, can be called successfully when none of the callees in the call have accepted
std::vector<std::string> invitees;
ZIMCallCancelConfig config;
zim->callCancel(invitees, "callID", config, [=](const std::string& callID, const std::vector<std::string>& errorInvitees,
    const ZIMError& errorInfo) {
});

// Regardless of whether the userID is passed in the userIDs, it is considered as canceling the entire call, can be called successfully when none of the callees in the call have accepted
std::vector<std::string> invitees;
invitees.emplace_back("userIdA");
invitees.emplace_back("userIdB");
ZIMCallCancelConfig config;
zim->callCancel(invitees, "callID", config, [=](const std::string& callID, const std::vector<std::string>& errorInvitees,
    const ZIMError& errorInfo) {
});

// Cancel the entire call invitation, can be called successfully when none of the callees in the call have accepted
std::vector<std::string> invitees;
ZIMCallCancelConfig config;
zim->callCancel(invitees, "callID", config, [=](const std::string& callID, const std::vector<std::string>& errorInvitees,
    const ZIMError& errorInfo) {
});

// Cancel userIdA and userIdB separately
var callID = 'xxxx';
var invitees = ['userIdA','userIdB'];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })

// Cancel the entire call invitation, can be called successfully when none of the callees in the call have accepted    
var callID = 'xxxx';
var invitees = [];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })

// Regardless of whether userID is passed in userIDs, it is considered as canceling the entire call, can be called successfully when none of the callees in the call have accepted
var callID = 'xxxx';
var invitees = ['userIdA','userIdB'];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })

// Cancel the entire call invitation, can be called successfully when none of the callees in the call have accepted    
var callID = 'xxxx';
var invitees = [];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })

// Cancel userIdA and userIdB separately
var callID = 'xxxx';
var invitees = ['userIdA','userIdB'];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })

// Cancel the entire call invitation, can be called successfully when none of the callees in the call have accepted    
var callID = 'xxxx';
var invitees = [];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })

// Regardless of whether userID is passed in userIDs, it is considered as canceling the entire call, can be called successfully when none of the callees in the call have accepted
var callID = 'xxxx';
var invitees = ['userIdA','userIdB'];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })

// Cancel the entire call invitation, can be called successfully when none of the callees in the call have accepted    
var callID = 'xxxx';
var invitees = [];  // List of invitees' IDs
var config = { extendedData: 'xxxx' }; 
zim.callCancel(invitees, callID, config)
    .then(res => {
          // Operation successful
    })
    .catch(err => {
        // Operation failed
    })