Manager.cpp

// Author: Kang Lin <kl222@126.com>
 
#include <QPluginLoader>
#include <QKeyEvent>
#include <QtPlugin>
#include <QFile>
#include <QTemporaryFile>
#include <QApplication>
#include <QSettings>
#include <QLoggingCategory>
#include <QMessageBox>
#include <QCheckBox>
 
#include "RabbitCommonDir.h"
#include "RabbitCommonTools.h"
#include "ParameterPluginUI.h"
#include "ParameterRecordUI.h"
#if defined(HAVE_QTERMWIDGET)
    #include "ParameterTerminalUI.h"
    #include "OperateTerminal.h"
#endif
#ifdef HAVE_LIBSSH
    #include "ChannelSSH.h"
#endif
 
#if HAVE_QTKEYCHAIN
    #include "keychain.h"
#endif
 
#include "FrmMediaDevices.h"
#include "ParameterFilter.h"
#include "FrmManagePlugins.h"
 
#include "ParameterDatabaseUI.h"
#include "ParameterPlugin.h"
 
#include "Channel.h"
#include "Manager.h"
 
static Q_LOGGING_CATEGORY(log, "Manager")
 
CManager::CManager(QObject *parent) : QObject(parent)
    , m_FileVersion(1)  //TODO: update version it if update data
    , m_pHook(nullptr)
    , m_pParameterPlugin(nullptr)
    , m_pDatabaseFile(nullptr)
{
}
 
CManager::~CManager()
{
    qDebug(log) << "CManager::~CManager()";
 
    qApp->removeEventFilter(this);
 
    if(m_pHook) {
        m_pHook->UnRegisterKeyboard();
        m_pHook->deleteLater();
        m_pHook = nullptr;
    }
 
    if(m_pParameterPlugin) {
        m_pParameterPlugin->deleteLater();
        m_pParameterPlugin = nullptr;
    }
 
    if(m_Translator)
        RabbitCommon::CTools::Instance()->RemoveTranslator(m_Translator);
 
    CChannel::RemoveTranslation();
 
    //#if defined (_DEBUG) || !defined(BUILD_SHARED_LIBS)
    //    Q_CLEANUP_RESOURCE(translations_Plugin);
    //#endif
}
 
int CManager::Initial(QString szFile)
{
    bool check = false;
    //#if defined (_DEBUG) || !defined(BUILD_SHARED_LIBS)
    //    Q_INIT_RESOURCE(translations_Plugin);
    //#endif
    
    m_Translator = RabbitCommon::CTools::Instance()->InstallTranslator(
        "Plugin", RabbitCommon::CTools::TranslationType::Library);
 
    m_szSettingsFile = szFile;
 
    CChannel::InitTranslation();
 
    m_pParameterPlugin = new CParameterPlugin();
    if(m_pParameterPlugin) {
        LoadSettings(m_szSettingsFile);
        
        bool bReboot = true;
        QString szSnap;
        QString szFlatpak;
#if defined(Q_OS_ANDROID)
        bReboot = false;
#endif
#if QT_VERSION > QT_VERSION_CHECK(6, 0, 0) && defined(Q_OS_WIN)
        szSnap = qEnvironmentVariable("SNAP");
        szFlatpak = qEnvironmentVariable("FLATPAK_ID");
#else
        szSnap = QString::fromLocal8Bit(qgetenv("SNAP"));
        szFlatpak = QString::fromLocal8Bit(qgetenv("FLATPAK_ID"));
#endif
        if(!szSnap.isEmpty() || !szFlatpak.isEmpty())
            bReboot = false;
        if(bReboot && !RabbitCommon::CTools::Instance()->HasAdministratorPrivilege()
            && m_pParameterPlugin->GetPromptAdministratorPrivilege())
        {
            int nRet = 0;
            QString szMsg;
            szMsg = tr("The programe is not administrator privilege.\n"
                       "Some features are limited.\n");
#if defined(Q_OS_WIN)
            szMsg += tr("Eg: Can not disable system shortcuts(eg: Ctrl+Alt+del).") + "\n";
#else
            szMsg += tr("Eg: Can not use the wake on LAN feature.") + "\n";
#endif
            szMsg += tr("Restart program by administrator?");
            QMessageBox msg(QMessageBox::Warning, tr("Warning"), szMsg,
                            QMessageBox::Yes | QMessageBox::No);
            msg.setCheckBox(new QCheckBox(tr("Always shown"), &msg));
            msg.checkBox()->setCheckable(true);
            msg.checkBox()->setChecked(
                m_pParameterPlugin->GetPromptAdministratorPrivilege());
            nRet = msg.exec();
            
            m_pParameterPlugin->SetPromptAdministratorPrivilege(
                msg.checkBox()->isChecked());
            SaveSettings(m_szSettingsFile);
            
            if(QMessageBox::Yes == nRet) {
                RabbitCommon::CTools::Instance()->StartWithAdministratorPrivilege(true);
                return 0;
            }
        }
        
        check = connect(m_pParameterPlugin, SIGNAL(sigCaptureAllKeyboard()),
                        this, SLOT(slotCaptureAllKeyboard()));
        Q_ASSERT(check);
        if(m_pParameterPlugin->GetCaptureAllKeyboard()) {
            m_pHook = CHook::GetHook(m_pParameterPlugin, this);
            if(m_pHook)
                m_pHook->RegisterKeyboard();
        }
    } else {
        qCritical(log) << "new CParameterPlugin() fail";
        Q_ASSERT(m_pParameterPlugin);
    }
    
    LoadPlugins();
 
    m_pDatabaseFile = new CDatabaseFile(this);
    if(m_pDatabaseFile) {
        CParameterDatabase* pDB = nullptr;
        if(GetGlobalParameters())
            pDB = GetGlobalParameters()->m_pDatabase;
        m_pDatabaseFile->OpenDatabase(pDB);
    }
 
    return 0;
}
 
int CManager::LoadPlugins()
{
    int nRet = 0;
    /*
    foreach (QObject *plugin, QPluginLoader::staticInstances())
    {
        CPlugin* p = qobject_cast<CPlugin*>(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.";
        }
    }//*/
 
    QStringList lstPaths;
    if(m_pParameterPlugin->GetEnableSetPluginsPath()) {
        lstPaths = m_pParameterPlugin->GetPluginsPath();
    }
    else
        lstPaths << RabbitCommon::CDir::Instance()->GetDirPlugins();
    if(lstPaths.isEmpty())
        qWarning(log) << "The plugins path is empty. please set it from: `Menu` -> `Tools` -> `Settings` -> `Load Plugins`";
 
    if(m_pParameterPlugin->GetOnlyLoadInWhitelist()) {
        m_pParameterPlugin->m_WhiteList.OnProcess([this, lstPaths](const QString& szPath) -> int{
            QFileInfo fi(szPath);
            if(fi.isAbsolute())
                return LoadPlugin(szPath);
            foreach (auto d, lstPaths) {
                if(d.isEmpty()) continue;
                QString szFile = d + QDir::separator() + szPath;
                return LoadPlugin(szFile);
            }
            return -1;
        });
        return 0;
    }
 
    foreach (auto szPath, lstPaths) {
        //QString szPath = RabbitCommon::CDir::Instance()->GetDirPlugins();
 
        QStringList filters;
        if(filters.isEmpty())
        {
#if defined (Q_OS_WINDOWS) || defined(Q_OS_WIN)
            filters << "*Plugin*.dll";
#elif defined(Q_OS_MACOS) || defined(Q_OS_MAC)
            filters << "*Plugin*.dylib";
#else
            filters << "*Plugin*.so";
#endif
        }
        nRet = FindPlugins(szPath, filters);
    }
 
    if(m_Plugins.empty()) {
        qWarning(log) << "The plugins is empty. please set it from: `Menu` -> `Tools` -> `Settings` -> `Load Plugins`";
    }
 
    if(!m_szDetails.isEmpty())
        m_szDetails = "## " + tr("Plugins") + "\n" + m_szDetails;
 
    qDebug(log) << ("Client details:\n" + Details()).toStdString().c_str();
    return 0;
}
 
int CManager::FindPlugins(QDir dir, QStringList filters)
{
    QString fileName;
 
    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);
        if(m_pParameterPlugin
            && (!m_pParameterPlugin->m_WhiteList.contains(szPlugins) || !m_pParameterPlugin->m_WhiteList.contains(fileName))
            && (m_pParameterPlugin->m_BlackList.contains(szPlugins) || m_pParameterPlugin->m_BlackList.contains(fileName))) {
            qInfo(log) << "Filter:" << szPlugins << "in blacklist";
            continue;
        }
        LoadPlugin(szPlugins);
    }
 
    foreach (fileName, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot)) {
        QDir pluginDir = dir;
        if(pluginDir.cd(fileName))
            FindPlugins(pluginDir, filters);
    }
 
    QDir::setCurrent(szCurrentPath);
 
    return 0;
}
 
int CManager::LoadPlugin(const QString &szPath)
{
    int nRet = -1;
    QPluginLoader loader(szPath);
    QObject *plugin = loader.instance();
    if (plugin) {
        CPlugin* p = qobject_cast<CPlugin*>(plugin);
        if(p)
        {
            if(m_Plugins.find(p->Id()) == m_Plugins.end())
            {
                qInfo(log) << "Success: Load plugin"
                           << p->Name() << "from" << szPath;
                AppendPlugin(p);
            }
            else
                qWarning(log) << "The plugin [" << p->Name() << "] is exist.";
            return 0;
        } else
            qCritical(log) << "The plugin is not \"CPlugin\":" << szPath;
    } else {
        QString szMsg;
        szMsg = "Error: Load plugin fail from " + szPath;
        if(!loader.errorString().isEmpty())
            szMsg += "; Error: " + loader.errorString();
        qCritical(log) << szMsg.toStdString().c_str();
    }
    return nRet;
}
 
int CManager::AppendPlugin(CPlugin *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";
 
    bRet = connect(p, &CPlugin::sigNewOperate, this, &CManager::sigNewOperate);
    return 0;
}
 
COperate* CManager::CreateOperate(const QString& id)
{
    COperate* pOperate = nullptr;
    auto it = m_Plugins.find(id);
    if(m_Plugins.end() != it)
    {
        bool bRet = 0;
        qDebug(log) << "CreateOperate id:" << id;
        auto plugin = it.value();
        if(plugin) {
            //p = plugin->CreateOperate(id);
            bRet = QMetaObject::invokeMethod(
                plugin,
                "CreateOperate",
                Qt::DirectConnection,
                Q_RETURN_ARG(COperate*, pOperate),
                Q_ARG(QString, id),
                Q_ARG(CParameterPlugin*, m_pParameterPlugin));
            if(!bRet) {
                qCritical(log) << "Create COperate fail.";
                return nullptr;
            }
        }
    }
    return pOperate;
}
 
int CManager::DeleteOperate(COperate *p)
{
    qDebug(log) << Q_FUNC_INFO;
    if(!p) return 0;
    
    CPlugin* pPlugin = nullptr;
    //pPlugin->GetPlugin();
    bool bRet = QMetaObject::invokeMethod(
        p,
        "GetPlugin",
        Qt::DirectConnection,
        Q_RETURN_ARG(CPlugin*, pPlugin));
    
    if(bRet && pPlugin) {
        int nRet = 0;
        //pPlugin->DeleteOperate(p);
        bRet = QMetaObject::invokeMethod(
            pPlugin,
            "DeleteOperate",
            Qt::DirectConnection,
            Q_RETURN_ARG(int, nRet),
            Q_ARG(COperate*, p));
        if(!bRet) {
            nRet = -1;
            qCritical(log) << "Call pPlugin->DeleteOperate(p) fail";
        }
        return nRet;
    }
    
    qCritical(log) << "Get CManager fail.";
    return -1;
}
 
COperate* CManager::LoadOperate(const QString &szFile)
{
    COperate* pOperate = nullptr;
    if(szFile.isEmpty()) return nullptr;
    qDebug(log) << "Load operate configure file:"<< szFile;
    if(m_pParameterPlugin->GetGlobalParameters()->GetSaveSettingsType()
        == CParameterGlobal::SaveSettingsType::Database) {
        QByteArray content = m_pDatabaseFile->Load(szFile);
        if(!content.isEmpty()) {
            QFile f(szFile);
            if(!f.open(QFile::WriteOnly | QFile::Text)) return nullptr;
            f.write(content.data(), content.length());
            f.close();
        }
    }
 
    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();
    qDebug(log) << "LoadOperate protocol:" << protocol
                << "name:" << name << "id:" << id;
    pOperate = CreateOperate(id);
    if(pOperate) {
        int nRet = false;
        //bRet = pOperate->Load(szFile);
        bool bRet = QMetaObject::invokeMethod(
            pOperate,
            "Load",
            Qt::DirectConnection,
            Q_RETURN_ARG(int, nRet),
            Q_ARG(QString, szFile));
        if(!bRet) {
            qCritical(log) << "Call pOperate->Load(szFile) fail.";
            return nullptr;
        }
        if(nRet) {
            qCritical(log) << "Load parameter fail" << nRet;
            DeleteOperate(pOperate);
            return nullptr;
        }
        pOperate->SetSettingsFile(szFile);
    }
    else
        qCritical(log) << "Don't create Operate:" << name << protocol << id << szFile;
 
    return pOperate;
}
 
int CManager::SaveOperate(COperate *pOperate)
{
    if(!pOperate) return -1;
    
    QString szFile = pOperate->GetSettingsFile();
    if(szFile.isEmpty())
        szFile = RabbitCommon::CDir::Instance()->GetDirUserData()
                 + QDir::separator()
                 + pOperate->Id()
                 + ".rrc";
 
    QSettings set(szFile, QSettings::IniFormat);
    CPlugin* pPlugin = nullptr; //pOperate->GetPlugin;
    bool bRet = QMetaObject::invokeMethod(
        pOperate,
        "GetPlugin",
        Qt::DirectConnection,
        Q_RETURN_ARG(CPlugin*, pPlugin));
    if(!bRet || !pPlugin)
    {
        qCritical(log) << "Get plugin client fail";
    }
    Q_ASSERT(pPlugin);
 
    set.setValue("Manage/FileVersion", m_FileVersion);
    set.setValue("Plugin/ID", pPlugin->Id());
    set.setValue("Plugin/Protocol", pPlugin->Protocol());
    set.setValue("Plugin/Name", pPlugin->Name());
    int nRet = 0;
    //nRet = pOperate->Save(szFile);
    bRet = QMetaObject::invokeMethod(
        pOperate,
        "Save",
        Qt::DirectConnection,
        Q_RETURN_ARG(int, nRet),
        Q_ARG(QString, szFile));
    if(!bRet) {
        qCritical(log) << "Call pOperate->Save(szFile) fail.";
        return -1;
    }
    if(nRet) {
        qCritical(log) << "Save parameter fail" << nRet;
        return -2;
    }
 
    if(m_pParameterPlugin->GetGlobalParameters()->GetSaveSettingsType()
        == CParameterGlobal::SaveSettingsType::Database) {
        return m_pDatabaseFile->Save(szFile) ? 0 : -1;
    }
 
    return 0;
}
 
int CManager::LoadSettings(const QString szFile)
{
    if(!m_pParameterPlugin) {
        qCritical(log) << "The m_pParameter is nullptr";
        Q_ASSERT_X(m_pParameterPlugin, "CManager", "The m_pParameter is nullptr");
        return -1;
    }
 
    QString s = szFile;
    if(s.isEmpty())
        s = m_szSettingsFile;
    return m_pParameterPlugin->Load(s);
}
 
int CManager::SaveSettings(const QString szFile)
{
    if(!m_pParameterPlugin) {
        qCritical(log) << "The m_pParameter is nullptr";
        Q_ASSERT_X(m_pParameterPlugin, "CManager", "The m_pParameter is nullptr");
        return -1;
    }
 
    QString s = szFile;
    if(s.isEmpty())
        s = m_szSettingsFile;
    return m_pParameterPlugin->Save(s);
}
 
CParameterGlobal* CManager::GetGlobalParameters()
{
    if(m_pParameterPlugin)
        return m_pParameterPlugin->GetGlobalParameters();
    return nullptr;
}
 
QList<QWidget*> CManager::GetSettingsWidgets(QWidget* parent)
{
    QList<QWidget*> lstWidget;
 
    CFrmManagePlugins* pManagePlugins = new CFrmManagePlugins(parent);
    if(pManagePlugins) {
        pManagePlugins->SetParameter(m_pParameterPlugin);
        lstWidget.push_back(pManagePlugins);
    }
 
    CParameterPluginUI* pClient = new CParameterPluginUI(parent);
    if(pClient) {
        pClient->SetParameter(m_pParameterPlugin);
        lstWidget.push_back(pClient);
    }
 
    auto pDatabase = new CParameterDatabaseUI(parent);
    if(pDatabase) {
        if(GetGlobalParameters())
            pDatabase->SetParameter(GetGlobalParameters()->m_pDatabase);
        lstWidget.push_back(pDatabase);
    }
 
#if defined(HAVE_QTERMWIDGET)
    CParameterTerminalUI* pTermina = new CParameterTerminalUI(parent);
    if(pTermina) {
        pTermina->SetParameter(&m_pParameterPlugin->m_Terminal);
        pTermina->setWindowTitle(tr("Terminal"));
        lstWidget.push_back(pTermina);
    }
#endif
    CParameterRecordUI* pRecord = new CParameterRecordUI(parent);
    if(pRecord) {
        pRecord->SetParameter(&m_pParameterPlugin->m_Record);
        lstWidget.push_back(pRecord);
    }
 
    CFrmMediaDevices* pMediaDevices = new CFrmMediaDevices(parent);
    if(pMediaDevices) {
        pMediaDevices->SetParameter(&m_pParameterPlugin->m_MediaDevices.m_Para);
        lstWidget.push_back(pMediaDevices);
    }
 
    foreach(auto plugin, m_Plugins) {
        if(!plugin) continue;
        QWidget* pSettings = nullptr;
        bool bRet = QMetaObject::invokeMethod(
            plugin,
            "GetSettingsWidget",
            Qt::DirectConnection,
            Q_RETURN_ARG(QWidget*, pSettings),
            Q_ARG(QWidget*, parent));
        if(!bRet) {
            qCritical(log) << "Call CPlugin::GetSettingsWidget() fail.";
            continue;
        }
        if(!pSettings) continue;
        lstWidget.push_back(pSettings);
    }
 
    return lstWidget;
}
 
int CManager::EnumPlugins(Handle *handle)
{
    int nRet = 0;
    QMap<QString, CPlugin*>::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 CManager::EnumPlugins(std::function<int(const QString &, CPlugin *)> cb)
{
    int nRet = 0;
    QMap<QString, CPlugin*>::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 CManager::Details() const
{
    QString szDetail;
#if HAVE_QTERMWIDGET
    szDetail += COperateTerminal::Details();
#endif
#ifdef HAVE_LIBSSH
    CChannelSSH channel(nullptr, nullptr);
    szDetail += channel.GetDetails();
#endif
#if HAVE_QTKEYCHAIN
    szDetail += "- QtKeyChain\n" +
        QString("  - ") + tr("Version:")
                + " 0x" + QString::number(QTKEYCHAIN_VERSION, 16) + "\n";
#endif
 
    if(!szDetail.isEmpty()) {
        szDetail = "## " + tr("Dependency libraries:") + "\n" + szDetail;
    }
    szDetail += m_szDetails;
    return szDetail;
}
 
void CManager::slotCaptureAllKeyboard()
{
    Q_ASSERT(m_pParameterPlugin);
    if(m_pParameterPlugin->GetCaptureAllKeyboard()) {
        if(m_pHook) return;
        m_pHook = CHook::GetHook(m_pParameterPlugin, this);
        if(m_pHook)
            m_pHook->RegisterKeyboard();
    } else {
        if(m_pHook) {
            m_pHook->UnRegisterKeyboard();
            m_pHook->deleteLater();
            m_pHook = nullptr;
        }
    }
}