libgfaipc/Test/qmlApp/qappctrl.h

// qappctrl.h :
//

#if !defined(AGD_QAPPCTRL_H__ADD46467_F628_4A07_8844_613598E359DE__INCLUDED_)
#define AGD_QAPPCTRL_H__ADD46467_F628_4A07_8844_613598E359DE__INCLUDED_

#include <QObject>
#include <QQmlEngine>
#include <QQmlContext>
#include <QAbstractTableModel>
#include <vector>
#include <gfa/gfaipc.h>
#include "../../src/ipcpriv.h"

#ifdef __cplusplus

/////////////////////////////////////////////////////////////////////////////
// qappctrl.h - Declarations:

typedef struct _STG_DEV_DISK_PART
{
	_STG_DEV_DISK_PART(int d, int p) {
		nDiskIdx = d;
		nPartIdx = p;
	}
	int nDiskIdx;
	int nPartIdx;
}STG_DEV_DISK_PART, *LPSTG_DEV_DISK_PART;
typedef const STG_DEV_DISK_PART *LPCSTG_DEV_DISK_PART;

/////////////////////////////////////////////////////////////////////////////

class QGfaStgDevList : public QAbstractTableModel
{
    Q_OBJECT

public:
	explicit QGfaStgDevList(QObject *pParent = NULL);
	virtual ~QGfaStgDevList(void);

	int rowCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
	int columnCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
	QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const Q_DECL_OVERRIDE;
	QHash<int, QByteArray> roleNames(void) const Q_DECL_OVERRIDE;
	
	void diskAdded(int nIndex, const GFA_SYSINFO_DISK &disk);
	void diskRemoved(int nIndex, const GFA_SYSINFO_DISK &disk);
	void partitionAdded(int nIndex, const GFA_SYSINFO_PARTITION &part);
	void partitionRemoved(int nIndex, const GFA_SYSINFO_PARTITION &part);
	void mountAdded(int nIndex, const GFA_SYSINFO_PARTITION &part);
	void mountRemoved(int nIndex, const GFA_SYSINFO_PARTITION &part);
	void clearAll(void);

private:
	void insertPartition(int nDiskIdx, int nPartIdx);
	void removePartition(int nDiskIdx, int nPartIdx);
	int FindPartVecEntry(int nDiskIdx, int nPartIdx);

private:
	GFA_SYSINFO_STORAGE_DEVICE_MAP m_stgDevShadowCpy;
	std::vector<STG_DEV_DISK_PART> m_partVec;
};

/////////////////////////////////////////////////////////////////////////////

class QGfaSysInfo : public QObject
{
    Q_OBJECT
	Q_PROPERTY(quint64 memTotal READ memTotal NOTIFY memTotalChanged)
	Q_PROPERTY(quint64 memUsed READ memUsed NOTIFY memUsedChanged)
	Q_PROPERTY(quint64 memFree READ memFree NOTIFY memFreeChanged)
	Q_PROPERTY(quint64 memAvailable READ memAvailable NOTIFY memAvailableChanged)
	Q_PROPERTY(quint64 memBuffers READ memBuffers NOTIFY memBuffersChanged)
	Q_PROPERTY(quint64 memCached READ memCached NOTIFY memCachedChanged)
    Q_PROPERTY(QGfaStgDevList *stgDev READ stgDev CONSTANT)
    Q_PROPERTY(bool bootFromEmmc READ bootFromEmmc NOTIFY bootFromEmmcChanged)

public:
	explicit QGfaSysInfo(QObject *pParent = NULL);
	virtual ~QGfaSysInfo(void);

signals:
	void memTotalChanged(quint64 val);
	void memUsedChanged(quint64 val);
	void memFreeChanged(quint64 val);
	void memAvailableChanged(quint64 val);
	void memBuffersChanged(quint64 val);
	void memCachedChanged(quint64 val);
	void bootFromEmmcChanged(bool val);

private:
	quint64 memTotal(void) const;
	quint64 memUsed(void) const;
	quint64 memFree(void) const;
	quint64 memAvailable(void) const;
	quint64 memBuffers(void) const;
	quint64 memCached(void) const;
	QGfaStgDevList* stgDev(void);
	bool bootFromEmmc(void) const;

public:
	void setSysMemInfo(LPCGFA_APPCTRL_SYSMEM psm, bool bDoHeavyLoadUpdate = false);
	void setSysInfoRunning(bool bRunning);
	void setBootFromEmmc(bool bootFromEmmc);

	inline void diskAdded(int nIndex, const GFA_SYSINFO_DISK &disk) {
		return m_stgDevList.diskAdded(nIndex, disk);}

	inline void diskRemoved(int nIndex, const GFA_SYSINFO_DISK &disk) {
		return m_stgDevList.diskRemoved(nIndex, disk);}

	inline void partitionAdded(int nIndex, const GFA_SYSINFO_PARTITION &part) {
		return m_stgDevList.partitionAdded(nIndex, part);}
		
	inline void partitionRemoved(int nIndex, const GFA_SYSINFO_PARTITION &part) {
		return m_stgDevList.partitionRemoved(nIndex, part);}

	inline void mountAdded(int nIndex, const GFA_SYSINFO_PARTITION &part) {
		return m_stgDevList.mountAdded(nIndex, part);}

	inline void mountRemoved(int nIndex, const GFA_SYSINFO_PARTITION &part) {
		return m_stgDevList.mountRemoved(nIndex, part);}

private:
	bool m_bSysInfoRunning;
	quint64 m_nMemTotal;
	quint64 m_nMemUsed;
	quint64 m_nMemFree;
	quint64 m_nMemAvailable;
	quint64 m_nMemBuffers;
	quint64 m_nMemCached;
	QGfaStgDevList m_stgDevList;
	bool m_bootFromEmmc;
};

/////////////////////////////////////////////////////////////////////////////

class QGfaAppInfo : public QObject
{
    Q_OBJECT
	Q_PROPERTY(int state READ state NOTIFY stateChanged)
	Q_PROPERTY(QString stateText READ stateText NOTIFY stateTextChanged)
	Q_PROPERTY(QString name READ name NOTIFY nameChanged)
	Q_PROPERTY(quint64 cycInt READ cycInt NOTIFY cycIntChanged)
	Q_PROPERTY(quint64 cycCur READ cycCur NOTIFY cycCurChanged)
	Q_PROPERTY(quint64 cycMin READ cycMin NOTIFY cycMinChanged)
	Q_PROPERTY(quint64 cycMax READ cycMax NOTIFY cycMaxChanged)
	Q_PROPERTY(quint64 wktCur READ wktCur NOTIFY wktCurChanged)
	Q_PROPERTY(quint64 wktMin READ wktMin NOTIFY wktMinChanged)
	Q_PROPERTY(quint64 wktMax READ wktMax NOTIFY wktMaxChanged)
	Q_PROPERTY(quint64 upTime READ upTime NOTIFY upTimeChanged)
	Q_PROPERTY(double cpuTime READ cpuTime NOTIFY cpuTimeChanged)
	Q_PROPERTY(double cpuCur READ cpuCur NOTIFY cpuCurChanged)
	Q_PROPERTY(double cpuAvg READ cpuAvg NOTIFY cpuAvgChanged)
	Q_PROPERTY(quint32 vmPeak READ vmPeak NOTIFY vmPeakChanged)
	Q_PROPERTY(quint32 vmSize READ vmSize NOTIFY vmSizeChanged)
	Q_PROPERTY(quint32 vmHWM READ vmHWM NOTIFY vmHWMChanged)
	Q_PROPERTY(quint32 vmRSS READ vmRSS NOTIFY vmRSSChanged)
	Q_PROPERTY(quint32 appSize READ appSize NOTIFY appSizeChanged)

public:
	Q_INVOKABLE bool pause(void);
	Q_INVOKABLE bool resume(void);
	Q_INVOKABLE bool stop(void);

signals:
	void stateChanged(int val);
	void stateTextChanged(const QString &val);
	void nameChanged(const QString &val);
	void sendControlMessage(appid_t nAppID, ctrlmsg_t msg);
	void cycIntChanged(quint64 val);
	void cycCurChanged(quint64 val);
	void cycMinChanged(quint64 val);
	void cycMaxChanged(quint64 val);
	void wktCurChanged(quint64 val);
	void wktMinChanged(quint64 val);
	void wktMaxChanged(quint64 val);
	void upTimeChanged(quint64 val);
	void cpuTimeChanged(double val);
	void cpuCurChanged(double val);
	void cpuAvgChanged(double val);
	void vmPeakChanged(quint32 val);
	void vmSizeChanged(quint32 val);
	void vmHWMChanged(quint32 val);
	void vmRSSChanged(quint32 val);
	void appSizeChanged(quint32 val);

public:
	explicit QGfaAppInfo(int nIndex, QObject *pParent = NULL);
	virtual ~QGfaAppInfo(void);
	
	appid_t appId(void) const;

	int state(void) const;
	bool setState(int val);

	QString stateText(void) const;
	void setStateText(int val);

	QString name(void) const;
	void setName(const QString &val);
	
	quint64 cycInt(void) const;
	quint64 cycCur(void) const;
	quint64 cycMin(void) const;
	quint64 cycMax(void) const;
	quint64 wktCur(void) const;
	quint64 wktMin(void) const;
	quint64 wktMax(void) const;
	quint64 upTime(void) const;
	double cpuTime(void) const;
	double cpuCur(void) const;
	double cpuAvg(void) const;
	quint32 vmPeak(void) const;
	quint32 vmSize(void) const;
	quint32 vmHWM(void) const;
	quint32 vmRSS(void) const;

	quint32 appSize(void) const;
	void setAppSize(quint32 size, GfaIpcAppStates state);

	void setAppTimes(LPCGFA_APPCTRL_APPTIMES pat, GfaIpcAppStates state, bool bDoHeavyLoadUpdate = false);
	void setAppMemInfo(LPCGFA_APPCTRL_APPMEM pam, GfaIpcAppStates state, bool bDoHeavyLoadUpdate = false);

private:

private:
	int m_state;
	QString m_stateText;
	QString m_name;
	int m_nIndex;
	appid_t m_nAppID;
	quint64 m_cycInt;
	quint64 m_cycCur;
	quint64 m_cycMin;
	quint64 m_cycMax;
	quint64 m_wktCur;
	quint64 m_wktMin;
	quint64 m_wktMax;
	quint64 m_upTime;
	double m_cpuTime;
	double m_cpuPercCur;
	double m_cpuPercAvg;
	quint32 m_vmPeak;
	quint32 m_vmSize;
	quint32 m_vmHWM;
	quint32 m_vmRSS;
	quint32 m_appSize;
};

/////////////////////////////////////////////////////////////////////////////

class QGfaAppCtrl : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QQmlListProperty<QGfaAppInfo> appInfo READ appInfo CONSTANT)
	Q_PROPERTY(quint64 minPass READ minPass NOTIFY minPassChanged)
	Q_PROPERTY(quint64 maxPass READ maxPass NOTIFY maxPassChanged)
	Q_PROPERTY(quint64 avgPass READ avgPass NOTIFY avgPassChanged)
    Q_PROPERTY(QGfaSysInfo *sysInfo READ sysInfo CONSTANT)

public:
	enum AppStates
	{
		STATE_NOT_RUNNING	= GIAS_StateNotRunning,
		STATE_INITIALIZING,
		STATE_RUNNING,
		STATE_PAUSED,
		STATE_HANGING,
		STATE_TERMINATING,
		STATE_ZOMBIE,
		STATE_INVALID
	};
	Q_ENUM(AppStates)
	static_assert((STATE_INVALID - STATE_NOT_RUNNING) == (GIAS_Invalid - GIAS_StateNotRunning), "enum AppStates does not match enum GfaIpcAppStates!");
	
	enum AppIndex
	{
		APP_INDEX_REMANENT		= GAI_Remanent,
		APP_INDEX_DATALOGGER	= GAI_Datalogger,
		APP_INDEX_SUMMARIST		= GAI_Summarist,
		APP_INDEX_REST			= GAI_Rest,
		APP_INDEX_MQTTCL		= GAI_Mqttcl,
		APP_INDEX_SYSINFO		= GAI_SysInfo
	};
	Q_ENUM(AppIndex)

signals:
	void minPassChanged(quint64 val);
	void maxPassChanged(quint64 val);
	void avgPassChanged(quint64 val);

public:
	explicit QGfaAppCtrl(QObject *pParent = NULL);
	virtual ~QGfaAppCtrl(void);

	bool Create(appid_t nAppID, const char *pszDisplayName, int nTimerIntMs, clock64_t nHeavyLoadUpdateIntervalMs);
	void Release(void);
	void RegisterQmlTypes(QQmlEngine &rEng, int nVerMajor = 1, int nVerMinor = 0);
	bool PresetDisplayName(appid_t nAppID, const char *pszName);
	bool SubscribeStateEvents(appid_t nAppMask);
	int SetState(int nState);

public:
	Q_INVOKABLE int appIndexFromAppID(quint64 nAppID);

public:
	QQmlListProperty<QGfaAppInfo> appInfo(void);
	quint64 minPass(void) const;
	quint64 maxPass(void) const;
	quint64 avgPass(void) const;
	QGfaSysInfo* sysInfo(void);

private slots:
	void onSendControlMessage(appid_t nAppID, ctrlmsg_t msg);
	void timerEvent(QTimerEvent *event) override;

private:
	bool m_bSysInfoRunning;
	HAPPCTRL m_hAC;
	appid_t m_nAppID;
	int m_nTimerID;
	QGfaSysInfo m_sysInfo;
	QList<QGfaAppInfo*> m_appInfo;
	clock64_t m_curPass;
	clock64_t m_minPass;
	clock64_t m_maxPass;
	clock64_t m_avgPass;
	appid_t m_nEvtSrcs;
	clock64_t m_nHeavyLoadUpdateIntervalUs;
	struct timespec m_tsLastHeavyLoadUpdate;
};

/////////////////////////////////////////////////////////////////////////////
#endif	//	__cplusplus
#endif	//	!defined(AGD_QAPPCTRL_H__ADD46467_F628_4A07_8844_613598E359DE__INCLUDED_)