diff -r 4fde310f06fe -r 86a2e675b80a memspy/MemSpyClient/src/memspysession.cpp --- a/memspy/MemSpyClient/src/memspysession.cpp Mon Jun 14 11:37:33 2010 +0300 +++ b/memspy/MemSpyClient/src/memspysession.cpp Mon Jun 28 15:36:07 2010 +0300 @@ -17,12 +17,14 @@ #include "memspysession.h" + #include - -#include -#include -#include -#include +// API +#include +#include +#include +#include +#include //KernelObjects #include // IMPLEMENTATION @@ -95,87 +97,6 @@ return KErrNone; } -//inline void RMemSpySession::Close() -// { -// RSessionBase::Close(); -// } -// -//inline TMemSpySinkType RMemSpySession::GetSinkType() -// { -// TPckgBuf OutBuf; -// TIpcArgs args( &OutBuf ); -// SendReceive( EGetSinkType, args ); -// return OutBuf(); -// } -// -//inline void RMemSpySession::OutputKernelObjects() -// { -// SendReceive( EOutputKernelObjects ); -// } -// -//inline void RMemSpySession::OutputToDebug() -// { -// SendReceive( EOutputToDebug ); -// } -// -//inline void RMemSpySession::OutputToFile() -// { -// SendReceive( EOutputToFile ); -// } -// -//inline void RMemSpySession::SetServerTimeOutStatus( TUint32 aValue, TBool aEnabled ) -// { -// TPckgBuf In1(aValue); -// TPckgBuf In2(aEnabled); -// TIpcArgs args( &In1, &In2 ); -// SendReceive( ESetServerTimeOutStatus, args ); -// } - -//inline void RMemSpySession::OutputProcessInfo( TMemSpyProcess aProcess ) -// { -// TProcessId iId = aProcess.iId; -// TPckgBuf In( iId ); -// TIpcArgs args( &In ); -// SendReceive( EOutputProcessInfo, args ); -// } - -////Processes operations -//inline TInt RMemSpySession::ProcessesCount() -// { -// TPckgBuf Out; -// TIpcArgs args( &Out ); -// SendReceive( EProcessesCount, args ); -// return Out(); -// } -// -//inline TMemSpyProcess RMemSpySession::GetProcessByIndex( TInt aIndex ) -// { -// TPckgBuf In( aIndex ); -// TPckgBuf Out; -// TIpcArgs args( &In, &Out ); -// SendReceive( EProcessByIndex, args ); -// return Out(); -// } -// -//inline TInt RMemSpySession::ProcessIndexById( TProcessId aId ) -// { -// TPckgBuf In( aId ); -// TPckgBuf Out; -// TIpcArgs args( &In, &Out ); -// SendReceive( EProcessIndexById, args ); -// return Out(); -// } -// -//inline TBool RMemSpySession::ProcessIsDead( TMemSpyProcess aProcess ) -// { -// TProcessId iId = aProcess.iId; -// TPckgBuf In( iId ); -// TPckgBuf Out; -// TIpcArgs args( &In, &Out ); -// SendReceive( EProcessIsDead, args ); -// return Out(); -// } - EXPORT_C void RMemSpySession::GetProcessesL(RArray &aProcesses, TSortType aSortType) { TPckgBuf count; @@ -320,7 +241,7 @@ return error; } -EXPORT_C void RMemSpySession::GetThreadInfoItems( RArray &aInfoItems, TThreadId aId, TMemSpyThreadInfoItemType aType ) +EXPORT_C void RMemSpySession::GetThreadInfoItemsL( RArray &aInfoItems, TThreadId aId, TMemSpyThreadInfoItemType aType ) { TPckgBuf id( aId ); TPckgBuf type( aType ); @@ -344,73 +265,116 @@ TIpcArgs args( &requestedCount, &id, &type, &bufferPtr ); TInt error = SendReceive( EMemSpyClientServerOpGetThreadInfoItems, args ); + + aInfoItems.Reset(); for(TInt i=0, offset = 0; i < itemCount; i++, offset+=sizeof(TMemSpyThreadInfoItemData)) { TPckgBuf data; data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyThreadInfoItemData)); - aInfoItems.AppendL(CMemSpyApiThreadInfoItem::NewL(data())); + aInfoItems.AppendL(CMemSpyApiThreadInfoItem::NewLC(data())); } - + + CleanupStack::Pop(aInfoItems.Count()); CleanupStack::PopAndDestroy(buffer); } - } + } + + User::LeaveIfError(error); + } + +EXPORT_C TInt RMemSpySession::GetThreadInfoItems( RArray &aInfoItems, TThreadId aId, TMemSpyThreadInfoItemType aType ) + { + TRAPD(error, GetThreadInfoItemsL(aInfoItems, aId, aType)); + return error; } //Kernel Objects specific operations -EXPORT_C TInt RMemSpySession::GetKernelObjects( RArray &aKernelObjects ) +EXPORT_C void RMemSpySession::GetKernelObjectsL( RArray &aKernelObjects ) { TPckgBuf count; - TInt error = SendReceive( EMemSpyClientServerOpGetKernelObjectCount, TIpcArgs(&count) ); + User::LeaveIfError(SendReceive( EMemSpyClientServerOpGetKernelObjectCount, TIpcArgs(&count) )); + + TInt requestedCount = count(); + HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyKernelObjectData)); + TPtr8 bufferPtr(buffer->Des()); + + TIpcArgs args( &count, &bufferPtr ); + User::LeaveIfError(SendReceive( EMemSpyClientServerOpGetKernelObjects, args )); + + aKernelObjects.Reset(); + + for(TInt i=0, offset = 0; i data; + data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyKernelObjectData)); + aKernelObjects.AppendL(CMemSpyApiKernelObject::NewLC(data())); + } - if( error == KErrNone ) - { - TInt requestedCount = count(); - HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyKernelObjectData)); - TPtr8 bufferPtr(buffer->Des()); - - TPckgBuf count(requestedCount); - TIpcArgs args( &count, &bufferPtr ); - TInt error = SendReceive( EMemSpyClientServerOpGetKernelObjects, args ); - - for(TInt i=0, offset = 0; i data; - data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyKernelObjectData)); - aKernelObjects.AppendL(CMemSpyApiKernelObject::NewL(data())); - } - - CleanupStack::PopAndDestroy(buffer); - } - return KErrNone; + CleanupStack::Pop(aKernelObjects.Count()); + CleanupStack::PopAndDestroy(buffer); + } + +EXPORT_C TInt RMemSpySession::GetKernelObjects( RArray &aKernelObjects ) + { + TRAPD(error, GetKernelObjectsL(aKernelObjects)); + return error; + } + +EXPORT_C void RMemSpySession::GetKernelObjectItemsL( RArray &aKernelObjectItems, TMemSpyDriverContainerType aForContainer ) + { + TPckgBuf count; + TPckgBuf type(aForContainer); + User::LeaveIfError(SendReceive( EMemSpyClientServerOpGetKernelObjectItemCount, TIpcArgs(&count, &type) )); + + TInt requestedCount = count(); + HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyDriverHandleInfoGeneric)); + TPtr8 bufferPtr(buffer->Des()); + + TIpcArgs args( &count, &type, &bufferPtr ); + User::LeaveIfError(SendReceive( EMemSpyClientServerOpGetKernelObjectItems, args )); + + aKernelObjectItems.Reset(); + + for(TInt i=0, offset = 0; i data; + data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyDriverHandleInfoGeneric)); + aKernelObjectItems.AppendL( CMemSpyApiKernelObjectItem::NewLC( data() ) ); + } + CleanupStack::Pop(aKernelObjectItems.Count()); + CleanupStack::PopAndDestroy(buffer); } EXPORT_C TInt RMemSpySession::GetKernelObjectItems( RArray &aKernelObjectItems, TMemSpyDriverContainerType aForContainer ) { + TRAPD(error, GetKernelObjectItemsL(aKernelObjectItems, aForContainer)); + return error; + } + +EXPORT_C void RMemSpySession::GetMemoryTrackingCyclesL(RArray& aCycles) + { TPckgBuf count; - TPckgBuf type(aForContainer); - TInt error = SendReceive( EMemSpyClientServerOpGetKernelObjectItemCount, TIpcArgs(&count, &type) ); - - if (error == KErrNone) - { - TInt requestedCount = count(); - HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyDriverHandleInfoGeneric)); - TPtr8 bufferPtr(buffer->Des()); + User::LeaveIfError(SendReceive( EMemSpyClientServerOpGetMemoryTrackingCycleCount, TIpcArgs(&count) )); + + TInt requestedCount = count(); + HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyMemoryTrackingCycleData)); + TPtr8 bufferPtr(buffer->Des()); - TPckgBuf count(requestedCount); - TIpcArgs args( &count, &type, &bufferPtr ); - TInt error = SendReceive( EMemSpyClientServerOpGetKernelObjectItems, args ); - - for(TInt i=0, offset = 0; i data; - data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyDriverHandleInfoGeneric)); - aKernelObjectItems.AppendL( CMemSpyApiKernelObjectItem::NewL( data() ) ); - } - - CleanupStack::PopAndDestroy(buffer); + TIpcArgs args( &count, &bufferPtr ); + User::LeaveIfError(SendReceive( EMemSpyClientServerOpGetMemoryTrackingCycles, args )); + + aCycles.Reset(); + + for(TInt i=0, offset = 0; i data; + data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyMemoryTrackingCycleData)); + aCycles.AppendL(CMemSpyApiMemoryTrackingCycle::NewLC(data())); } - return KErrNone; + + CleanupStack::Pop(aCycles.Count()); + CleanupStack::PopAndDestroy(buffer); } EXPORT_C void RMemSpySession::OutputAllContainerContents() @@ -420,82 +384,323 @@ //Heap specific operations -EXPORT_C CMemSpyApiHeap* RMemSpySession::GetHeap() + +EXPORT_C CMemSpyApiHeap* RMemSpySession::GetHeapL() { CMemSpyApiHeap* aHeap; - TInt error = KErrNone; HBufC8* buffer = HBufC8::NewLC( sizeof(TMemSpyHeapData) ); TPtr8 bufferPtr(buffer->Des()); TIpcArgs args( &bufferPtr ); - error = SendReceive( EMemSpyClientServerOpGetHeap, args ); + User::LeaveIfError(SendReceive( EMemSpyClientServerOpGetHeap, args )); - if( error == KErrNone ) - { - TPckgBuf data; - data.Copy(bufferPtr.Ptr(), sizeof(TMemSpyHeapData)); - aHeap = CMemSpyApiHeap::NewL( data() ); - } + TPckgBuf data; + data.Copy(bufferPtr.Ptr(), sizeof(TMemSpyHeapData)); + aHeap = CMemSpyApiHeap::NewL( data() ); + CleanupStack::PopAndDestroy(buffer); return aHeap; } +EXPORT_C CMemSpyApiHeap* RMemSpySession::GetHeap() + { + CMemSpyApiHeap *result = NULL; + TRAPD(error, result = GetHeapL()); + return error == KErrNone ? result : NULL; + } + EXPORT_C void RMemSpySession::DumpKernelHeap() { SendReceive( EMemSpyClientServerOpDumpKernelHeap ); } -EXPORT_C void RMemSpySession::OutputKernelHeapDataL(TMemSpyOutputType aOutputType) - { - SetOutputTypeL(aOutputType); - +EXPORT_C void RMemSpySession::OutputKernelHeapDataL() + { User::LeaveIfError(SendReceive(EMemSpyClientServerOpHeapData | KMemSpyOpFlagsIncludesThreadId, TIpcArgs(KMemSpyClientServerThreadIdKernel))); } -EXPORT_C void RMemSpySession::OutputThreadHeapDataL(TMemSpyOutputType aOutputType, TThreadId aThreadId) + +EXPORT_C void RMemSpySession::OutputKernelHeapData(TRequestStatus& aStatus) { - SetOutputTypeL(aOutputType); - + SendReceive(EMemSpyClientServerOpHeapData, + TIpcArgs(KMemSpyClientServerThreadIdKernel), + aStatus); + } + +EXPORT_C void RMemSpySession::OutputThreadHeapDataL( TThreadId aThreadId) + { User::LeaveIfError(SendReceive(EMemSpyClientServerOpHeapData | KMemSpyOpFlagsIncludesThreadId, TIpcArgs(aThreadId))); } -EXPORT_C void RMemSpySession::OutputThreadCellListL(TMemSpyOutputType aOutputType, TThreadId aThreadId) - { - SetOutputTypeL(aOutputType); - + +EXPORT_C void RMemSpySession::OutputThreadHeapDataL(const TDesC& aThreadName) + { + const TIpcArgs args( &aThreadName ); + + User::LeaveIfError( SendReceive( EMemSpyClientServerOpHeapData | KMemSpyOpFlagsIncludesThreadName, args )); + } + +EXPORT_C void RMemSpySession::OutputThreadCellListL(TThreadId aThreadId) + { User::LeaveIfError(SendReceive(EMemSpyClientServerOpHeapCellListing | KMemSpyOpFlagsIncludesThreadId, TIpcArgs(aThreadId))); } -EXPORT_C void RMemSpySession::OutputKernelObjectsL(TMemSpyOutputType aOutputType) +EXPORT_C void RMemSpySession::OutputHeapInfoUserL(TThreadId aThreadId) + { + User::LeaveIfError(SendReceive( EMemSpyClientServerOpHeapInfo | KMemSpyOpFlagsIncludesThreadId, + TIpcArgs(aThreadId))); + } + +EXPORT_C void RMemSpySession::SwitchOutputSinkL( TMemSpySinkType aType ) + { + TInt op; + if( aType == ESinkTypeFile ) + op = EMemSpyClientServerOpSwitchOutputSinkFile; + else + op = EMemSpyClientServerOpSwitchOutputSinkTrace; + + User::LeaveIfError(SendReceive( op )); + } + +EXPORT_C void RMemSpySession::SwitchOutputToTraceL() + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSwitchOutputSinkTrace)); + } + +EXPORT_C void RMemSpySession::SwitchOutputToFileL(const TDesC& aRootFolder) { - SetOutputTypeL(aOutputType); - + TIpcArgs args; + if (aRootFolder.Length()) + { + args.Set(0, &aRootFolder); + } + + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSwitchOutputSinkFile, args)); + } + +EXPORT_C void RMemSpySession::OutputStackInfoL(TThreadId aThreadId) + { + User::LeaveIfError(SendReceive( EMemSpyClientServerOpStackInfo | KMemSpyOpFlagsIncludesThreadId, + TIpcArgs(aThreadId))); + } + +EXPORT_C void RMemSpySession::OutputStackDataL(TThreadId aThreadId, TMemSpyDriverDomainType aType ) + { + TInt op; + if( aType == EMemSpyDriverDomainUser ) + op = EMemSpyClientServerOpStackDataUser; + else + op = EMemSpyClientServerOpStackDataKernel; + + User::LeaveIfError(SendReceive( op | KMemSpyOpFlagsIncludesThreadId, + TIpcArgs(aThreadId, aType))); + + } + +EXPORT_C void RMemSpySession::OutputThreadInfoHandlesL(TThreadId aThreadId) + { + TPckgBuf id(aThreadId); + User::LeaveIfError(SendReceive(EMemSpyClientServerOpOutputInfoHandles, TIpcArgs( &id ))); + } + +EXPORT_C void RMemSpySession::OutputAOListL(TThreadId aId, TMemSpyThreadInfoItemType aType) + { + TPckgBuf id(aId); + TPckgBuf type(aType); + + User::LeaveIfError(SendReceive(EMemSpyClientServerOpOutputAOList, TIpcArgs( &id, &type ))); + } + +EXPORT_C void RMemSpySession::OutputKernelObjectsL() + { User::LeaveIfError(SendReceive(EMemSpyClientServerOpEnumerateKernelContainerAll)); } -EXPORT_C void RMemSpySession::OutputCompactStackInfoL(TMemSpyOutputType aOutputType) +EXPORT_C void RMemSpySession::OutputCompactStackInfoL() { - SetOutputTypeL(aOutputType); - User::LeaveIfError(SendReceive(EMemSpyClientServerOpStackInfoCompact)); } -EXPORT_C void RMemSpySession::OutputCompactHeapInfoL(TMemSpyOutputType aOutputType) +EXPORT_C void RMemSpySession::OutputCompactHeapInfoL() + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpHeapInfoCompact)); + } +// Asynchronous operations +EXPORT_C void RMemSpySession::OutputPhoneInfo(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpSummaryInfo | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputDetailedPhoneInfo(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpSummaryInfoDetailed | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputHeapInfo(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpHeapInfo | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputCompactHeapInfo(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpHeapInfoCompact | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputHeapCellListing(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpHeapCellListing | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputHeapData(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpHeapData | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +// synchronous version of the operation - for CLI +EXPORT_C void RMemSpySession::OutputHeapData() { - SetOutputTypeL(aOutputType); - - User::LeaveIfError(SendReceive(EMemSpyClientServerOpHeapInfoCompact)); + SendReceive(EMemSpyClientServerOpHeapData); + } + +EXPORT_C void RMemSpySession::OutputStackInfo(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpStackInfo | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputCompactStackInfo(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpStackInfoCompact | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputUserStackData(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpStackDataUser | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +EXPORT_C void RMemSpySession::OutputKernelStackData(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpStackDataKernel | KMemSpyOpFlagsAsyncOperation, TIpcArgs(), aStatus); + } + +// Synchronous operations +EXPORT_C void RMemSpySession::OutputPhoneInfo() + { + SendReceive( EMemSpyClientServerOpSummaryInfo , TIpcArgs() ); + } + +EXPORT_C void RMemSpySession::SetSwmtConfig( TMemSpyEngineHelperSysMemTrackerConfig aConfig ) + { + TPckgBuf config(aConfig); + TIpcArgs args( &config ); + + SendReceive( EMemSpyClientServerOpSetSwmtConfig, args) ; + } + +EXPORT_C void RMemSpySession::SetSwmtAutoStartProcessList( CArrayFixFlat* aList ) + { + TInt count = aList->Count(); + TIpcArgs args( &aList, &count ); + + SendReceive( EMemSpyClientServerOpSetSwmtAutoStartProcessList, args ); + } + +EXPORT_C void RMemSpySession::SwmtResetTracking() + { + SendReceive( EMemSpyClientServerOpSystemWideMemoryTrackingReset ); } -void RMemSpySession::SetOutputTypeL(TMemSpyOutputType aOutputType) +EXPORT_C void RMemSpySession::GetOutputSink( TMemSpySinkType aType ) + { + TPckgBuf type( aType ); + TIpcArgs args( &type ); + + SendReceive( EMemSpyClientServerOpGetOutputSink, args ); + } + +EXPORT_C void RMemSpySession::NotifyDeviceWideOperationProgress(TMemSpyDeviceWideOperationProgress &aProgress, TRequestStatus &aStatus) + { + SendReceive(EMemSpyClientServerOpNotifyDeviceWideOperationProgress | KMemSpyOpFlagsAsyncOperation, + TIpcArgs(&aProgress.iProgress, &aProgress.iDescription), + aStatus); + } + +EXPORT_C void RMemSpySession::CancelDeviceWideOperationL() + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpCancelDeviceWideOperation)); + } + +// SWMT operations +EXPORT_C void RMemSpySession::SetSwmtCategoriesL(TInt aCategories) + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingCategoriesSet, + TIpcArgs(aCategories))); + } + +EXPORT_C void RMemSpySession::SetSwmtHeapDumpsEnabledL(TBool aEnabled) + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingHeapDumpSet, + TIpcArgs(aEnabled))); + } + +EXPORT_C TBool RMemSpySession::IsSwmtRunningL() + { + TPckgBuf ret; + User::LeaveIfError(SendReceive(EMemSpyClientServerOpIsSwmtRunning, TIpcArgs(&ret))); + + return ret(); + } + +EXPORT_C void RMemSpySession::StartSwmtTimerL(TInt aPeriod) { - TInt operation = aOutputType == EOutputTypeFile ? - EMemSpyClientServerOpSwitchOutputSinkFile : - EMemSpyClientServerOpSwitchOutputSinkTrace; - - User::LeaveIfError(SendReceive(operation)); + SetSwmtTimerIntervalL(aPeriod); + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingTimerStart)); + } + +EXPORT_C void RMemSpySession::StartSwmtTimerL() + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingTimerStart)); + } + +EXPORT_C void RMemSpySession::SetSwmtTimerIntervalL(TInt aPeriod) + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodSet, + TIpcArgs(aPeriod))); + } + +EXPORT_C void RMemSpySession::StopSwmtTimerL() + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingTimerStop)); } + + +EXPORT_C void RMemSpySession::ForceSwmtUpdateL() + { + User::LeaveIfError(SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingForceUpdate)); + } + +EXPORT_C void RMemSpySession::ForceSwmtUpdate(TRequestStatus& aStatus) + { + SendReceive(EMemSpyClientServerOpSystemWideMemoryTrackingForceUpdate, + TIpcArgs(), + aStatus); + } + +EXPORT_C void RMemSpySession::SetSwmtFilter( const TDesC& aFilter ) + { + TIpcArgs args( &aFilter ); + User::LeaveIfError( SendReceive( EMemSpyClientServerOpSystemWideMemoryTrackingThreadNameFilterSet, args ) ); + } + +EXPORT_C TInt TMemSpyDeviceWideOperationProgress::Progress() const + { + return iProgress(); + } + +EXPORT_C const TDesC& TMemSpyDeviceWideOperationProgress::Description() const + { + return iDescription; + }