open-im-sdk-flutter-m/windows/src/common/services/ConversationManager.cpp

#include "ConversationManager.h"
#include <libopenimsdk.h>
#include "../NimResult.h"
#include "../ZegoDataUtils.h"
#include "ConstDefine.h"
#include "Listen.h"

ConversationManagerService::ConversationManagerService() {
    m_serviceName = "conversationManager";
}

void ConversationManagerService::onMethodCalled(
    const std::string& method,
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (method == "setConversationListener") {
        setConversationListener(arguments, result);
    } else if (method == "getAllConversationList") {
        getAllConversationList(arguments, result);
    } else if (method == "getConversationListSplit") {
        getConversationListSplit(arguments, result);
    } else if (method == "getOneConversation") {
        getOneConversation(arguments, result);
    } else if (method == "getMultipleConversation") {
        getMultipleConversation(arguments, result);
    } else if (method == "setConversationDraft") {
        setConversationDraft(arguments, result);
    } else if (method == "hideConversation") {
        hideConversation(arguments, result);
    } else if (method == "markConversationMessageAsRead") {
        markConversationMessageAsRead(arguments, result);
    } else if (method == "getTotalUnreadMsgCount") {
        getTotalUnreadMsgCount(arguments, result);
    } else if (method == "getConversationIDBySessionType") {
        getConversationIDBySessionType(arguments, result);
    } else if (method == "clearConversationAndDeleteAllMsg") {
        clearConversationAndDeleteAllMsg(arguments, result);
    } else if (method == "deleteConversationAndDeleteAllMsg") {
        deleteConversationAndDeleteAllMsg(arguments, result);
    } else if (method == "getAtAllTag") {
        getAtAllTag(arguments, result);
    } else if (method == "hideAllConversations") {
        hideAllConversations(arguments, result);
    } else if (method == "searchConversation") {
        searchConversation(arguments, result);
    } else if (method == "changeInputStates") {
        changeInputStates(arguments, result);
    } else if (method == "getInputStates") {
        getInputStates(arguments, result);
    } else if (method == "setConversation") {
        setConversation(arguments, result);
    } else if (method == "searchConversations") {
        searchConversations(arguments, result);
    } else {
        result->NotImplemented();
    }
}

void ConversationManagerService::setConversationListener(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        set_conversation_listener(NewConversationListenerCallBack());
        result->Success(flutter::EncodableValue());
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getAllConversationList(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        get_all_conversation_list(NewBaseCallBack(result), operationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getConversationListSplit(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto offset = zego_value_get_int(arguments->at(flutter::EncodableValue("offset")));
        auto count = zego_value_get_int(arguments->at(flutter::EncodableValue("count")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        get_conversation_list_split(NewBaseCallBack(result), operationID_cs, offset, count);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getOneConversation(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto sessionType = zego_value_get_int(arguments->at(flutter::EncodableValue("sessionType")));
        auto sourceID = zego_value_get_string(arguments->at(flutter::EncodableValue("sourceID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* sourceID_cs = const_cast<char*>(sourceID.c_str());

        get_one_conversation(NewBaseCallBack(result), operationID_cs, sessionType, sourceID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getMultipleConversation(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationIDList = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationIDList")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationIDList_cs = const_cast<char*>(conversationIDList.c_str());

        get_multiple_conversation(NewBaseCallBack(result), operationID_cs, conversationIDList_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::setConversationDraft(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        auto draftText = zego_value_get_string(arguments->at(flutter::EncodableValue("draftText")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());
        char* draftText_cs = const_cast<char*>(draftText.c_str());

        set_conversation_draft(NewBaseCallBack(result), operationID_cs, conversationID_cs, draftText_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::hideConversation(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());

        hide_conversation(NewBaseCallBack(result), operationID_cs, conversationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::markConversationMessageAsRead(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());

        mark_conversation_message_as_read(NewBaseCallBack(result), operationID_cs, conversationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getTotalUnreadMsgCount(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        get_total_unread_msg_count(NewBaseCallBack(result), operationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getConversationIDBySessionType(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto sourceID = zego_value_get_string(arguments->at(flutter::EncodableValue("sourceID")));
        auto sessionType = zego_value_get_int(arguments->at(flutter::EncodableValue("sessionType")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* sourceID_cs = const_cast<char*>(sourceID.c_str());

        std::string conversationID = get_conversation_id_by_session_type(operationID_cs, sourceID_cs, sessionType);
        result->Success(flutter::EncodableValue(conversationID));
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::clearConversationAndDeleteAllMsg(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());

        clear_conversation_and_delete_all_msg(NewBaseCallBack(result), operationID_cs, conversationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::deleteConversationAndDeleteAllMsg(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());

        delete_conversation_and_delete_all_msg(NewBaseCallBack(result), operationID_cs, conversationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getAtAllTag(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        std::string tag = get_at_all_tag(operationID_cs);
        result->Success(flutter::EncodableValue(tag));
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::hideAllConversations(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());

        hide_all_conversations(NewBaseCallBack(result), operationID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::searchConversation(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto name = zego_value_get_string(arguments->at(flutter::EncodableValue("name")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* name_cs = const_cast<char*>(name.c_str());

        search_conversation(NewBaseCallBack(result), operationID_cs, name_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::changeInputStates(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        auto focus = zego_value_get_bool(arguments->at(flutter::EncodableValue("focus")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());

        change_input_states(NewBaseCallBack(result), operationID_cs, conversationID_cs, focus);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::getInputStates(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        auto userID = zego_value_get_string(arguments->at(flutter::EncodableValue("userID")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());
        char* userID_cs = const_cast<char*>(userID.c_str());

        get_input_states(NewBaseCallBack(result), operationID_cs, conversationID_cs, userID_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::setConversation(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto conversationID = zego_value_get_string(arguments->at(flutter::EncodableValue("conversationID")));
        auto req = zego_value_get_string(arguments->at(flutter::EncodableValue("req")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* conversationID_cs = const_cast<char*>(conversationID.c_str());
        char* req_cs = const_cast<char*>(req.c_str());

        set_conversation(NewBaseCallBack(result), operationID_cs, conversationID_cs, req_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void ConversationManagerService::searchConversations(
    const flutter::EncodableMap* arguments,
    std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
        auto name = zego_value_get_string(arguments->at(flutter::EncodableValue("name")));
        char* operationID_cs = const_cast<char*>(operationID.c_str());
        char* name_cs = const_cast<char*>(name.c_str());

        search_conversations(NewBaseCallBack(result), operationID_cs, name_cs);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}