Added --codeseg option to ps to list the codesegs loaded into a given process.
Also tweaked some docs, added support to date to handle kernel TTimeK (epoc=0AD)
// btrace_parser.h
//
// Copyright (c) 2008 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Accenture - Initial contribution
// Backwards Compatibility:
// The interfaces defined in this file should be considered INTERNAL to the
// fshell project as they may be subject to change. Expect to have to absorb
// downstream compatibility breaks if you use these interfaces from outside
// of the fshell project.
#ifndef __BTRACE_PARSER_H__
#define __BTRACE_PARSER_H__
#include <e32base.h>
#include <fshell/btrace_parser_defs.h>
#include <fshell/extrabtrace.h>
#include FSHELL_D32BTRACE_HEADER
#include <f32file.h>
#include <e32property.h>
#include <fshell/common.mmh>
#ifdef FSHELL_ATRACE_SUPPORT
#include <fshell/atrace/atraceconfig.h>
#endif
class TBtraceHeader;
struct TKeyEvent;
struct TPointerEvent;
class CMultipartFragment;
class CFlusher;
enum TBtraceParserPanic
{
EBtpPanicUndefinedCallBack = 0,
EBtpPanicIncompatiblePubSubArgs = 1,
EBtpPanicThreadIdNotFound = 2,
EBtpPanicProcessNameNotFound = 3,
EBtpPanicBtraceThreadIdOverflow = 4,
EBtpPanicThreadNotFoundForId = 5,
EBtpPanicFailedToInsertCpuUsageObject = 6,
EBtpPanicBtraceProcessIdOverflow = 7,
EBtpPanicUnused1 = 8,
EBtpPanicUnused2 = 9,
EBtpPanicNegativeTickInterval = 10,
EBtpPanicUnused3 = 11,
EBtpPanicInvalidReaderMode = 12,
EBtpPanicUnexpectedReaderRun = 13,
EBtpPanicUnknownCpuContext = 14,
EBtpPanicFlusherObserverAlreadySet = 15,
EBtpPanicReaderNotReplaying = 16,
EBtpPanicNoReplayData = 17,
EBtpPanicFailedToFindProcess = 18,
EBtpPanicNegativeRefCount = 19,
EBtpPanicNestedSynchronizeCalls = 20,
EBtpPanicFrameObserverAlreadyExists = 21,
EBtpPanicTriedToDisableReplayWhenBtraceNotRunning = 22,
EBtpPanicAddObserverCalledWhileIterating = 23,
EBtpPanicRemoveObserverCalledWhileIterating = 24,
EBtpPanicTooManyDomainEventDataItems = 25,
EBtpPanicBtraceWindowGroupIdOverflow = 26,
EBtpPanicWindowGroupIdNotFound = 27,
EBtpPanicWservWindowGroupIdNotFound = 28
};
void Panic(TBtraceParserPanic aReason);
struct SBtraceParserTls;
enum TBtraceNotificationPersistence
{
ENotificationOneShot,
ENotificationPersistent,
};
class TBtraceUtils
{
public:
IMPORT_C static TUint32 MicroSecondsToNanoTicks(TTimeIntervalMicroSeconds32 aInterval);
IMPORT_C static TUint64 MicroSecondsToFastTicks(TTimeIntervalMicroSeconds32 aInterval);
IMPORT_C static TTimeIntervalMicroSeconds NanoTicksToMicroSeconds(TUint32 aNanoTicks);
IMPORT_C static TTimeIntervalMicroSeconds FastTicksToMicroSeconds(const TUint64& aFastTicks);
IMPORT_C static void DebugOverrideTimerSettings(TInt aNanoPeriod, TInt aFastCounterFreq, TBool aFastCountUp);
public:
static TInt NanoTickPeriod();
static TInt FastCounterFrequency();
static TBool FastCounterCountsUp();
private:
static SBtraceParserTls* CreateTls();
static TInt CalculateNanoTickPeriod();
static TInt CalculateFastCounterFrequency();
static TInt CalculateFastCounterCountsUp();
};
class TBtraceTickCount
{
public:
IMPORT_C TBtraceTickCount();
IMPORT_C void SetToNow();
IMPORT_C TUint32 IntervalInNanoTicks(const TBtraceTickCount& aTickCount) const;
IMPORT_C TUint64 IntervalInFastTicks(const TBtraceTickCount& aTickCount) const;
IMPORT_C TTimeIntervalMicroSeconds IntervalInMicroSeconds(const TBtraceTickCount& aTickCount) const;
IMPORT_C TBool operator==(const TBtraceTickCount& aTickCount) const;
IMPORT_C TBool operator!=(const TBtraceTickCount& aTickCount) const;
IMPORT_C TBool operator>=(const TBtraceTickCount& aTickCount) const;
IMPORT_C TBool operator<=(const TBtraceTickCount& aTickCount) const;
IMPORT_C TBool operator>(const TBtraceTickCount& aTickCount) const;
IMPORT_C TBool operator<(const TBtraceTickCount& aTickCount) const;
public:
TUint32 iNano;
TUint32 iFast;
};
class TBtraceFrame
{
public:
TBtraceFrame(const TBtraceHeader& aHeader);
public:
TUint8 iSize;
TUint8 iFlags;
TUint8 iCategory;
TUint8 iSubCategory;
TBtraceTickCount iTickCount;
TUint32 iThreadContext;
TUint32 iProgramCounter;
TPtrC8 iData;
};
class MBtraceLog
{
public:
IMPORT_C virtual TBool LogEnabled() = 0;
IMPORT_C virtual void Log(const TDesC& aLog) = 0;
};
class CBtraceReader;
class MBtraceObserver
{
public:
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame) = 0;
virtual void BtraceBufferHasBeenReset() {} // Empty default impl
};
class MBtraceFrameObserver
{
public:
virtual void HandleFrameDispatchStart() = 0;
virtual void HandleFrameDispatchComplete() = 0;
};
NONSHARABLE_CLASS(CBtraceReader) : public CActive
{
public:
enum TMode
{
EAllowBtraceToOverflow,
EFlushOnBtraceThreshold,
ELeaveOnBtraceThreshold
};
enum TObserverType
{
ENormal,
EIncludeSynchronizationFrames
};
public:
IMPORT_C static CBtraceReader* NewL(TMode aMode, TInt aBufferSize, TInt aThreshold, MBtraceLog* aLog = NULL);
IMPORT_C static CBtraceReader* NewL(const TDesC& aReplayFileName, MBtraceLog* aLog = NULL);
IMPORT_C ~CBtraceReader();
IMPORT_C void Reset();
IMPORT_C void SynchronizeL();
IMPORT_C void Start(const TBtraceTickCount& aInitialTickCount);
IMPORT_C void Start(const TBtraceTickCount& aInitialTickCount, TTimeIntervalMicroSeconds32 aAutoFlushPeriod);
IMPORT_C void DisableBtrace();
IMPORT_C void EnableCategoryL(TUint aCategory);
IMPORT_C void DisableCategoryL(TUint aCategory);
IMPORT_C void AddObserverL(MBtraceObserver& aObserver);
IMPORT_C void AddObserverL(MBtraceObserver& aObserver, TObserverType aType);
IMPORT_C void AddObserverL(TUint aCategory, MBtraceObserver& aObserver);
IMPORT_C void AddObserverL(TUint aCategory, MBtraceObserver& aObserver, TObserverType aType);
IMPORT_C void RemoveObserver(MBtraceObserver& aObserver);
IMPORT_C void RemoveObserver(TUint aCategory, MBtraceObserver& aObserver);
IMPORT_C void AddFrameObseverL(MBtraceFrameObserver& aObserver);
IMPORT_C void RemoveFrameObserver(MBtraceFrameObserver& aObserver);
IMPORT_C void GetReplayStartTickCountL(TBtraceTickCount& aTickCount);
IMPORT_C void SetBufferSizeL(TInt aBufferSize);
IMPORT_C void SetReplayFileNameL(const TDesC& aReplayFileName); // Pass empty desc to disable (not allowed to disable if constructed with the overload that took a replay filename)
IMPORT_C const TBtraceTickCount& CurrentTickCount() const;
IMPORT_C void RecordBtraceDataToFileL(const TDesC& aRecordFileName); // Pass empty desc to disable
IMPORT_C void LogBtraceStatus();
IMPORT_C void SetMultipartReassemblyL(TInt aMaxTrackedFragments); // zero to disable
IMPORT_C void FlushL();
public:
void Log(const TDesC& aDes) const;
void Log(TRefByValue<const TDesC> aFmt, ...) const;
private: // From CActive.
virtual void RunL();
virtual void DoCancel();
private:
CBtraceReader(TMode aMode, TInt aThreshold, MBtraceLog* aLog);
void ConstructL(TInt aBufferSize);
void ConstructL(const TDesC& aReplayFileName);
void QueueRead();
void DoReadL(TBool& aFinished);
TInt GetData(TUint8*& aData);
void DispatchFrameL(const TBtraceFrame& aFrame);
void NotifyObserversOfBufferReset();
void ResetAndReprimeL();
void NewMultipartFrameL(const TBtraceFrame& aFrame, TUint32 aExtra);
void AdditionalMultipartFragmentL(const TBtraceFrame& aFrame, TUint32 aExtra, TBool aLast);
private:
class TObserver
{
public:
TObserver(MBtraceObserver& aObserver, TObserverType aType, TUint aCategory);
static TObserver ArrayKey(TUint aCategory);
private:
TObserver(TUint aCategory); // Only for use by ArrayKey
public:
MBtraceObserver* iObserver;
TObserverType iType;
TUint iCategory;
};
private:
static TBool ObserversEqual(const TObserver& aA, const TObserver& aB);
static void DecIteratingObservers(TAny* aSelf);
private:
const TMode iMode;
MBtraceLog* iLog;
CFlusher* iFlusher;
RBTrace iBtrace;
#ifdef FSHELL_ATRACE_SUPPORT
RATraceConfig iAtraceConfig;
#endif
TInt iThreshold;
RArray<TObserver> iObservers; // Sorted by TObserver::iCategory
TInt iNumBytesRead;
TInt iNumFramesRead;
TBtraceTickCount iCurrentTickCount;
TBtraceTickCount iInitialTickCount;
TPtrC8 iBtraceBuffer;
HBufC8* iReplayData;
RFs iFs;
RFile iReplayFile;
TBool iSynchronizing;
MBtraceFrameObserver* iFrameObserver;
RFile iRecordFile;
TInt iIteratingObservers;
TInt iNextSyncFrameId;
TInt iSyncFrameIdToWaitFor;
TInt iMaxTrackedMultipartFragments;
RPointerArray<CMultipartFragment> iMultipartFragments;
};
class CRefCountedObject : public CBase
{
public:
IMPORT_C void IncRef();
IMPORT_C void DecRef();
IMPORT_C TInt RefCount() const;
protected:
CRefCountedObject();
private:
TInt iRefCount;
};
class TBtraceIdBase
{
public:
IMPORT_C void Set(TUint aValue);
IMPORT_C TUint Value() const;
IMPORT_C TBool operator==(const TBtraceIdBase& aId) const;
protected:
TBtraceIdBase();
TBtraceIdBase(TUint aId);
TBtraceIdBase(const TBtraceIdBase& aId);
private:
TUint iId;
};
class TBtraceThreadId : public TBtraceIdBase
{
public:
IMPORT_C TBtraceThreadId();
IMPORT_C explicit TBtraceThreadId(TUint aId);
IMPORT_C TBtraceThreadId(const TBtraceThreadId& aId);
};
class TBtraceProcessId : public TBtraceIdBase
{
public:
IMPORT_C TBtraceProcessId();
IMPORT_C explicit TBtraceProcessId(TUint aId);
IMPORT_C TBtraceProcessId(const TBtraceProcessId& aId);
};
class TBtraceWindowGroupId : public TBtraceIdBase
{
public:
IMPORT_C TBtraceWindowGroupId();
IMPORT_C explicit TBtraceWindowGroupId(TUint aId);
IMPORT_C TBtraceWindowGroupId(const TBtraceWindowGroupId& aId);
};
class MBtraceContextObserver
{
public:
IMPORT_C virtual void HandleThreadSeenL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TUint aUserId);
IMPORT_C virtual void HandleThreadGoneL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TUint aUserId);
IMPORT_C virtual void HandleThreadExitL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TExitType aExitType, TInt aReason, const TDesC& aCategory, TUint aUserId);
IMPORT_C virtual void HandleWindowGroupSeenL(const TBtraceTickCount& aTickCount, const TBtraceWindowGroupId& aId, TUint aUserId);
};
NONSHARABLE_CLASS(CBtraceContext) : public CRefCountedObject, public MBtraceObserver
{
public:
enum TMode
{
ENormal
};
enum TExitTypes
{
EKill = 0x00000001,
ETerminate = 0x00000002,
EPanic = 0x00000004
};
public:
IMPORT_C static CBtraceContext* NewL(CBtraceReader& aReader, TMode aMode = ENormal);
IMPORT_C ~CBtraceContext();
IMPORT_C const TDesC& ThreadName(const TBtraceThreadId& aId) const;
IMPORT_C void GetFullThreadName(const TBtraceThreadId& aId, TDes& aFullName) const;
IMPORT_C TThreadId ThreadId(const TBtraceThreadId& aId) const;
IMPORT_C const TDesC& ProcessName(const TBtraceProcessId& aId) const;
IMPORT_C TInt WindowGroupId(const TBtraceWindowGroupId& aId) const;
IMPORT_C const TDesC& WindowGroupName(const TBtraceWindowGroupId& aId) const;
IMPORT_C const TBtraceThreadId* FindThread(TUint32 aNThreadAddress) const;
IMPORT_C const TBtraceThreadId* FindThread(const TThreadId& aId) const;
IMPORT_C const TBtraceWindowGroupId* FindWindowGroup(TInt aWServWgId) const;
IMPORT_C void FindThreadsL(const TDesC& aPattern, RArray<TBtraceThreadId>& aThreads) const;
IMPORT_C void FindWindowGroupsL(const TDesC& aPattern, RArray<TBtraceWindowGroupId>& aWindowGroups) const;
IMPORT_C void FindWindowGroupsByThreadName(const TDesC& aPattern, RArray<TBtraceWindowGroupId>& aWindowGroups) const;
IMPORT_C void NotifyThreadSeenL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId);
IMPORT_C void NotifyThreadSeenL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyThreadSeen(MBtraceContextObserver& aObserver);
IMPORT_C void NotifyThreadGoneL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId);
IMPORT_C void NotifyThreadGoneL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyThreadGone(MBtraceContextObserver& aObserver);
IMPORT_C void NotifyThreadExitL(const TDesC& aPattern, TUint aExitTypes, TInt* aReason, const TDesC* aCategory, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional.
IMPORT_C void CancelNotifyThreadExit(MBtraceContextObserver& aObserver);
IMPORT_C void NotifyWindowGroupSeenL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyWindowGroupSeenByThreadNameL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyWindowGroupSeen(MBtraceContextObserver& aObserver);
private:
CBtraceContext(CBtraceReader& aReader, TMode aMode);
void ConstructL();
TUint GetNextThreadId();
TUint GetNextProcessId();
TUint GetNextWindowGroupId();
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
virtual void BtraceBufferHasBeenReset();
private:
class TThread
{
public:
TThread(TUint32 aNThreadAddress, TUint32 aOwningProcess, const TDesC8& aName);
public:
TUint32 iNThreadAddress;
TBtraceThreadId iId;
TUint32 iOwningProcess;
TUint32 iKernelId;
TName iName;
};
class TProcess
{
public:
TProcess(TUint32 aDProcessAddress);
TProcess(TUint32 aDProcessAddress, const TDesC8& aName);
public:
TUint32 iDProcessAddress;
TBtraceProcessId iId;
TName iName;
TInt iReferenceCount;
};
class TWindowGroup
{
public:
TWindowGroup(TInt aWindowGroupId);
TWindowGroup(const TDesC& aName);
TWindowGroup(TInt aWindowGroupId, TThreadId aThreadId, const TDesC& aName);
public:
TBtraceWindowGroupId iId;
TInt iWindowGroupId;
TThreadId iThreadId;
TFullName iName;
};
class TThreadSeenNotif
{
public:
TThreadSeenNotif(TUint aId, const TDesC& aPattern, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
TUint iId;
TName iPattern;
MBtraceContextObserver& iObserver;
TBtraceNotificationPersistence iPersistence;
};
class TThreadGoneNotif
{
public:
TThreadGoneNotif(TUint aId, const TDesC& aPattern, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
TUint iId;
TName iPattern;
MBtraceContextObserver& iObserver;
TBtraceNotificationPersistence iPersistence;
};
class TThreadExitNotif
{
public:
TThreadExitNotif(TUint aId, const TDesC& aPattern, TUint aExitTypes, TInt* aReason, const TDesC* aCategory, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence);
TBool Matches(const TDesC& aThreadName, TExitType aExitType, TInt aReason, const TDesC& aCategory) const;
private:
TBool MatchesType(TExitType aExitType) const;
public:
TUint iId;
TName iPattern;
TUint iExitTypes;
TInt* iReason;
const TDesC* iCategory;
MBtraceContextObserver& iObserver;
TBtraceNotificationPersistence iPersistence;
};
class TWindowGroupSeenNotif
{
public:
enum TPatternType
{
EWindowGroupName,
EThreadName
};
public:
TWindowGroupSeenNotif(TUint aId, const TDesC& aPattern, TPatternType aPatternType, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
TUint iId;
TName iPattern;
TPatternType iPatternType;
MBtraceContextObserver& iObserver;
TBtraceNotificationPersistence iPersistence;
};
private:
void SeenL(const TThread& aThread, const TBtraceTickCount& aTickCount);
void GoneL(const TThread& aThread, const TBtraceTickCount& aTickCount);
void ExitedL(const TThread& aThread, TExitType aExitType, TInt aReason, const TDesC& aCategory, const TBtraceTickCount& aTickCount);
void AppendL(const TThread& aThread, const TBtraceTickCount& aTickCount);
void AppendL(const TProcess& aProcess, const TBtraceTickCount& aTickCount);
void RemoveThread(TInt aPosition);
void SeenAllThreadsL(const TProcess& aProcess, const TBtraceTickCount& aTickCount);
void SeenL(const TWindowGroup& aWindowGroup, const TBtraceTickCount& aTickCount);
static TBool ThreadMatchesId(const TThread& aLeft, const TThread& aRight);
static TBool ThreadMatchesKernelId(const TThread& aLeft, const TThread& aRight);
static TBool ThreadMatchesNThreadAddress(const TThread& aLeft, const TThread& aRight);
static TBool ProcessMatchesId(const TProcess& aLeft, const TProcess& aRight);
static TBool ProcessMatchesDProcessAddress(const TProcess& aLeft, const TProcess& aRight);
static TBool WindowGroupMatchesId(const TWindowGroup& aLeft, const TWindowGroup& aRight);
static TBool WindowGroupMatchesThreadId(const TWindowGroup& aLeft, const TWindowGroup& aRight);
static TBool WindowGroupMatchesWServId(const TWindowGroup& aLeft, const TWindowGroup& aRight);
private:
TMode iMode;
CBtraceReader& iReader;
TUint iNextBtraceThreadId;
TUint iNextBtraceProcessId;
TUint iNextBtraceWindowGroupId;
RArray<TThread> iThreads;
RArray<TProcess> iProcesses;
RArray<TWindowGroup> iWindowGroups;
RArray<TThreadSeenNotif> iThreadSeenNotifs;
RArray<TThreadGoneNotif> iThreadGoneNotifs;
RArray<TThreadExitNotif> iThreadExitNotifs;
RArray<TWindowGroupSeenNotif> iWindowGroupSeenNotifs;
};
class MBtraceCpuUsageObserver
{
public:
enum TContextSwitchType
{
EToThisThread,
EFromThisThread
};
enum TIdleType
{
ENeverScheduled,
EScheduledAtLeastOnce
};
class TCpuUsage
{
public:
TCpuUsage(const TBtraceThreadId& aId);
TCpuUsage(const TBtraceThreadId& aId, const TBtraceTickCount& aTickCount);
public:
TBtraceThreadId iId;
TUint64 iNumFastTicks;
private:
friend class CBtraceCpuUsage;
TBtraceTickCount iSwitchedInAt;
};
public:
virtual void HandleCpuUsageL(const TBtraceTickCount& aTickCount, const TArray<TCpuUsage>& aCpuUsage) = 0;
virtual void HandleContextSwitchL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TContextSwitchType aType) = 0;
virtual void HandleThreadIdleL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TIdleType aIdleType) = 0;
};
NONSHARABLE_CLASS(CBtraceCpuUsage) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtraceCpuUsage* NewL(CBtraceReader& aReader, CBtraceContext& aContext);
IMPORT_C ~CBtraceCpuUsage();
IMPORT_C void NotifyCpuUsageL(TUint32 aNanoTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver);
IMPORT_C void NotifyCpuUsageL(TUint32 aNanoTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyContextSwitchL(const TBtraceThreadId& aId, MBtraceCpuUsageObserver& aObserver);
IMPORT_C void NotifyThreadIdleL(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver);
IMPORT_C void NotifyThreadIdleL(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyThreadIdle(MBtraceCpuUsageObserver& aObserver);
private:
CBtraceCpuUsage(CBtraceReader& aReader, CBtraceContext& aContext);
void ConstructL();
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class RCpuUsageNotif
{
public:
RCpuUsageNotif(TUint32 aStartTickCount, TUint32 aNumNanoTicks, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence);
void Close();
public:
TUint32 iStartTickCount;
TUint32 iNumNanoTicks;
MBtraceCpuUsageObserver* iObserver;
RArray<MBtraceCpuUsageObserver::TCpuUsage> iUsage;
TBtraceNotificationPersistence iPersistence;
};
class TContextSwitchNotif
{
public:
TContextSwitchNotif(const TBtraceThreadId& aId);
TContextSwitchNotif(const TBtraceThreadId& aId, MBtraceCpuUsageObserver& aObserver);
public:
TBtraceThreadId iId;
MBtraceCpuUsageObserver* iObserver;
};
class TThreadIdleNotif
{
public:
TThreadIdleNotif(const TBtraceThreadId& aId);
TThreadIdleNotif(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TUint aNumNanoTicks, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
TBtraceThreadId iId;
TUint32 iNumNanoTicks;
MBtraceCpuUsageObserver* iObserver;
TBtraceTickCount iLastSwitchedOut;
TBool iEverScheduled;
TBtraceNotificationPersistence iPersistence;
};
private:
void HandleContextSwitchL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aNewBtraceThreadId);
void TestCpuUsagePeriodL(const TBtraceTickCount& aTickCount);
void TestThreadIdlenessL(const TBtraceTickCount& aTickCount);
private:
CBtraceReader& iReader;
CBtraceContext& iContext;
RArray<RCpuUsageNotif> iCpuUsageNotifs;
RArray<TContextSwitchNotif> iContextSwitchNotifs;
RArray<TThreadIdleNotif> iThreadIdleNotifs;
TBtraceThreadId iLastBtractThreadId;
TInt iNumIgnoredFrames;
TInt iNumProcessedFrames;
TInt iNumRelevantFrames;
};
class MBtraceKeyPressObserver
{
public:
virtual void HandleKeyPressL(const TBtraceTickCount& aTickCount, const TKeyEvent& aKey) = 0;
virtual void HandlePointerPressL(const TBtraceTickCount& aTickCount, const TPointerEvent& aPointer) = 0;
virtual void HandleUnclassifiedDataL(const TBtraceTickCount& aTickCount, const TInt aCommandClass, const TInt aOpcode, const TAny* aData) = 0;
virtual void HandleRawKeyL(const TBtraceTickCount& aTickCount, TBool aKeyUp, TInt aScanCode) = 0;
};
NONSHARABLE_CLASS(CBtraceKeyPress) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtraceKeyPress* NewL(CBtraceReader& aReader);
IMPORT_C ~CBtraceKeyPress();
IMPORT_C void NotifyKeyEventL(MBtraceKeyPressObserver& aObserver);
IMPORT_C void NotifyKeyEventL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyKeyEvent(MBtraceKeyPressObserver& aObserver);
IMPORT_C void NotifyPointerEventL(MBtraceKeyPressObserver& aObserver);
IMPORT_C void NotifyPointerEventL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyPointerEvent(MBtraceKeyPressObserver& aObserver);
IMPORT_C void NotifyUnclassifiedDataL(MBtraceKeyPressObserver& aObserver);
IMPORT_C void NotifyUnclassifiedDataL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyUnclassifiedData(MBtraceKeyPressObserver& aObserver);
IMPORT_C void NotifyRawKeyEventL(MBtraceKeyPressObserver& aObserver);
IMPORT_C void NotifyRawKeyEventL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyRawKeyEvent(MBtraceKeyPressObserver& aObserver);
private:
CBtraceKeyPress(CBtraceReader& aReader);
void ConstructL();
void SeenKeyL(const TBtraceTickCount& aTickCount, const TKeyEvent& aKey);
void SeenPointerL(const TBtraceTickCount& aTickCount, const TPointerEvent& aKey);
void SeenUnclassifiedL(const TBtraceTickCount& aTickCount, const TInt aCommandClass, const TInt aOpcode, const TAny* aData);
void SeenRawKeyL(const TBtraceTickCount& aTickCount, TBool aKeyUp, TInt aScanCode);
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class TKeyPressNotif
{
public:
TKeyPressNotif(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
MBtraceKeyPressObserver* iObserver;
TBtraceNotificationPersistence iPersistence;
};
CBtraceReader& iReader;
RArray<TKeyPressNotif> iKeyNotifs;
RArray<TKeyPressNotif> iPointerNotifs;
RArray<TKeyPressNotif> iGenericNotifs;
RArray<TKeyPressNotif> iRawKeyNotifs;
};
class MBtraceTextOnScreenObserver
{
public:
virtual void HandleTextSeenL(const TBtraceTickCount& aTickCount, const TDesC& aText, TInt aWindowGroupId) = 0;
};
NONSHARABLE_CLASS(CBtraceTextOnScreen) : public CRefCountedObject, public MBtraceObserver
{
public:
enum TMatchMode
{
EWildNonSpanning,
ESpanningNonWild
};
public:
IMPORT_C static CBtraceTextOnScreen* NewL(CBtraceReader& aReader);
IMPORT_C ~CBtraceTextOnScreen();
IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, MBtraceTextOnScreenObserver& aObserver);
IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, TInt aWindowGroupId, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver);
IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, TInt aWindowGroupId, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyTextOnScreen(MBtraceTextOnScreenObserver& aObserver);
private:
CBtraceTextOnScreen(CBtraceReader& aReader);
void ConstructL();
void SeenL(const TBtraceTickCount& aTickCount, const TDesC& aData, TInt aWindowGroupId);
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class TTextOnScreenNotif
{
public:
TTextOnScreenNotif(const TDesC& aText, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence);
TTextOnScreenNotif(const TDesC& aText, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence);
TTextOnScreenNotif(const TDesC& aText, TInt aWindowGroupId, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
TPtrC iTxtPtr;
TInt iWindowGroupId;
TInt iMatchedChars;
TMatchMode iMatchMode;
MBtraceTextOnScreenObserver* iObserver;
TBtraceNotificationPersistence iPersistence;
};
CBtraceReader& iReader;
RArray<TTextOnScreenNotif> iScreenNotifs;
};
//
// An observer to identify the occurrence of generic events (see btrace_parser_defs.h)
//
class MBtraceGenericObserver
{
public:
virtual void HandleGenericEvent0L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory) = 0;
virtual void HandleGenericEvent1L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1) = 0;
virtual void HandleGenericEvent2L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2) = 0;
virtual void HandleGenericEvent3L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2, TUint32 aData3) = 0;
};
NONSHARABLE_CLASS(CBtraceGeneric) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtraceGeneric* NewL(CBtraceReader& aReader);
IMPORT_C ~CBtraceGeneric();
IMPORT_C void NotifyGenericEventL(MBtraceGenericObserver& aObserver);
private:
CBtraceGeneric(CBtraceReader& aReader);
void ConstructL();
// MBtraceObserver pure virtuals
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
void SeenGeneric0L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory);
void SeenGeneric1L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1);
void SeenGeneric2L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2);
void SeenGeneric3L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2, TUint32 aData3);
private:
CBtraceReader& iReader;
//TODO TBtraceNotificationPersistence iPersistence
RPointerArray<MBtraceGenericObserver> iObservers; // pointers not owned
};
class MBtraceDomainEventObserver
{
public:
virtual void HandleDomainEventL(const TBtraceTickCount& aTickCount, MBtraceDomainEventObserver& aObserver) = 0;
};
NONSHARABLE_CLASS(CBtraceDomainEvent) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtraceDomainEvent* NewL(CBtraceReader& aReader);
IMPORT_C ~CBtraceDomainEvent();
IMPORT_C void NotifyDomainEventL(TUint aSubCategory, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyDomainEventL(TUint aSubCategory, TUint aData1, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyDomainEventL(TUint aSubCategory, TUint aData1, TUint aData2, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyDomainEventL(TUint aSubCategory, TUint aData1, TUint aData2, TUint aData3, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyDomainEvent(MBtraceDomainEventObserver& aObserver);
private:
CBtraceDomainEvent(CBtraceReader& aReader);
void ConstructL();
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class TDomainEventNotif
{
public:
TDomainEventNotif(TUint aSubCategory);
TDomainEventNotif(TUint aSubCategory, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence);
void AddDataItem(TUint aData);
TBool operator==(const TDomainEventNotif& aNotif) const;
public:
enum { KMaxNumDataItems = 3 };
public:
TUint iSubCategory;
MBtraceDomainEventObserver* iObserver;
TBtraceNotificationPersistence iPersistence;
TInt iDataCount;
TFixedArray<TUint, KMaxNumDataItems> iData;
};
private:
CBtraceReader& iReader;
RArray<TDomainEventNotif> iNotifs;
};
class MBtraceAppResponseObserver
{
public:
virtual void HandleAppResponseSeenL(const TBtraceTickCount& aTickCount) = 0;
};
NONSHARABLE_CLASS(CBtraceAppResponse) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtraceAppResponse* NewL(CBtraceReader& aReader);
IMPORT_C ~CBtraceAppResponse();
IMPORT_C void NotifyAppResponseL(MBtraceAppResponseObserver& aObserver, const TProcessId& aProcessId);
IMPORT_C void NotifyAppResponseL(MBtraceAppResponseObserver& aObserver, const TProcessId& aProcessId, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyAppResponse(MBtraceAppResponseObserver& aObserver);
private:
CBtraceAppResponse(CBtraceReader& aReader);
void ConstructL();
void SeenAppResponseL(const TBtraceTickCount& aTickCount, const TProcessId& aProcessId);
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class TAppResponseNotif
{
public:
TAppResponseNotif(MBtraceAppResponseObserver& aObserver, const TProcessId& aProcessId, TBtraceNotificationPersistence aPersistence);
public:
MBtraceAppResponseObserver& iObserver;
TProcessId iProcessId;
TBtraceNotificationPersistence iPersistence;
};
private:
CBtraceReader& iReader;
RArray<TAppResponseNotif> iNotifs;
};
class MBtraceScreenUpdateObserver
{
public:
virtual void HandleScreenUpdateL(const TBtraceTickCount& aTickCount, TInt aScreenNumber, const TRect& aRect) = 0;
};
NONSHARABLE_CLASS(CBtraceScreenUpdate) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtraceScreenUpdate* NewL(CBtraceReader& aReader);
IMPORT_C ~CBtraceScreenUpdate();
IMPORT_C void NotifyScreenUpdateL(MBtraceScreenUpdateObserver& aObserver);
IMPORT_C void NotifyScreenUpdateL(MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void NotifyScreenUpdateL(TInt aScreenNumber, const TRect& aRect, MBtraceScreenUpdateObserver& aObserver);
IMPORT_C void NotifyScreenUpdateL(TInt aScreenNumber, const TRect& aRect, MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyScreenUpdate(MBtraceScreenUpdateObserver& aObserver);
private:
CBtraceScreenUpdate(CBtraceReader& aReader);
void ConstructL();
void HandleScreenUpdateL(const TBtraceTickCount& aTickCount, TInt aScreenNumber, const TRect& aRect);
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class TScreenUpdateNotif
{
public:
TScreenUpdateNotif(MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence);
TScreenUpdateNotif(TInt aScreenNumber, const TRect& aRect, MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
TBool iNotifyAll;
TInt iScreenNumber;
TRect iRect;
MBtraceScreenUpdateObserver* iObserver;
TBtraceNotificationPersistence iPersistence;
};
private:
CBtraceReader& iReader;
RArray<TScreenUpdateNotif> iNotifs;
};
class MBtracePubSubObserver
{
public:
virtual void HandlePropertyChangedL(const TBtraceTickCount& aTickCount, TUint aCategory, TUint aKey, TInt aNewValue) = 0;
virtual void HandlePropertyChangedL(const TBtraceTickCount& aTickCount, TUint aCategory, TUint aKey, const TDesC8& aNewValue) = 0;
};
NONSHARABLE_CLASS(CBtracePubSub) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtracePubSub* NewL(CBtraceReader& aReader);
IMPORT_C ~CBtracePubSub();
IMPORT_C void NotifyPropertyChangedL(MBtracePubSubObserver& aObserver);
IMPORT_C void NotifyPropertyChangedL(TUint* aCategory, TUint* aKey, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional.
IMPORT_C void NotifyIntegerPropertyChangedL(TUint* aCategory, TUint* aKey, TInt* aValue, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional.
IMPORT_C void NotifyDataPropertyChangedL(TUint* aCategory, TUint* aKey, const TDesC8* aValue, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional.
IMPORT_C void CancelNotifyPropertyChanged(MBtracePubSubObserver& aObserver);
private:
CBtracePubSub(CBtraceReader& aReader);
void ConstructL();
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class TPubSubNotif
{
public:
TPubSubNotif(TUint* aCategory, TUint* aKey, TInt* aIntegerValue, const TDesC8* aDataValue, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence);
TBool Matches(TUint aCategory, TUint aKey, TInt aIntegerValue) const;
TBool Matches(TUint aCategory, TUint aKey, const TDesC8& aDataValue) const;
public:
TUint* iCategory;
TUint* iKey;
TInt* iIntegerValue;
const TDesC8* iDataValue;
MBtracePubSubObserver& iObserver;
TBtraceNotificationPersistence iPersistence;
};
private:
CBtraceReader& iReader;
RArray<TPubSubNotif> iNotifs;
};
class MBtraceFocusChangeObserver
{
public:
virtual void HandleFocusChangedL(const TBtraceTickCount& aTickCount, const TBtraceWindowGroupId& aWindowGroupId) = 0;
};
NONSHARABLE_CLASS(CBtraceFocusChange) : public CRefCountedObject, public MBtraceObserver
{
public:
IMPORT_C static CBtraceFocusChange* NewL(CBtraceReader& aReader, CBtraceContext& aContext);
IMPORT_C ~CBtraceFocusChange();
IMPORT_C void NotifyFocusChangedL(const TDesC& aWindowGroupNamePattern, MBtraceFocusChangeObserver& aObserver);
IMPORT_C void NotifyFocusChangedL(const TDesC& aWindowGroupNamePattern, MBtraceFocusChangeObserver& aObserver, TBtraceNotificationPersistence aPersistence);
IMPORT_C void CancelNotifyFocusChanged(MBtraceFocusChangeObserver& aObserver);
private:
CBtraceFocusChange(CBtraceReader& aReader, CBtraceContext& aContext);
void ConstructL();
private: // From MBtraceObserver.
virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame);
private:
class TFocusChangeNotif
{
public:
TFocusChangeNotif(const TDesC& aWindowGroupNamePattern, MBtraceFocusChangeObserver& aObserver, TBtraceNotificationPersistence aPersistence);
public:
TPtrC iWindowGroupNamePattern;
MBtraceFocusChangeObserver& iObserver;
TBtraceNotificationPersistence iPersistence;
};
private:
CBtraceReader& iReader;
CBtraceContext& iContext;
RArray<TFocusChangeNotif> iNotifs;
};
#endif // __BTRACE_PARSER_H__