src/WeChatOcrCpp/XPluginManager.cpp

#include "XPluginManager.h"
#include <stdexcept>
#include <iostream>

XPluginManager::XPluginManager() : isMmmojoEnvInited(false), intPtrMmmojoEnv(nullptr), intPtrUserData(nullptr), intPtrOcrExePath(nullptr) {
}

XPluginManager::~XPluginManager() {
    if (isMmmojoEnvInited) {
        StopMmMojoEnv();
    }
    
    // 释放分配的内存
    if (intPtrOcrExePath != nullptr) {
        free(intPtrOcrExePath);
        intPtrOcrExePath = nullptr;
    }
}

void XPluginManager::SetExePath(const std::string& exePath) {
    const std::string ocrExeName = "WeChatOCR.exe";
    std::string fullPath = exePath;
    
    // 检查路径是否以exe结尾，如果不是，则添加exe名称
    if (fullPath.find(ocrExeName) == std::string::npos) {
        if (fullPath.back() != '\\') {
            fullPath += "\\";
        }
        fullPath += ocrExeName;
    }
    
    // 检查文件是否存在
    FILE* file = fopen(fullPath.c_str(), "r");
    if (!file) {
        throw std::runtime_error("指定的 " + ocrExeName + " 路径不存在!");
    }
    fclose(file);
    
    // 释放之前分配的内存
    if (intPtrOcrExePath != nullptr) {
        free(intPtrOcrExePath);
    }
    
    // 分配内存并复制路径
    size_t len = fullPath.length() + 1;
    intPtrOcrExePath = malloc(len * sizeof(wchar_t));
    if (intPtrOcrExePath == nullptr) {
        throw std::runtime_error("内存分配失败");
    }
    
    // 将路径转换为宽字符并存储
    mbstowcs((wchar_t*)intPtrOcrExePath, fullPath.c_str(), len);
}

void XPluginManager::AppendSwitchNativeCmdLine(const std::string& arg, const std::string& value) {
    m_switch_native[arg] = value;
}

void XPluginManager::SetCommandLine(const std::vector<std::string>& cmdline) {
    cmdLines = cmdline;
}

void XPluginManager::SetOneCallback(const std::string& name, void* func) {
    callbacks[name] = func;
}

void XPluginManager::SetCallbacks(const std::map<std::string, void*>& callBacks) {
    for (const auto& callback : callBacks) {
        callbacks[callback.first] = callback.second;
    }
}

void XPluginManager::SetCallbackUsrData(void* cbUsrData) {
    intPtrUserData = cbUsrData;
}

void XPluginManager::InitMmMojoEnv() {
    // 检查OCR可执行文件路径是否设置
    if (intPtrOcrExePath == nullptr) {
        throw std::runtime_error("OCR可执行文件路径未设置");
    }
    
    // 检查文件是否存在
    wchar_t* exePath = (wchar_t*)intPtrOcrExePath;
    FILE* file = _wfopen(exePath, L"r");
    if (!file) {
        throw std::runtime_error("给定的 WeChatOcr.exe 路径错误");
    }
    fclose(file);
    
    // 如果环境已经初始化，则直接返回
    if (isMmmojoEnvInited && intPtrMmmojoEnv != nullptr) {
        return;
    }
    
    // 初始化MMMojo环境
    MmmojoDll::InitializeMMMojo(0, nullptr);
    intPtrMmmojoEnv = MmmojoDll::CreateMMMojoEnvironment();
    if (intPtrMmmojoEnv == nullptr) {
        throw std::runtime_error("CreateMMMojoEnvironment 失败!");
    }
    
    // 设置回调用户数据
    MmmojoDll::SetMMMojoEnvironmentCallbacks(intPtrMmmojoEnv, (int)MMMojoCallbackType::kMMUserData, intPtrUserData);
    
    // 设置默认回调
    SetDefaultCallbacks();
    
    // 设置环境初始化参数
    MmmojoDll::SetMMMojoEnvironmentInitParams(intPtrMmmojoEnv, (int)MMMojoEnvironmentInitParamType::kMMHostProcess, (void*)1);
    MmmojoDll::SetMMMojoEnvironmentInitParams(intPtrMmmojoEnv, (int)MMMojoEnvironmentInitParamType::kMMExePath, intPtrOcrExePath);
    
    // 添加命令行开关
    for (const auto& item : m_switch_native) {
        // 分配内存并转换字符串
        char* keyPtr = _strdup(item.first.c_str());
        wchar_t* valuePtr = (wchar_t*)malloc((item.second.length() + 1) * sizeof(wchar_t));
        mbstowcs(valuePtr, item.second.c_str(), item.second.length() + 1);
        
        // 添加开关
        MmmojoDll::AppendMMSubProcessSwitchNative(intPtrMmmojoEnv, keyPtr, valuePtr);
        
        // 释放内存
        free(keyPtr);
        free(valuePtr);
    }
    
    // 启动环境
    MmmojoDll::StartMMMojoEnvironment(intPtrMmmojoEnv);
    isMmmojoEnvInited = true;
}

void XPluginManager::SetDefaultCallbacks() {
    // 设置默认回调
    for (int type = 1; type <= (int)MMMojoCallbackType::kMMRemoteMojoError; type++) {
        try {
            std::string fName;
            switch ((MMMojoCallbackType)type) {
                case MMMojoCallbackType::kMMReadPush: fName = "kMMReadPush"; break;
                case MMMojoCallbackType::kMMReadPull: fName = "kMMReadPull"; break;
                case MMMojoCallbackType::kMMReadShared: fName = "kMMReadShared"; break;
                case MMMojoCallbackType::kMMRemoteConnect: fName = "kMMRemoteConnect"; break;
                case MMMojoCallbackType::kMMRemoteDisconnect: fName = "kMMRemoteDisconnect"; break;
                case MMMojoCallbackType::kMMRemoteProcessLaunched: fName = "kMMRemoteProcessLaunched"; break;
                case MMMojoCallbackType::kMMRemoteProcessLaunchFailed: fName = "kMMRemoteProcessLaunchFailed"; break;
                case MMMojoCallbackType::kMMRemoteMojoError: fName = "kMMRemoteMojoError"; break;
                default: continue;
            }
            
            void* callback = defaultCallbacks.callbacks[fName];
            
            // 如果用户设置了自定义回调，则使用用户的回调
            auto it = callbacks.find(fName);
            if (it != callbacks.end()) {
                callback = it->second;
            }
            
            // 设置回调
            MmmojoDll::SetMMMojoEnvironmentCallbacks(intPtrMmmojoEnv, type, callback);
        }
        catch (const std::exception& ex) {
            std::cerr << ex.what() << std::endl;
        }
    }
}

void XPluginManager::StopMmMojoEnv() {
    if (!isMmmojoEnvInited || intPtrMmmojoEnv == nullptr) {
        return;
    }
    
    MmmojoDll::StopMMMojoEnvironment(intPtrMmmojoEnv);
    MmmojoDll::RemoveMMMojoEnvironment(intPtrMmmojoEnv);
    intPtrMmmojoEnv = nullptr;
    isMmmojoEnvInited = false;
}

void XPluginManager::SendPbSerializedData(const unsigned char* pbData, int pbSize, int method, int sync, unsigned int requestId) {
    void* writeInfo = MmmojoDll::CreateMMMojoWriteInfo(method, sync, requestId);
    void* request = MmmojoDll::GetMMMojoWriteInfoRequest(writeInfo, (unsigned int)pbSize);
    
    // 复制数据
    memcpy(request, pbData, pbSize);
    
    // 发送数据
    MmmojoDll::SendMMMojoWriteInfo(intPtrMmmojoEnv, writeInfo);
}

void* XPluginManager::GetPbSerializedData(void* requestInfo, unsigned int* dataSize) {
    return MmmojoDll::GetMMMojoReadInfoRequest(requestInfo, dataSize);
}

void* XPluginManager::GetReadInfoAttachData(void* requestInfo, unsigned int* dataSize) {
    return MmmojoDll::GetMMMojoReadInfoAttach(requestInfo, dataSize);
}

void XPluginManager::RemoveReadInfo(void* requestInfo) {
    MmmojoDll::RemoveMMMojoReadInfo(requestInfo);
}