/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

// System includes

#include <e32debug.h>

#include <hal.h>

#include <hal_data.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyenginehelperchunk.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyengineoutputlist.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyenginehelpersysmemtrackercyclechange.h>

// Literal constants

_LIT( KMemSpySWMTDataFolderSpecification, "Data" );

_LIT( KMemSpySWMTFolderSpecification, "System Wide MT\\Cycle %04d" );

CMemSpyEngineHelperSysMemTrackerCycle::CMemSpyEngineHelperSysMemTrackerCycle( const TMemSpyEngineHelperSysMemTrackerConfig& aConfig, const CMemSpyEngineHelperSysMemTrackerCycle* aPreviousCycle )

:   iConfig( aConfig ), iPreviousCycle( aPreviousCycle ), iCycleNumber( 1 )

    {

    iTime.HomeTime();

    if  ( aPreviousCycle )

        {

        iCycleNumber = aPreviousCycle->CycleNumber() + 1;

        }

    }

CMemSpyEngineHelperSysMemTrackerCycle::~CMemSpyEngineHelperSysMemTrackerCycle()

    {

    delete iFixedItems;

    delete iCaption;

    delete iTimeFormatted;

    //

    DiscardChanges();

    iChangeDescriptors.Close();

    }

void CMemSpyEngineHelperSysMemTrackerCycle::ConstructL()

    {

    iFixedItems = CMemSpyEngineOutputList::NewL();

    // Get time stamp

    TBuf<128> timeBuf;

    MemSpyEngineUtils::FormatTimeSimple( timeBuf, iTime );

    iTimeFormatted = timeBuf.AllocL();

    // Get free ram

    TInt freeRam = KErrNotFound;

    User::LeaveIfError( HAL::Get( HALData::EMemoryRAMFree, freeRam ) );

    iMemoryFree = freeRam;

    }

CMemSpyEngineHelperSysMemTrackerCycle* CMemSpyEngineHelperSysMemTrackerCycle::NewLC( const TMemSpyEngineHelperSysMemTrackerConfig& aConfig, const CMemSpyEngineHelperSysMemTrackerCycle* aPreviousCycle )

    {

    CMemSpyEngineHelperSysMemTrackerCycle* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycle( aConfig, aPreviousCycle );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

EXPORT_C TInt CMemSpyEngineHelperSysMemTrackerCycle::CycleNumber() const

    {

    return iCycleNumber;

    }

EXPORT_C const TTime& CMemSpyEngineHelperSysMemTrackerCycle::Time() const

    {

    return iTime;

    }

EXPORT_C const TDesC& CMemSpyEngineHelperSysMemTrackerCycle::TimeFormatted() const

    {

    return *iTimeFormatted;

    }

EXPORT_C const TDesC& CMemSpyEngineHelperSysMemTrackerCycle::Caption() const

    {

    return *iCaption;

    }

EXPORT_C const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryFree() const

    {

    return iMemoryFree;

    }

EXPORT_C TInt64 CMemSpyEngineHelperSysMemTrackerCycle::MemoryFreePreviousCycle() const

    {

    TInt64 ret = MemoryFree();

    //

    if  ( iPreviousCycle )

        {

        ret = iPreviousCycle->MemoryFree();

        }

    //

    return ret;

    }

EXPORT_C TInt64 CMemSpyEngineHelperSysMemTrackerCycle::MemoryDelta() const

    {

    const TInt64 ret = ( iMemoryFree - iMemoryUsed );

    return ret;

    }

EXPORT_C TInt CMemSpyEngineHelperSysMemTrackerCycle::ChangeCount() const

    {

    return iChangeCount;

    }

EXPORT_C TInt CMemSpyEngineHelperSysMemTrackerCycle::MdcaCount() const

    {

    return iFixedItems->Count();

    }

EXPORT_C TPtrC CMemSpyEngineHelperSysMemTrackerCycle::MdcaPoint( TInt aIndex ) const

    {

    return iFixedItems->MdcaPoint( aIndex );

    }

void CMemSpyEngineHelperSysMemTrackerCycle::FinalizeL()

    {

    _LIT( KChange, "change" );

    _LIT( KChanges, "changes" );

    // Save change count

    iChangeCount = iChangeDescriptors.Count();

    // First make the main caption

    TMemSpySizeText sizeText;

    TMemSpySizeText deltaText;

    TPtrC pChangeText( KChange );

    // Get free RAM formatted as a descriptor

    sizeText = MemSpyEngineUtils::FormatSizeTextPrecise( MemoryFree() );

    // Get delta formatted as a descriptor

    const TInt64 delta( MemoryDelta() );

    deltaText = MemSpyEngineUtils::FormatSizeTextPrecise( delta );

    // Get number of changed threads as a descriptor

    if  ( ChangeCount() == 0 || ChangeCount() > 1 )

        {

        pChangeText.Set( KChanges );

        }

    // Now make the caption

    if  ( MemoryDelta() != 0 )

        {

        TBuf<300> buf;

        _LIT( KMainCaption1, "\t[%03d] F: %S\t\tD: %S, %d %S" );

        buf.Format( KMainCaption1, CycleNumber(), &sizeText, &deltaText, ChangeCount(), &pChangeText );

        HBufC* caption = buf.AllocL();

        delete iCaption;

        iCaption = caption;

        }

    else

        {

        TBuf<300> buf;

        _LIT( KMainCaption2, "\t[%03d] F: %S\t\tNo Delta, %d %S" );

        buf.Format( KMainCaption2, CycleNumber(), &sizeText, ChangeCount(), &pChangeText );

        HBufC* caption = buf.AllocL();

        delete iCaption;

        iCaption = caption;

        }

    // Now make the child entries

    if  ( CycleNumber() > 0 )

        {

        _LIT(KItem1a, "Cycle");

        iFixedItems->AddItemL( KItem1a, CycleNumber() );

        }

    else

        {

        _LIT(KItem1a, "Baseline");

        iFixedItems->AddItemL( KItem1a );

        }

    //

    _LIT(KItem1c, "Time");

    iFixedItems->AddItemL( KItem1c, iTimeFormatted );

    //

    _LIT(KItem2, "Memory Free");

    iFixedItems->AddItemL( KItem2, sizeText );

    //

    if  ( CycleNumber() > 0 )

        {

        _LIT(KItem2b, "Memory Change (vs. Last Cycle)");

        sizeText = MemSpyEngineUtils::FormatSizeTextPrecise( MemoryFree() - MemoryFreePreviousCycle() );

        iFixedItems->AddItemL( KItem2b, sizeText );

        //

        _LIT(KItem3, "Number of Changes");

        iFixedItems->AddItemL( KItem3, ChangeCount() );

        }

    }

void CMemSpyEngineHelperSysMemTrackerCycle::DiscardChanges()

    {

    iChangeDescriptors.ResetAndDestroy();

    }

CMemSpyEngineHelperSysMemTrackerCycleChange& CMemSpyEngineHelperSysMemTrackerCycle::ChangeAt( TInt aIndex )

    {

    return *iChangeDescriptors[ aIndex ];

    }

void CMemSpyEngineHelperSysMemTrackerCycle::GetDataFolderL( RFs& aFsSession, TDes& aFolder )

    {

    TFileName fileName;

    fileName.Format( KMemSpySWMTFolderSpecification, CycleNumber() );

    CMemSpyEngineSinkMetaData* metaData = CMemSpyEngineSinkMetaData::NewL( KNullDesC, fileName, KNullDesC, ETrue, EFalse, Time() );

    CleanupStack::PushL( metaData );

    MemSpyEngineUtils::GetFolderL( aFsSession, aFolder, *metaData );

    CleanupStack::PopAndDestroy( metaData );

    // This get's us something like:

    //

    //    E:\MemSpy\System Wide MT\Data - Cycle 001\Log.txt

    //

    // Now we must strip off the filename and return just the folder specification

    const TParsePtrC parser( aFolder );

    if  ( parser.NamePresent() && parser.ExtPresent() )

        {

        const TPtrC nameAndExt( parser.NameAndExt() );

        aFolder.SetLength( aFolder.Length() - nameAndExt.Length() );

        }

    // Add "Data" on to the end so that we put all data in a clearly marked subdir)

    aFolder.Append( KMemSpySWMTDataFolderSpecification );

    TRACE( RDebug::Print(_L("CMemSpyEngineHelperSysMemTrackerCycle::GetDataFolderL() - folder1: %S"), &aFolder ) );

    // Now we should return something like:

    //

    //    E:\MemSpy\System Wide MT\Data - Cycle 001

    TRACE( RDebug::Print(_L("CMemSpyEngineHelperSysMemTrackerCycle::GetDataFolderL() - folder2: %S"), &aFolder ) );

    const TInt err = aFsSession.MkDirAll( aFolder );

    if  ( !(err == KErrNone || err == KErrAlreadyExists ) )

        {

        User::LeaveIfError( err );

        }

    }

void CMemSpyEngineHelperSysMemTrackerCycle::DataStreamBeginL( CMemSpyEngineOutputSink& aSink, const TDesC& aContext )

    {

    // First make the folder...

    HBufC* folder = HBufC::NewLC( KMemSpySWMTFolderSpecification().Length() + 10 );

    TPtr pFolder( folder->Des() );

    pFolder.Format( KMemSpySWMTFolderSpecification, CycleNumber() );

    // Now start the data stream

    aSink.DataStreamBeginL( aContext, pFolder, KMemSpyLogDefaultExtension, ETrue, EFalse );

    CleanupStack::PopAndDestroy( folder );

    }

void CMemSpyEngineHelperSysMemTrackerCycle::DataStreamEndL( CMemSpyEngineOutputSink& aSink )

    {

	aSink.DataStreamEndL();

    }

void CMemSpyEngineHelperSysMemTrackerCycle::AddAndPopL( CMemSpyEngineHelperSysMemTrackerCycleChange* aInfo )

    {

    iChangeDescriptors.AppendL( aInfo );

    CleanupStack::Pop( aInfo );

    }

const TMemSpyEngineHelperSysMemTrackerConfig& CMemSpyEngineHelperSysMemTrackerCycle::Config() const

    {

    return iConfig; 

    }

void CMemSpyEngineHelperSysMemTrackerCycle::AddToMemoryUsed( TInt aValue )

    {

    iMemoryUsed += aValue;

    }

void CMemSpyEngineHelperSysMemTrackerCycle::AddToMemoryHeapAllocs( TInt aValue )

    {

    iMemoryHeapAllocs += aValue;

    }

void CMemSpyEngineHelperSysMemTrackerCycle::AddToMemoryHeapFrees( TInt aValue )

    {

    iMemoryHeapFrees += aValue;

    }

void CMemSpyEngineHelperSysMemTrackerCycle::AddToCellCountFree( TInt aValue )

    {

    iCellCountsFrees += aValue;

    }

void CMemSpyEngineHelperSysMemTrackerCycle::AddToCellCountAlloc( TInt aValue )

    {

    iCellCountsAllocs += aValue;

    }

const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryUsed() const

    {

    return iMemoryUsed;

    }

const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapAllocs() const

    {

    return iMemoryHeapAllocs;

    }

const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapFrees() const

    {

    return iMemoryHeapFrees;

    }

const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapCellCountAlloc() const

    {

    return iCellCountsAllocs;

    }

const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapCellCountFree() const

    {

    return iCellCountsFrees;

    }