Client.cpp

// Author: Kang Lin <kl222@126.com>
 
#include <QPluginLoader>
#include <QKeyEvent>
#include <QtPlugin>
#include <QFile>
#include <QApplication>
#include <QSettings>
#include <QLoggingCategory>
#include <QMessageBox>
#include <QCheckBox>
 
#include "Client.h"
#include "RabbitCommonDir.h"
#include "RabbitCommonTools.h"
#include "FrmParameterClient.h"
#include "FrmViewer.h"
#include "Channel.h"
#include "ParameterRecordUI.h"
 
static Q_LOGGING_CATEGORY(log, "Client")
 
CClient::CClient(QObject *parent, QString szFile) : QObject(parent)
    , m_FileVersion(1)  //TODO: update version it if update data
    , m_pHook(nullptr)
{
    bool check = false;
//#if defined (_DEBUG) || !defined(BUILD_SHARED_LIBS)
//    Q_INIT_RESOURCE(translations_Client);
//#endif
 
    m_Translator = RabbitCommon::CTools::Instance()->InstallTranslator(
        "Client", RabbitCommon::CTools::TranslationType::Library);
 
    CChannel::InitTranslation();
    m_szSettingsFile = szFile;
    m_pParameterClient = new CParameterClient();
    if(m_pParameterClient) {
        LoadSettings(m_szSettingsFile);
        check = connect(m_pParameterClient, &CParameterClient::sigNativeWindowRecieveKeyboard,
                        this, [&](){
            if(m_pParameterClient->GetNativeWindowReceiveKeyboard()) {
                if(m_pHook) {
                    m_pHook->UnRegisterKeyboard();
                    m_pHook->deleteLater();
                    m_pHook = nullptr;
                }
            } else {
                m_pHook = CHook::GetHook(m_pParameterClient, this);
                if(m_pHook)
                    m_pHook->RegisterKeyboard();
            }
        });
        m_pHook = CHook::GetHook(m_pParameterClient, this);
        if(m_pHook)
            m_pHook->RegisterKeyboard();
    } else {
        qCritical(log) << "new CParameterClient() fail";
        Q_ASSERT(m_pParameterClient);
    }
 
    LoadPlugins();
}
 
CClient::~CClient()
{
    qDebug(log) << "CClient::~CClient()";
    
    qApp->removeEventFilter(this);
    
    if(m_pHook) {
        m_pHook->UnRegisterKeyboard();
        m_pHook->deleteLater();
        m_pHook = nullptr;
    }
 
    if(m_pParameterClient) {
        m_pParameterClient->deleteLater();
        m_pParameterClient = nullptr;
    }
 
    if(m_Translator)
        RabbitCommon::CTools::Instance()->RemoveTranslator(m_Translator);
 
    CChannel::RemoveTranslation();
 
//#if defined (_DEBUG) || !defined(BUILD_SHARED_LIBS)
//    Q_CLEANUP_RESOURCE(translations_Client);
//#endif
}
 
int CClient::LoadPlugins()
{
    int nRet = 0;
    foreach (QObject *plugin, QPluginLoader::staticInstances())
    {
        CPluginClient* p = qobject_cast<CPluginClient*>(plugin);
        if(p)
        {
            if(m_Plugins.find(p->Id()) == m_Plugins.end())
            {
                qInfo(log) << "Success: Load plugin" << p->Name();
                AppendPlugin(p);
            }
            else
                qWarning(log) << "The plugin" << p->Name() << " is exist.";
        }
    }
 
    QString szPath = RabbitCommon::CDir::Instance()->GetDirPlugins();
#if !defined (Q_OS_ANDROID)
    szPath = szPath + QDir::separator() + "Client";
#endif
 
    QStringList filters;
#if defined (Q_OS_WINDOWS) || defined(Q_OS_WIN)
    filters << "*PluginClient*.dll";
#else
    filters << "*PluginClient*.so";
#endif
    nRet = FindPlugins(szPath, filters);
    if(!m_szDetails.isEmpty())
        m_szDetails = tr("### Plugins") + "\n" + m_szDetails;
 
    qDebug(log) << ("Client details:\n" + Details()).toStdString().c_str();
    return nRet;
}
 
int CClient::FindPlugins(QDir dir, QStringList filters)
{
    QString fileName;
    if(filters.isEmpty())
    {
#if defined (Q_OS_WINDOWS) || defined(Q_OS_WIN)
        filters << "*PluginClient*.dll";
#else
        filters << "*PluginClient*.so";
#endif
    }
 
    QString szCurrentPath = QDir::currentPath();
    QStringList files = dir.entryList(filters, QDir::Files | QDir::NoDotAndDotDot);
    if(!files.isEmpty())
    {
        //This method is invalid
        //QCoreApplication::addLibraryPath(QDir::cleanPath(dir.absolutePath()));
 
        QDir::setCurrent(QDir::cleanPath(dir.absolutePath()));
 
        // This method is valid
//#if defined(Q_OS_WINDOWS)
//        QString szPath = QString::fromLocal8Bit(qgetenv("PATH"));
//        szPath += ";";
//        szPath += QDir::cleanPath(dir.absolutePath());
//        qputenv("PATH", szPath.toLatin1());
//#endif
    }
 
    foreach (fileName, files) {
        QString szPlugins = dir.absoluteFilePath(fileName);
        QPluginLoader loader(szPlugins);
        QObject *plugin = loader.instance();
        if (plugin) {
            CPluginClient* p = qobject_cast<CPluginClient*>(plugin);
            if(p)
            {
                if(m_Plugins.find(p->Id()) == m_Plugins.end())
                {
                    qInfo(log) << "Success: Load plugin"
                                  << p->Name() << "from" << szPlugins;
                    AppendPlugin(p);
                }
                else
                    qWarning(log) << "The plugin [" << p->Name() << "] is exist.";
            }
        }else{
            QString szMsg;
            szMsg = "Error: Load plugin fail from " + szPlugins;
            if(!loader.errorString().isEmpty())
                szMsg += "; Error: " + loader.errorString();
            qCritical(log) << szMsg.toStdString().c_str();
        }
    }
 
    foreach (fileName, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot)) {
        QDir pluginDir = dir;
        if(pluginDir.cd(fileName))
            FindPlugins(pluginDir, filters);
    }
 
    QDir::setCurrent(szCurrentPath);
 
    return 0;
}
 
int CClient::AppendPlugin(CPluginClient *p)
{
    if(!p) return -1;
    m_Plugins.insert(p->Id(), p);
    //p->InitTranslator();
    int val = 0;
    bool bRet = QMetaObject::invokeMethod(
        p,
        "InitTranslator",
        Qt::DirectConnection,
        Q_RETURN_ARG(int, val));
    if(!bRet || val)
    {
        qCritical(log) << "The plugin" <<  p->Name()
                       << "initial translator fail" << bRet << val;
    }
 
    m_szDetails += "#### " + p->DisplayName() + "\n"
              + tr("Version:") + " " + p->Version() + "  \n"
              + p->Description() + "\n";
    if(!p->Details().isEmpty())
        m_szDetails += p->Details() + "\n";
 
    return 0;
}
 
CConnecter* CClient::CreateConnecter(const QString& id)
{
    CConnecter* pConnecter = nullptr;
    auto it = m_Plugins.find(id);
    if(m_Plugins.end() != it)
    {
        bool bRet = 0;
        qDebug(log) << "CreateConnecter id:" << id;
        auto plugin = it.value();
        if(plugin) {
            //p = plugin->CreateConnecter(id);
            bRet = QMetaObject::invokeMethod(
                plugin,
                "CreateConnecter",
                Qt::DirectConnection,
                Q_RETURN_ARG(CConnecter*, pConnecter),
                Q_ARG(QString, id),
                Q_ARG(CParameterClient*, m_pParameterClient));
            if(!bRet) {
                qCritical(log) << "Create CConnecter fail.";
                return nullptr;
            }
        }
    }
    return pConnecter;
}
 
int CClient::DeleteConnecter(CConnecter *p)
{
    qDebug(log) << Q_FUNC_INFO;
    if(!p) return 0;
 
    CPluginClient* pPluginClient = nullptr;
    //pPluginClient->GetPlugClient();
    bool bRet = QMetaObject::invokeMethod(
        p,
        "GetPlugClient",
        Qt::DirectConnection,
        Q_RETURN_ARG(CPluginClient*, pPluginClient));
 
    if(bRet && pPluginClient) {
        int nRet = 0;
        //pPluginClient->DeleteConnecter(p);
        bRet = QMetaObject::invokeMethod(
            pPluginClient,
            "DeleteConnecter",
            Qt::DirectConnection,
            Q_RETURN_ARG(int, nRet),
            Q_ARG(CConnecter*, p));
        if(!bRet) {
            nRet = -1;
            qCritical(log) << "Call pPluginClient->DeleteConnecter(p) fail";
        }
        return nRet;
    }
 
    qCritical(log) << "Get CClient fail.";
    return -1;
}
 
CConnecter* CClient::LoadConnecter(const QString &szFile)
{
    CConnecter* pConnecter = nullptr;
    if(szFile.isEmpty()) return nullptr;
 
    QSettings set(szFile, QSettings::IniFormat);
    m_FileVersion = set.value("Manage/FileVersion", m_FileVersion).toInt();
    QString id = set.value("Plugin/ID").toString();
    QString protocol = set.value("Plugin/Protocol").toString();
    QString name = set.value("Plugin/Name").toString();
    Q_UNUSED(name);
    qDebug(log) << "LoadConnecter protocol:" << protocol
                << "name:" << name << "id:" << id;
    pConnecter = CreateConnecter(id);
    if(pConnecter) {
        int nRet = false;
        //bRet = pConnecter->Load(szFile);
        bool bRet = QMetaObject::invokeMethod(
            pConnecter,
            "Load",
            Qt::DirectConnection,
            Q_RETURN_ARG(int, nRet),
            Q_ARG(QString, szFile));
        if(!bRet) {
            qCritical(log) << "Call pConnecter->Load(szFile) fail.";
            return nullptr;
        }
        if(nRet) {
            qCritical(log) << "Load parameter fail" << nRet;
            DeleteConnecter(pConnecter);
            return nullptr;
        }
        pConnecter->SetSettingsFile(szFile);
    }
    else
        qCritical(log) << "Don't create connecter:" << protocol;
 
    return pConnecter;
}
 
int CClient::SaveConnecter(CConnecter *pConnecter)
{
    if(!pConnecter) return -1;
 
    QString szFile = pConnecter->GetSettingsFile();
    if(szFile.isEmpty())
        szFile = RabbitCommon::CDir::Instance()->GetDirUserData()
                + QDir::separator()
                + pConnecter->Id()
                + ".rrc";
 
    QSettings set(szFile, QSettings::IniFormat);
 
    CPluginClient* pPluginClient = nullptr; //pConnecter->m_pPluginClient;
    bool bRet = QMetaObject::invokeMethod(
        pConnecter,
        "GetPlugClient",
        Qt::DirectConnection,
        Q_RETURN_ARG(CPluginClient*, pPluginClient));
    if(!bRet || !pPluginClient)
    {
        qCritical(log) << "Get plugin client fail";
    }
    Q_ASSERT(pPluginClient);
 
    set.setValue("Manage/FileVersion", m_FileVersion);
    set.setValue("Plugin/ID", pPluginClient->Id());
    set.setValue("Plugin/Protocol", pPluginClient->Protocol());
    set.setValue("Plugin/Name", pPluginClient->Name());
    int nRet = 0;
    //nRet = pConnecter->Save(szFile);
    bRet = QMetaObject::invokeMethod(
        pConnecter,
        "Save",
        Qt::DirectConnection,
        Q_RETURN_ARG(int, nRet),
        Q_ARG(QString, szFile));
    if(!bRet) {
        qCritical(log) << "Call pConnecter->Save(szFile) fail.";
        return -1;
    }
    if(nRet) {
        qCritical(log) << "Save parameter fail" << nRet;
        return -2;
    }
    return 0;
}
 
int CClient::LoadSettings(const QString szFile)
{
    if(!m_pParameterClient) {
        qCritical(log) << "The m_pParameterClient is nullptr";
        Q_ASSERT_X(m_pParameterClient, "CClient", "The m_pParameterClient is nullptr");
        return -1;
    }
 
    QString s = szFile;
    if(s.isEmpty())
        s = m_szSettingsFile;
    return m_pParameterClient->CParameter::Load(s);
}
 
int CClient::SaveSettings(const QString szFile)
{
    if(!m_pParameterClient) {
        qCritical(log) << "The m_pParameterClient is nullptr";
        Q_ASSERT_X(m_pParameterClient, "CClient", "The m_pParameterClient is nullptr");
        return -1;
    }
 
    QString s = szFile;
    if(s.isEmpty())
        s = m_szSettingsFile;
    return m_pParameterClient->CParameter::Save(s);
}
 
QList<QWidget*> CClient::GetSettingsWidgets(QWidget* parent)
{
    QList<QWidget*> lstWidget;
 
    CFrmParameterClient* pClient = new CFrmParameterClient(parent);
    if(pClient) {
        pClient->SetParameter(m_pParameterClient);
        lstWidget.push_back(pClient);
    }
 
    CParameterRecordUI* pRecord = new CParameterRecordUI(parent);
    if(pRecord) {
        pRecord->SetParameter(&m_pParameterClient->m_Record);
        lstWidget.push_back(pRecord);
    }
 
    return lstWidget;
}
 
int CClient::EnumPlugins(Handle *handle)
{
    int nRet = 0;
    QMap<QString, CPluginClient*>::iterator it;
    for(it = m_Plugins.begin(); it != m_Plugins.end(); it++)
    {
        nRet = handle->onProcess(it.key(), it.value());
        if(nRet)
            return nRet;
    }
    return nRet;
}
 
#if HAS_CPP_11
int CClient::EnumPlugins(std::function<int(const QString &, CPluginClient *)> cb)
{
    int nRet = 0;
    QMap<QString, CPluginClient*>::iterator it;
    for(it = m_Plugins.begin(); it != m_Plugins.end(); it++)
    {
        nRet = cb(it.key(), it.value());
        if(nRet)
            return nRet;
    }
    return nRet;
}
#endif
 
const QString CClient::Details() const
{
    return m_szDetails;
}