--- a/memspyui/ui/hb/inc/enginewrapper.h Fri Jun 11 16:29:34 2010 +0100
+++ b/memspyui/ui/hb/inc/enginewrapper.h Thu Jul 22 16:33:59 2010 +0100
@@ -19,31 +19,14 @@
#define ENGINEWRAPPER_H_
#include <QObject>
+#include <QVariantList>
+#include <QSettings>
#include <memspysession.h>
-#include <memspyapiprocess.h>
typedef quint64 ProcessId;
typedef quint64 ThreadId;
-class MemSpyProcess
-{
-public:
- MemSpyProcess(CMemSpyApiProcess* process)
- : mProcess(process)
- {}
-
- virtual ~MemSpyProcess() { delete mProcess; }
-
- ProcessId id() const { return mProcess->Id(); }
-
- QString name() const { return QString((QChar*) mProcess->Name().Ptr(), mProcess->Name().Length()); }
-
-
-private:
- CMemSpyApiProcess *mProcess;
-};
-
enum ThreadPriority
{
ThreadPriorityNull=(-30),
@@ -94,6 +77,105 @@
KernelObjectTypeCondVar
};
+enum ThreadInfoType
+{
+ ThreadInfoTypeGeneral = EMemSpyThreadInfoItemTypeGeneralInfo,
+ ThreadInfoTypeHeap = EMemSpyThreadInfoItemTypeHeap,
+ ThreadInfoTypeStack = EMemSpyThreadInfoItemTypeStack,
+ ThreadInfoTypeChunk = EMemSpyThreadInfoItemTypeChunk,
+ ThreadInfoTypeCodeSeg = EMemSpyThreadInfoItemTypeCodeSeg,
+ ThreadInfoTypeOpenFiles = EMemSpyThreadInfoItemTypeOpenFiles,
+ ThreadInfoTypeActiveObjects = EMemSpyThreadInfoItemTypeActiveObject,
+ ThreadInfoTypeOwnedThreadHandles = EMemSpyThreadInfoItemTypeOwnedThreadHandles,
+ ThreadInfoTypeOwnedProcessHandles = EMemSpyThreadInfoItemTypeOwnedProcessHandles,
+ ThreadInfoTypeServer = EMemSpyThreadInfoItemTypeServer,
+ ThreadInfoTypeSession = EMemSpyThreadInfoItemTypeSession,
+ ThreadInfoTypeSemaphore = EMemSpyThreadInfoItemTypeSemaphore,
+ ThreadInfoTypeOtherThreads = EMemSpyThreadInfoItemTypeOtherThreads,
+ ThreadInfoTypeOtherProcesses = EMemSpyThreadInfoItemTypeOtherProcesses,
+ ThreadInfoTypeMutex = EMemSpyThreadInfoItemTypeMutex,
+ ThreadInfoTypeTimer = EMemSpyThreadInfoItemTypeTimer,
+ ThreadInfoTypeChannel = EMemSpyThreadInfoItemTypeLogicalChannel,
+ ThreadInfoTypeChangeNotifier = EMemSpyThreadInfoItemTypeChangeNotifier,
+ ThreadInfoTypeUndertaker = EMemSpyThreadInfoItemTypeUndertaker,
+ ThreadInfoTypeMessageQueue = EMemSpyThreadInfoItemTypeMessageQueue,
+ ThreadInfoTypeConditionalVariable = EMemSpyThreadInfoItemTypeConditionalVariable,
+ ThreadInfoTypeLDD = EMemSpyThreadInfoItemTypeLDD,
+ ThreadInfoTypePDD = EMemSpyThreadInfoItemTypePDD,
+};
+
+enum DeviceWideOperation
+{
+ OutputPhoneInfo = 0,
+
+ OutputDetailedPhoneInfo,
+
+ OutputHeapInfo,
+
+ OutputCompactHeapInfo,
+
+ OutputHeapCellListing,
+
+ OutputHeapData,
+
+ OutputStackInfo,
+
+ OutputCompactStackInfo,
+
+ OutputUserStackData,
+
+ OutputKernelStackData
+};
+
+enum SwmtMode
+{
+ SwmtModeBasic = 0,
+ SwmtModeFull,
+ SwmtModeCustom
+};
+
+enum HeapDumpsMode
+{
+ HeapDumpsModeKernel = 0,
+ HeapDumpsModeUser,
+ HeapDumpsModeBoth
+};
+
+enum OutputMode
+{
+ OutputModeTrace = 0,
+ OutputModeFile
+};
+
+class MemSpyProcess
+{
+public:
+ MemSpyProcess(CMemSpyApiProcess* process)
+ : mProcess(process)
+ {}
+
+ virtual ~MemSpyProcess() { delete mProcess; }
+
+ ProcessId id() const { return mProcess->Id(); }
+
+ QString name() const { return QString((QChar*) mProcess->Name().Ptr(), mProcess->Name().Length()); }
+
+ QString exitInfo() const;
+
+ int priority() const { return mProcess->Priority(); }
+
+ int threadCount() const { return mProcess->ThreadCount(); }
+
+ int sid() const { return mProcess->SID(); }
+
+ int vid() const { return mProcess->VID(); }
+
+ bool isDead() const { return mProcess->IsDead(); }
+
+private:
+ CMemSpyApiProcess *mProcess;
+};
+
class MemSpyThread
{
public:
@@ -127,6 +209,10 @@
QString name() const { return QString((QChar*) mType->Name().Ptr(), mType->Name().Length()); }
+ int count() const { return mType->Count(); }
+
+ qint64 size() const { return mType->Size(); }
+
private:
CMemSpyApiKernelObject *mType;
};
@@ -236,25 +322,208 @@
CMemSpyApiKernelObjectItem *mObject;
};
-class EngineWrapper : public QObject
+class MemSpyThreadInfoItem
{
public:
+ MemSpyThreadInfoItem(CMemSpyApiThreadInfoItem *item)
+ : mItem(item)
+ {}
+
+ virtual ~MemSpyThreadInfoItem() { delete mItem; }
+
+ QString caption() const { return QString((QChar*) mItem->Caption().Ptr(), mItem->Caption().Length()); }
+
+ QString value() const { return QString((QChar*) mItem->Value().Ptr(), mItem->Value().Length()); }
+
+private:
+ CMemSpyApiThreadInfoItem* mItem;
+};
+
+class MemSpyDwoProgressTracker : public QObject, public CActive
+{
+ Q_OBJECT
+
+public:
+ MemSpyDwoProgressTracker(RMemSpySession &session);
+ virtual ~MemSpyDwoProgressTracker();
+
+public slots:
+
+ void start();
+
+ void cancel();
+
+protected: // from CActive
+
+ virtual void RunL();
+
+ virtual void DoCancel();
+
+ virtual TInt RunError(TInt aError);
+
+signals:
+ void progress(int progress, const QString& processName);
+
+private:
+ TMemSpyDeviceWideOperationProgress mProgress;
+ RMemSpySession mSession;
+};
+
+class MemSpyDwoTracker : public QObject, public CActive
+{
+ Q_OBJECT
+
+public:
+ MemSpyDwoTracker(RMemSpySession &session, DeviceWideOperation operation);
+ virtual ~MemSpyDwoTracker();
+
+public slots:
+
+ void start();
+
+ void cancel();
+
+protected: // from CActive
+
+ virtual void RunL();
+
+ virtual void DoCancel();
+
+ virtual TInt RunError(TInt aError);
+
+signals:
+ void finished(int errorCode);
+ void progress(int progress, const QString& processName);
+
+private:
+ RMemSpySession mSession;
+ MemSpyDwoProgressTracker *mProgressTracker;
+ DeviceWideOperation mOperation;
+};
+
+class MemSpyAsyncTracker : public QObject, public CActive
+{
+ Q_OBJECT
+
+public:
+
+ MemSpyAsyncTracker(RMemSpySession& session, void (RMemSpySession::*function)(TRequestStatus&));
+
+ void start();
+
+ virtual void RunL();
+
+ virtual void DoCancel();
+
+ virtual TInt RunError(TInt aError);
+
+signals:
+
+ void finished(int errorCode);
+
+private:
+ void (RMemSpySession::*mFunction)(TRequestStatus&);
+ RMemSpySession& mSession;
+};
+
+class MemSpySwmtDumpTracker : public MemSpyAsyncTracker
+{
+public:
+ MemSpySwmtDumpTracker(RMemSpySession& session) :
+ MemSpyAsyncTracker(session, &RMemSpySession::ForceSwmtUpdate)
+ {}
+};
+
+class MemSpyKernelHeapDumpTracker : public MemSpyAsyncTracker
+{
+public:
+ MemSpyKernelHeapDumpTracker(RMemSpySession& session) :
+ MemSpyAsyncTracker(session, &RMemSpySession::OutputKernelHeapData)
+ {}
+};
+
+class MemSpySettings : private QSettings
+{
+public:
+
+ MemSpySettings();
+
+ OutputMode outputMode() const;
+ void setOutputMode(OutputMode mode);
+
+ QString outputPath() const;
+ void setOutputPath(const QString& path);
+
+ int swmtTimerPeriod() const;
+ void setSwmtTimerPeriod(int period);
+
+ SwmtMode swmtMode() const;
+ void setSwmtMode(SwmtMode mode);
+
+ QVariantList swmtCategories() const;
+ void setSwmtCategories(const QVariantList& categories);
+
+ HeapDumpsMode heapDumpsMode() const;
+ void setHeapDumpsMode(HeapDumpsMode mode);
+};
+
+class EngineWrapper : public QObject
+{
+ Q_OBJECT
+
+public:
+ EngineWrapper();
+
virtual ~EngineWrapper();
+
bool initialize();
+ MemSpySettings& settings();
+
+ const MemSpySettings& settings() const;
+
+
+
QList<MemSpyProcess*> getProcesses();
QList<MemSpyThread*> getThreads(ProcessId processId);
+ QList<MemSpyThreadInfoItem*> getThreadInfo(ThreadId threadId, ThreadInfoType type);
+
void setThreadPriority(ThreadId threadId, ThreadPriority priority);
QList<MemSpyKernelObjectType*> getKernelObjectTypes();
QList<MemSpyKernelObject*> getKernelObjects(int type);
+ MemSpyDwoTracker* createDeviceWideOperation(DeviceWideOperation operation);
+
+ MemSpyKernelHeapDumpTracker* createKernelHeapDumpTracker();
+
+ MemSpySwmtDumpTracker* createSwmtDumpTracker();
+
+ void setSwmtSettings(SwmtMode mode, const QVariantList& categories);
+
+ bool isSwmtRunning();
+
+ void startSwmt(int period);
+
+ void stopSwmt();
+
+ void forceSwmtDump();
+
+ void outputKernelHeapData();
+
+ int outputThreadHeapData(const QString& filter);
+
+ void updateOutputSettings();
+
private:
RMemSpySession mSession;
+ bool mSwmtRunning;
+
+ MemSpySettings mSettings;
};
#endif /* ENGINEWRAPPER_H_ */