/*
 * This file was generated by qdbusxml2cpp-fix version 0.8
 * Command line was: qdbusxml2cpp-fix -c antiav -p generated/com_deepin_defender_antiav ../xml/com.deepin.defender.antiav.xml
 *
 * qdbusxml2cpp-fix is Copyright (C) 2016 Deepin Technology Co., Ltd.
 *
 * This is an auto-generated file.
 * Do not edit! All changes made to it will be lost.
 */

#ifndef COM_DEEPIN_DEFENDER_ANTIAV_H
#define COM_DEEPIN_DEFENDER_ANTIAV_H

#include <QtCore/QObject>
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QVariant>

#include <DBusExtendedAbstractInterface>
#include <QtDBus/QtDBus>


/*
 * Proxy class for interface com.deepin.defender.antiav
 */
class __antiavPrivate;
class __antiav : public DBusExtendedAbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    { return "com.deepin.defender.antiav"; }

public:
    explicit __antiav(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);

    ~__antiav();

    Q_PROPERTY(double globalRecv READ globalRecv NOTIFY GlobalRecvChanged)
    double globalRecv();

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> DoDissection(bool bAllDissection, const QString &sDissectionPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bAllDissection) << QVariant::fromValue(sDissectionPath);
        return asyncCallWithArgumentList(QStringLiteral("DoDissection"), argumentList);
    }

    inline void DoDissectionQueued(bool bAllDissection, const QString &sDissectionPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bAllDissection) << QVariant::fromValue(sDissectionPath);

        CallQueued(QStringLiteral("DoDissection"), argumentList);
    }


    inline QDBusPendingReply<> ExitApp()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ExitApp"), argumentList);
    }

    inline void ExitAppQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("ExitApp"), argumentList);
    }


    inline QDBusPendingReply<int> GetScanStatus()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("GetScanStatus"), argumentList);
    }



    inline QDBusPendingReply<> IsolationProblemFile(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);
        return asyncCallWithArgumentList(QStringLiteral("IsolationProblemFile"), argumentList);
    }

    inline void IsolationProblemFileQueued(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);

        CallQueued(QStringLiteral("IsolationProblemFile"), argumentList);
    }


    inline QDBusPendingReply<> QueryIsolationFiles()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("QueryIsolationFiles"), argumentList);
    }

    inline void QueryIsolationFilesQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("QueryIsolationFiles"), argumentList);
    }


    inline QDBusPendingReply<> QueryTrustFiles()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("QueryTrustFiles"), argumentList);
    }

    inline void QueryTrustFilesQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("QueryTrustFiles"), argumentList);
    }


    inline QDBusPendingReply<> QueryVersion()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("QueryVersion"), argumentList);
    }

    inline void QueryVersionQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("QueryVersion"), argumentList);
    }


    inline QDBusPendingReply<> RepairProblemFile(const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(sPath);
        return asyncCallWithArgumentList(QStringLiteral("RepairProblemFile"), argumentList);
    }

    inline void RepairProblemFileQueued(const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(sPath);

        CallQueued(QStringLiteral("RepairProblemFile"), argumentList);
    }


    inline QDBusPendingReply<> SelectIsolationAreaSize()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("SelectIsolationAreaSize"), argumentList);
    }

    inline void SelectIsolationAreaSizeQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("SelectIsolationAreaSize"), argumentList);
    }


    inline QDBusPendingReply<> SelectTrustAreaSize()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("SelectTrustAreaSize"), argumentList);
    }

    inline void SelectTrustAreaSizeQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("SelectTrustAreaSize"), argumentList);
    }


    inline QDBusPendingReply<> SetIsbInVirusScanningPage(bool isbOn)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(isbOn);
        return asyncCallWithArgumentList(QStringLiteral("SetIsbInVirusScanningPage"), argumentList);
    }

    inline void SetIsbInVirusScanningPageQueued(bool isbOn)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(isbOn);

        CallQueued(QStringLiteral("SetIsbInVirusScanningPage"), argumentList);
    }


    inline QDBusPendingReply<> SetScanFileSize(int nSize)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(nSize);
        return asyncCallWithArgumentList(QStringLiteral("SetScanFileSize"), argumentList);
    }

    inline void SetScanFileSizeQueued(int nSize)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(nSize);

        CallQueued(QStringLiteral("SetScanFileSize"), argumentList);
    }


    inline QDBusPendingReply<> SetScanStatus(int status)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(status);
        return asyncCallWithArgumentList(QStringLiteral("SetScanStatus"), argumentList);
    }

    inline void SetScanStatusQueued(int status)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(status);

        CallQueued(QStringLiteral("SetScanStatus"), argumentList);
    }


    inline QDBusPendingReply<> SetVriusUpdateAddress(const QString &address)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(address);
        return asyncCallWithArgumentList(QStringLiteral("SetVriusUpdateAddress"), argumentList);
    }

    inline void SetVriusUpdateAddressQueued(const QString &address)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(address);

        CallQueued(QStringLiteral("SetVriusUpdateAddress"), argumentList);
    }


    inline QDBusPendingReply<> StartApp()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("StartApp"), argumentList);
    }

    inline void StartAppQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("StartApp"), argumentList);
    }


    inline QDBusPendingReply<> TrustProblemFile(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);
        return asyncCallWithArgumentList(QStringLiteral("TrustProblemFile"), argumentList);
    }

    inline void TrustProblemFileQueued(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);

        CallQueued(QStringLiteral("TrustProblemFile"), argumentList);
    }


    inline QDBusPendingReply<> UpdateVersion()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("UpdateVersion"), argumentList);
    }

    inline void UpdateVersionQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("UpdateVersion"), argumentList);
    }


    inline QDBusPendingReply<> backgroundUpdate()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("backgroundUpdate"), argumentList);
    }

    inline void backgroundUpdateQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("backgroundUpdate"), argumentList);
    }


    inline QDBusPendingReply<> doDissection(bool bAllDissection, const QString &sDissectionPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bAllDissection) << QVariant::fromValue(sDissectionPath);
        return asyncCallWithArgumentList(QStringLiteral("doDissection"), argumentList);
    }

    inline void doDissectionQueued(bool bAllDissection, const QString &sDissectionPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bAllDissection) << QVariant::fromValue(sDissectionPath);

        CallQueued(QStringLiteral("doDissection"), argumentList);
    }


    inline QDBusPendingReply<QString> getVdbVersion()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("getVdbVersion"), argumentList);
    }



    inline QDBusPendingReply<bool> isScanning()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("isScanning"), argumentList);
    }



    inline QDBusPendingReply<bool> isTrueScanning()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("isTrueScanning"), argumentList);
    }



    inline QDBusPendingReply<> preInitialize()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("preInitialize"), argumentList);
    }

    inline void preInitializeQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("preInitialize"), argumentList);
    }


    inline QDBusPendingReply<> queryReposeFile()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("queryReposeFile"), argumentList);
    }

    inline void queryReposeFileQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("queryReposeFile"), argumentList);
    }


    inline QDBusPendingReply<> querySepFile()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("querySepFile"), argumentList);
    }

    inline void querySepFileQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("querySepFile"), argumentList);
    }


    inline QDBusPendingReply<> queryVersion()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("queryVersion"), argumentList);
    }

    inline void queryVersionQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("queryVersion"), argumentList);
    }


    inline QDBusPendingReply<> repairProblemFile(const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(sPath);
        return asyncCallWithArgumentList(QStringLiteral("repairProblemFile"), argumentList);
    }

    inline void repairProblemFileQueued(const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(sPath);

        CallQueued(QStringLiteral("repairProblemFile"), argumentList);
    }


    inline QDBusPendingReply<> reposeProblemFile(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);
        return asyncCallWithArgumentList(QStringLiteral("reposeProblemFile"), argumentList);
    }

    inline void reposeProblemFileQueued(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);

        CallQueued(QStringLiteral("reposeProblemFile"), argumentList);
    }


    inline QDBusPendingReply<> scanThreatsFile()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("scanThreatsFile"), argumentList);
    }

    inline void scanThreatsFileQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("scanThreatsFile"), argumentList);
    }


    inline QDBusPendingReply<> sepProblemFile(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);
        return asyncCallWithArgumentList(QStringLiteral("sepProblemFile"), argumentList);
    }

    inline void sepProblemFileQueued(bool bFlag, const QString &sPath)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(bFlag) << QVariant::fromValue(sPath);

        CallQueued(QStringLiteral("sepProblemFile"), argumentList);
    }


    inline QDBusPendingReply<> setDissection(int eState)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(eState);
        return asyncCallWithArgumentList(QStringLiteral("setDissection"), argumentList);
    }

    inline void setDissectionQueued(int eState)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(eState);

        CallQueued(QStringLiteral("setDissection"), argumentList);
    }


    inline QDBusPendingReply<> setScanStart()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("setScanStart"), argumentList);
    }

    inline void setScanStartQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("setScanStart"), argumentList);
    }


    inline QDBusPendingReply<> updateVersion()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("updateVersion"), argumentList);
    }

    inline void updateVersionQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("updateVersion"), argumentList);
    }



Q_SIGNALS: // SIGNALS
    void DissectionFinished();
    void NotifyDetailData(const QString &name, double recv, double send, int pid, const QString &device, const QString &type);
    void NotifyGlobalData(double recv, double send);
    void NotifyHeartbeat();
    void SendDissectionProgInfo(const QString &path, double progress, int type, const QString &sDetailInfo);
    void SendIsolationAreaSize(int size);
    void SendOperationIsolationFileResult(const QString &file);
    void SendOperationRepairFileResult(const QString &file);
    void SendOperationTrustFileResult(const QString &file);
    void SendQueryIsolationFiles(const QString &files);
    void SendQueryTrustFiles(const QString &files);
    void SendSrvVersion(const QString &version);
    void SendTrustAreaSize(int size);
    void SendUpdateVersionResult(bool result);
    void SetScanStatusFinished(int status);
    void onBackgroundUpdate();
    void onDissectionResult(const QString &sPath, double dProgress, int eType, const QString &sDetailInfo);
    void onRepairProblemFileResult(const QString &sPath, const QString &sMessage);
    void onReposeProblemFileResult(const QString &sPath, const QString &sMessage);
    void onRequstScanThreatsFile();
    void onSendScanStart();
    void onSepProblemFileResult(const QString &sPath, const QString &sMessage);
    void onSetDissectionStateResult(const QString &sPath, const QString &sMessage);
    void signal_UpdateVersionResult(bool flag);
    void signal_doDissectionFinished();
    void signal_doQueryVersion(const QString &version);
    void signal_onQueryReposeFile(const QString &fileinfo);
    void signal_onQuerySepFile(const QString &fileinfo);
    // begin property changed signals
    void GlobalRecvChanged(double  value) const;

public Q_SLOTS:
    void CallQueued(const QString &callName, const QList<QVariant> &args);

private Q_SLOTS:
    void onPendingCallFinished(QDBusPendingCallWatcher *w);
    void onPropertyChanged(const QString &propName, const QVariant &value);

private:
    __antiavPrivate *d_ptr;
};

namespace com {
  namespace deepin {
    namespace defender {
      typedef ::__antiav antiav;
    }
  }
}
#endif
