1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include <memspy/engine/memspyengine.h>

    19 

    20 // System includes

    21 #include <e32debug.h>

    22 

    23 // User includes

    24 #include <memspy/engine/memspyengineimp.h>

    25 

    26 

    27 CMemSpyEngine::CMemSpyEngine()

    28     {

    29     }

    30 

    31 

    32 EXPORT_C CMemSpyEngine::~CMemSpyEngine()

    33     {

    34 #ifdef _DEBUG

    35     RDebug::Printf( "CMemSpyEngine::~CMemSpyEngine() - START" );

    36 #endif

    37 

    38     delete iImp;

    39 

    40 #ifdef _DEBUG

    41     RDebug::Printf( "CMemSpyEngine::~CMemSpyEngine() - END" );

    42 #endif

    43     }

    44 

    45 

    46 void CMemSpyEngine::ConstructL( RFs& aFsSession )

    47     {

    48 #ifdef _DEBUG

    49     RDebug::Printf( "CMemSpyEngine::ConstructL() - START" );

    50 #endif

    51     

    52     iImp = new(ELeave) CMemSpyEngineImp( aFsSession, *this );

    53     iImp->ConstructL();

    54 

    55 #ifdef _DEBUG

    56     RDebug::Printf( "CMemSpyEngine::ConstructL() - END" );

    57 #endif

    58     }

    59 

    60 

    61 EXPORT_C CMemSpyEngine* CMemSpyEngine::NewL( RFs& aFsSession )

    62     {

    63     CMemSpyEngine* self = new(ELeave) CMemSpyEngine();

    64     CleanupStack::PushL( self );

    65     self->ConstructL( aFsSession );

    66     CleanupStack::Pop( self );

    67     return self;

    68     }

    69 

    70 EXPORT_C CMemSpyEngine* CMemSpyEngine::NewL( RFs& aFsSession, TBool aStartServer )

    71     {

    72     return NewL(aFsSession);

    73     }

    74 

    75 EXPORT_C RFs& CMemSpyEngine::FsSession()

    76     {

    77     return iImp->FsSession();

    78     }

    79 

    80 

    81 EXPORT_C CMemSpyEngineObjectContainer& CMemSpyEngine::Container()

    82     {

    83     return iImp->Container();

    84     }

    85 

    86 

    87 EXPORT_C const CMemSpyEngineObjectContainer& CMemSpyEngine::Container() const

    88     {

    89     return iImp->Container();

    90     }

    91 

    92 

    93 EXPORT_C void CMemSpyEngine::SetObserver( MMemSpyEngineObserver* aObserver )

    94     {

    95     iImp->SetObserver( aObserver );

    96     }

    97 

    98 

    99 void CMemSpyEngine::NotifyContainerChangeL()

   100     {

   101     iImp->NotifyContainerChangeL();

   102     }

   103 

   104 

   105 void CMemSpyEngine::NotifyClientServerOperationRequestL( TInt aType )

   106     {

   107     iImp->NotifyClientServerOperationRequestL( aType );

   108     }

   109 

   110 

   111 EXPORT_C CMemSpyEngineOutputSink& CMemSpyEngine::Sink()

   112     {

   113     return iImp->Sink();

   114     }

   115 

   116 

   117 EXPORT_C TMemSpySinkType CMemSpyEngine::SinkType()

   118     {

   119     return iImp->SinkType();

   120     }

   121 

   122 

   123 EXPORT_C void CMemSpyEngine::InstallSinkL( TMemSpySinkType aType )

   124     {

   125     iImp->InstallSinkL( aType, KNullDesC );

   126     }

   127 

   128 EXPORT_C void CMemSpyEngine::InstallDebugSinkL()

   129     {

   130     iImp->InstallSinkL( ESinkTypeDebug, KNullDesC );

   131     }

   132 

   133 EXPORT_C void CMemSpyEngine::InstallFileSinkL( const TDesC& aRootFolder )

   134     {

   135     iImp->InstallSinkL( ESinkTypeFile, aRootFolder );

   136     }

   137 

   138 EXPORT_C void CMemSpyEngine::ListOpenFilesL()

   139     {

   140     iImp->ListOpenFilesL();

   141     }

   142 

   143 

   144 EXPORT_C void CMemSpyEngine::GetVersion( TVersion& aVersion )

   145     {

   146     iImp->GetVersion( aVersion );

   147     }

   148 

   149 

   150 EXPORT_C TBool CMemSpyEngine::IsHelperWindowServerSupported()

   151     {

   152     return iImp->IsHelperWindowServerSupported();

   153     }

   154 

   155 

   156 CMemSpyEngineMidwife& CMemSpyEngine::Midwife()

   157     {

   158     return iImp->Midwife();

   159     }

   160 

   161 

   162 CMemSpyEngineUndertaker& CMemSpyEngine::Undertaker()

   163     {

   164     return iImp->Undertaker();

   165     }

   166 

   167 

   168 CMemSpyEngineChunkWatcher& CMemSpyEngine::ChunkWatcher()

   169     {

   170     return iImp->ChunkWatcher();

   171     }

   172 

   173 

   174 EXPORT_C CMemSpyEngineHelperHeap& CMemSpyEngine::HelperHeap()

   175     {

   176     return iImp->HelperHeap();

   177     }

   178 

   179 

   180 EXPORT_C CMemSpyEngineHelperStack& CMemSpyEngine::HelperStack()

   181     {

   182     return iImp->HelperStack();

   183     }

   184 

   185 

   186 EXPORT_C CMemSpyEngineHelperCodeSegment& CMemSpyEngine::HelperCodeSegment()

   187     {

   188     return iImp->HelperCodeSegment();

   189     }

   190 

   191 

   192 EXPORT_C CMemSpyEngineHelperChunk& CMemSpyEngine::HelperChunk()

   193     {

   194     return iImp->HelperChunk();

   195     }

   196 

   197 

   198 EXPORT_C CMemSpyEngineHelperThread& CMemSpyEngine::HelperThread()

   199     {

   200     return iImp->HelperThread();

   201     }

   202 

   203 

   204 EXPORT_C CMemSpyEngineHelperProcess& CMemSpyEngine::HelperProcess()

   205     {

   206     return iImp->HelperProcess();

   207     }

   208 

   209 

   210 EXPORT_C CMemSpyEngineHelperServer& CMemSpyEngine::HelperServer()

   211     {

   212     return iImp->HelperServer();

   213     }

   214 

   215 

   216 EXPORT_C CMemSpyEngineHelperActiveObject& CMemSpyEngine::HelperActiveObject()

   217     {

   218     return iImp->HelperActiveObject();

   219     }

   220 

   221 

   222 EXPORT_C CMemSpyEngineHelperKernelContainers& CMemSpyEngine::HelperKernelContainers()

   223     {

   224     return iImp->HelperKernelContainers();

   225     }

   226 

   227 

   228 EXPORT_C CMemSpyEngineHelperFileSystem& CMemSpyEngine::HelperFileSystem()

   229     {

   230     return iImp->HelperFileSystem();

   231     }

   232 

   233 

   234 EXPORT_C CMemSpyEngineHelperECom& CMemSpyEngine::HelperECom()

   235     {

   236     return iImp->HelperECom();

   237     }

   238 

   239 

   240 EXPORT_C CMemSpyEngineHelperSysMemTracker& CMemSpyEngine::HelperSysMemTracker()

   241     {

   242     return iImp->HelperSysMemTracker();

   243     }

   244 

   245 

   246 EXPORT_C CMemSpyEngineHelperFbServ& CMemSpyEngine::HelperFbServ()

   247     {

   248     return iImp->HelperFbServ();

   249     }

   250 

   251 

   252 EXPORT_C CMemSpyEngineHelperROM& CMemSpyEngine::HelperROM()

   253     {

   254     return iImp->HelperROM();

   255     }

   256 

   257 

   258 EXPORT_C CMemSpyEngineHelperRAM& CMemSpyEngine::HelperRAM()

   259     {

   260     return iImp->HelperRAM();

   261     }

   262 

   263 

   264 EXPORT_C MMemSpyEngineHelperWindowServer& CMemSpyEngine::HelperWindowServer()

   265     {

   266     return iImp->HelperWindowServer();

   267     }

   268 

   269 

   270 EXPORT_C CMemSpyEngineHelperCondVar& CMemSpyEngine::HelperCondVar()

   271     {

   272     return iImp->HelperCondVar();

   273     }

   274 

   275 

   276 RMemSpyDriverClient& CMemSpyEngine::Driver()

   277     {

   278     return iImp->Driver();

   279     }

   280 

   281 

   282 TInt CMemSpyEngine::ProcessSuspendAndGetErrorLC( TProcessId aId )

   283     {

   284     return iImp->ProcessSuspendAndGetErrorLC( aId );

   285     }

   286 

   287 

   288 void CMemSpyEngine::ProcessSuspendLC( TProcessId aId )

   289     {

   290     iImp->ProcessSuspendLC( aId );

   291     }

   292 

   293 

   294 void CMemSpyEngine::ProcessResume()

   295     {

   296     iImp->ProcessResume();

   297     }

   298     

   299 

   300 TProcessId CMemSpyEngine::SuspendedProcessId() const

   301     {

   302     return iImp->SuspendedProcessId();

   303     }

   304 

   305 

   306