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 

    71 EXPORT_C RFs& CMemSpyEngine::FsSession()

    72     {

    73     return iImp->FsSession();

    74     }

    75 

    76 

    77 EXPORT_C CMemSpyEngineObjectContainer& CMemSpyEngine::Container()

    78     {

    79     return iImp->Container();

    80     }

    81 

    82 

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

    84     {

    85     return iImp->Container();

    86     }

    87 

    88 

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

    90     {

    91     iImp->SetObserver( aObserver );

    92     }

    93 

    94 

    95 void CMemSpyEngine::NotifyContainerChangeL()

    96     {

    97     iImp->NotifyContainerChangeL();

    98     }

    99 

   100 

   101 void CMemSpyEngine::NotifyClientServerOperationRequestL( TInt aType )

   102     {

   103     iImp->NotifyClientServerOperationRequestL( aType );

   104     }

   105 

   106 

   107 EXPORT_C CMemSpyEngineOutputSink& CMemSpyEngine::Sink()

   108     {

   109     return iImp->Sink();

   110     }

   111 

   112 

   113 EXPORT_C TMemSpySinkType CMemSpyEngine::SinkType()

   114     {

   115     return iImp->SinkType();

   116     }

   117 

   118 

   119 EXPORT_C void CMemSpyEngine::InstallSinkL( TMemSpySinkType aType )

   120     {

   121     iImp->InstallSinkL( aType );

   122     }

   123 

   124 

   125 EXPORT_C void CMemSpyEngine::ListOpenFilesL()

   126     {

   127     iImp->ListOpenFilesL();

   128     }

   129 

   130 

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

   132     {

   133     iImp->GetVersion( aVersion );

   134     }

   135 

   136 

   137 EXPORT_C TBool CMemSpyEngine::IsHelperWindowServerSupported()

   138     {

   139     return iImp->IsHelperWindowServerSupported();

   140     }

   141 

   142 

   143 CMemSpyEngineMidwife& CMemSpyEngine::Midwife()

   144     {

   145     return iImp->Midwife();

   146     }

   147 

   148 

   149 CMemSpyEngineUndertaker& CMemSpyEngine::Undertaker()

   150     {

   151     return iImp->Undertaker();

   152     }

   153 

   154 

   155 CMemSpyEngineChunkWatcher& CMemSpyEngine::ChunkWatcher()

   156     {

   157     return iImp->ChunkWatcher();

   158     }

   159 

   160 

   161 EXPORT_C CMemSpyEngineHelperHeap& CMemSpyEngine::HelperHeap()

   162     {

   163     return iImp->HelperHeap();

   164     }

   165 

   166 

   167 EXPORT_C CMemSpyEngineHelperStack& CMemSpyEngine::HelperStack()

   168     {

   169     return iImp->HelperStack();

   170     }

   171 

   172 

   173 EXPORT_C CMemSpyEngineHelperCodeSegment& CMemSpyEngine::HelperCodeSegment()

   174     {

   175     return iImp->HelperCodeSegment();

   176     }

   177 

   178 

   179 EXPORT_C CMemSpyEngineHelperChunk& CMemSpyEngine::HelperChunk()

   180     {

   181     return iImp->HelperChunk();

   182     }

   183 

   184 

   185 EXPORT_C CMemSpyEngineHelperThread& CMemSpyEngine::HelperThread()

   186     {

   187     return iImp->HelperThread();

   188     }

   189 

   190 

   191 EXPORT_C CMemSpyEngineHelperProcess& CMemSpyEngine::HelperProcess()

   192     {

   193     return iImp->HelperProcess();

   194     }

   195 

   196 

   197 EXPORT_C CMemSpyEngineHelperServer& CMemSpyEngine::HelperServer()

   198     {

   199     return iImp->HelperServer();

   200     }

   201 

   202 

   203 EXPORT_C CMemSpyEngineHelperActiveObject& CMemSpyEngine::HelperActiveObject()

   204     {

   205     return iImp->HelperActiveObject();

   206     }

   207 

   208 

   209 EXPORT_C CMemSpyEngineHelperKernelContainers& CMemSpyEngine::HelperKernelContainers()

   210     {

   211     return iImp->HelperKernelContainers();

   212     }

   213 

   214 

   215 EXPORT_C CMemSpyEngineHelperFileSystem& CMemSpyEngine::HelperFileSystem()

   216     {

   217     return iImp->HelperFileSystem();

   218     }

   219 

   220 

   221 EXPORT_C CMemSpyEngineHelperECom& CMemSpyEngine::HelperECom()

   222     {

   223     return iImp->HelperECom();

   224     }

   225 

   226 

   227 EXPORT_C CMemSpyEngineHelperSysMemTracker& CMemSpyEngine::HelperSysMemTracker()

   228     {

   229     return iImp->HelperSysMemTracker();

   230     }

   231 

   232 

   233 EXPORT_C CMemSpyEngineHelperFbServ& CMemSpyEngine::HelperFbServ()

   234     {

   235     return iImp->HelperFbServ();

   236     }

   237 

   238 

   239 EXPORT_C CMemSpyEngineHelperROM& CMemSpyEngine::HelperROM()

   240     {

   241     return iImp->HelperROM();

   242     }

   243 

   244 

   245 EXPORT_C CMemSpyEngineHelperRAM& CMemSpyEngine::HelperRAM()

   246     {

   247     return iImp->HelperRAM();

   248     }

   249 

   250 

   251 EXPORT_C MMemSpyEngineHelperWindowServer& CMemSpyEngine::HelperWindowServer()

   252     {

   253     return iImp->HelperWindowServer();

   254     }

   255 

   256 

   257 EXPORT_C CMemSpyEngineHelperCondVar& CMemSpyEngine::HelperCondVar()

   258     {

   259     return iImp->HelperCondVar();

   260     }

   261 

   262 

   263 RMemSpyDriverClient& CMemSpyEngine::Driver()

   264     {

   265     return iImp->Driver();

   266     }

   267 

   268 

   269 TInt CMemSpyEngine::ProcessSuspendAndGetErrorLC( TProcessId aId )

   270     {

   271     return iImp->ProcessSuspendAndGetErrorLC( aId );

   272     }

   273 

   274 

   275 void CMemSpyEngine::ProcessSuspendLC( TProcessId aId )

   276     {

   277     iImp->ProcessSuspendLC( aId );

   278     }

   279 

   280 

   281 void CMemSpyEngine::ProcessResume()

   282     {

   283     iImp->ProcessResume();

   284     }

   285     

   286 

   287 TProcessId CMemSpyEngine::SuspendedProcessId() const

   288     {

   289     return iImp->SuspendedProcessId();

   290     }

   291 

   292 

   293