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 "MemSpyEngineHelperSysMemTrackerEntryBitmap.h"

    19 

    20 // System includes

    21 #include <e32base.h>

    22 #include <badesca.h>

    23 

    24 // Driver includes

    25 #include <memspy/driver/memspydriverclient.h>

    26 

    27 // User includes

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

    29 #include <memspy/engine/memspyengineutils.h>

    30 #include <memspy/engine/memspyengineoutputsink.h>

    31 #include <memspy/engine/memspyengineoutputlist.h>

    32 #include <memspy/engine/memspyenginehelperheap.h>

    33 #include <memspy/engine/memspyenginehelperfbserv.h>

    34 #include <memspy/engine/memspyengineobjectthread.h>

    35 #include <memspy/engine/memspyengineobjectprocess.h>

    36 #include <memspy/engine/memspyengineobjectcontainer.h>

    37 #include <memspy/engine/memspyenginehelperfilesystem.h>

    38 #include "MemSpyEngineHelperSysMemTrackerImp.h"

    39 #include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

    40 #include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>

    41 

    42 

    43 CMemSpyEngineHelperSysMemTrackerEntryBitmap::CMemSpyEngineHelperSysMemTrackerEntryBitmap( CMemSpyEngineHelperSysMemTrackerImp& aTracker )

    44 :   CMemSpyEngineHelperSysMemTrackerEntry( aTracker, EMemSpyEngineSysMemTrackerTypeOpenFile )

    45     {

    46     }

    47 

    48 

    49 CMemSpyEngineHelperSysMemTrackerEntryBitmap::~CMemSpyEngineHelperSysMemTrackerEntryBitmap()

    50     {

    51     delete iInfo;

    52     }

    53 

    54 

    55 void CMemSpyEngineHelperSysMemTrackerEntryBitmap::ConstructL( TInt aHandle )

    56     {

    57     iInfo = new(ELeave) TMemSpyEngineFBServBitmapInfo();

    58     CMemSpyEngineHelperFbServ::GetBitmapInfoL( aHandle, *iInfo );

    59     }

    60 

    61 

    62 CMemSpyEngineHelperSysMemTrackerEntryBitmap* CMemSpyEngineHelperSysMemTrackerEntryBitmap::NewLC( CMemSpyEngineHelperSysMemTrackerImp& aTracker, TInt aHandle )

    63     {

    64     CMemSpyEngineHelperSysMemTrackerEntryBitmap* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntryBitmap( aTracker );

    65     CleanupStack::PushL( self );

    66     self->ConstructL( aHandle );

    67     return self;

    68     }

    69 

    70 

    71 TUint64 CMemSpyEngineHelperSysMemTrackerEntryBitmap::Key() const

    72     {

    73     return TUint64( iInfo->iHandle );

    74     }

    75 

    76 

    77 void CMemSpyEngineHelperSysMemTrackerEntryBitmap::CreateChangeDescriptorL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    78     {

    79     CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap* changeDescriptor = CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::NewLC( Attributes(), *iInfo );

    80     aCycle.AddAndPopL( changeDescriptor );

    81     }

    82 

    83 

    84 void CMemSpyEngineHelperSysMemTrackerEntryBitmap::UpdateCycleStatistics( CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

    85     {

    86     // Doesn't participate in direct memory usage and indirect usage cannot really be measured.

    87     }

    88 

    89 

    90 

    91 

    92 

    93 

    94 

    95 

    96 

    97 

    98 

    99 

   100 

   101 

   102 CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap( TUint8 aAttribs )

   103 :   CMemSpyEngineHelperSysMemTrackerCycleChange( aAttribs )

   104     {

   105     }

   106 

   107 

   108 CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::~CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap()

   109     {

   110     delete iInfo;

   111     delete iBitmap;

   112     }

   113 

   114 

   115 void CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::ConstructL( const TMemSpyEngineFBServBitmapInfo& aInfo )

   116     {

   117     BaseConstructL();

   118 

   119     iInfo = new(ELeave) TMemSpyEngineFBServBitmapInfo();

   120     *iInfo = aInfo;

   121 

   122     iBitmap = new(ELeave) CFbsBitmap();

   123     const TInt err = iBitmap->Duplicate( aInfo.iHandle );

   124     if ( err != KErrNone )

   125         {

   126         RDebug::Printf( "CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::ConstructL() - aInfo.iHandle: 0x%08x, dupe Err: %d", aInfo.iHandle, err );

   127         delete iBitmap;

   128         iBitmap = NULL;

   129         }

   130     }

   131 

   132 

   133 CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap* CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::NewLC( TUint8 aAttribs, const TMemSpyEngineFBServBitmapInfo& aInfo )

   134     {

   135     CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap( aAttribs );

   136     CleanupStack::PushL( self );

   137     self->ConstructL( aInfo );

   138     return self;

   139     }

   140 

   141 

   142 TMemSpyEngineSysMemTrackerType CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::Type() const

   143     {

   144     return EMemSpyEngineSysMemTrackerTypeBitmap;

   145     }

   146    

   147 

   148 void CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::OutputHeaderL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   149     {

   150     _LIT( KHeaderLine, "Type, Handle, Dimensions [W x H], BPP, Disp. Mode, Color, Comp. Type, Size (Bytes), In Rom, Is Large, Is Mono, Is Compressed in Ram, Attribs");

   151     aSink.OutputLineL( KHeaderLine );

   152     }

   153  

   154 

   155 void CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::OutputContentL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   156     {

   157     _LIT( KFormat, "%S,0x%08x,[%05d x %05d],%d,%d,%d,%d,%d,%d,%d,%d,%d,%S" );

   158     //

   159     TMemSpySWMTTypeName type;;

   160     FormatType( type );

   161     //

   162     TBuf<20> attribs;

   163     FormatAttributes( attribs );

   164 

   165     // Now output line

   166     aSink.OutputLineFormattedL( KFormat,

   167                                 &type,

   168                                 iInfo->iHandle,

   169                                 iInfo->iSizeInPixels.iWidth,

   170                                 iInfo->iSizeInPixels.iHeight,

   171                                 iInfo->iBitsPerPixel,

   172                                 iInfo->iDisplayMode,

   173                                 iInfo->iColor,

   174                                 iInfo->iCompressionType,

   175                                 iInfo->iSizeInBytes,

   176                                 ( iInfo->iFlags & TMemSpyEngineFBServBitmapInfo::EFlagsIsRomBitmap ) ? 1 : 0,

   177                                 ( iInfo->iFlags & TMemSpyEngineFBServBitmapInfo::EFlagsIsMonochrome ) ? 1 : 0,

   178                                 ( iInfo->iFlags & TMemSpyEngineFBServBitmapInfo::EFlagsIsLarge ) ? 1 : 0,

   179                                 ( iInfo->iFlags & TMemSpyEngineFBServBitmapInfo::EFlagsIsCompressedInRam ) ? 1 : 0,

   180                                 &attribs

   181                                 );

   182     }

   183 

   184 

   185 void CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::OutputDataL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

   186     {

   187     TRACE( RDebug::Printf( "CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::OutputDataL() - iInfo.iHandle: 0x%08x, iBitmap: 0x%08x, size: %03d x %03d", iInfo->iHandle, iBitmap, iInfo->iSizeInPixels.iWidth, iInfo->iSizeInPixels.iHeight ) );

   188     if  ( iBitmap && iInfo->iSizeInPixels.iWidth > 0 && iInfo->iSizeInPixels.iHeight > 0 )

   189         {

   190         // Get folder

   191         HBufC* fileName = HBufC::NewLC( KMaxFileName );

   192         TPtr pFileName( fileName->Des() );

   193         aCycle.GetDataFolderL( aSink.Engine().FsSession(), pFileName );

   194         TRACE( RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::OutputDataL() - fileName1: [%S]"), fileName ) );

   195 

   196         // Get file name

   197         CMemSpyEngineFbServBitmap::GetExportableFileNameL( *iInfo, pFileName );

   198         TRACE( RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::OutputDataL() - fileName2: [%S]"), fileName ) );

   199 

   200         // Remove .bmp extension, since we're actually saving mbms

   201         const TParsePtrC parser( pFileName );

   202         if ( parser.ExtPresent() )

   203             {

   204             const TInt extLength = parser.Ext().Length();

   205             const TInt totalLength = pFileName.Length();

   206             pFileName.SetLength( totalLength - extLength );

   207             }

   208 

   209         // Add .MBM

   210         _LIT( KEpocBitmapExtension, ".mbm" );

   211         pFileName.Append( KEpocBitmapExtension );

   212 

   213         const TInt err = iBitmap->Save( pFileName );

   214         if  ( err != KErrNone )

   215             {

   216             RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerCycleChangeBitmap::OutputDataL() - err: %d, fileName: [%S]"), err, fileName ); 

   217             }

   218 

   219         // Clean up

   220         CleanupStack::PopAndDestroy( fileName );

   221         delete iBitmap;

   222         iBitmap = NULL;

   223         }

   224     }

   225 

   226 

   227