/*
* 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 "MemSpyEngineHelperSysMemTrackerEntrySystemMemory.h"

// System includes
#include <e32base.h>
#include <badesca.h>
#include <hal.h>
#include <hal_data.h>

// Driver includes
#include <memspy/driver/memspydriverclient.h>

// User includes
#include <memspy/engine/memspyengine.h>
#include <memspy/engine/memspyengineutils.h>
#include <memspy/engine/memspyengineoutputsink.h>
#include <memspy/engine/memspyengineoutputlist.h>
#include <memspy/engine/memspyenginehelperheap.h>
#include <memspy/engine/memspyenginehelperchunk.h>
#include <memspy/engine/memspyengineobjectthread.h>
#include <memspy/engine/memspyengineobjectprocess.h>
#include <memspy/engine/memspyengineobjectcontainer.h>
#include <memspy/engine/memspyenginehelpercodesegment.h>
#include "MemSpyEngineHelperSysMemTrackerImp.h"
#include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>
#include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>





CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::CMemSpyEngineHelperSysMemTrackerEntrySystemMemory( CMemSpyEngineHelperSysMemTrackerImp& aTracker, TSystemMemoryType aType )
:   CMemSpyEngineHelperSysMemTrackerEntry( aTracker, EMemSpyEngineSysMemTrackerTypeSystemMemory ), iType( aType )
    {
    }


CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::~CMemSpyEngineHelperSysMemTrackerEntrySystemMemory()
    {
    }


void CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::ConstructL()
    {
    if ( iType == ETypeFree )
        {
        HAL::Get( HALData::EMemoryRAMFree, iCurrent );
        }
    else if ( iType == ETypeTotal )
        {
        HAL::Get( HALData::EMemoryRAM, iCurrent );
        }
    //
    iLast = iCurrent;
    }


CMemSpyEngineHelperSysMemTrackerEntrySystemMemory* CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::NewLC( CMemSpyEngineHelperSysMemTrackerImp& aTracker, TSystemMemoryType aType )
    {
    CMemSpyEngineHelperSysMemTrackerEntrySystemMemory* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntrySystemMemory( aTracker, aType );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


TUint64 CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::Key() const
    {
    const TUint32 val = ( Type() << 28 ); 
    TUint64 ret = val;
    ret <<= 32;
    ret += static_cast<TInt>( iType );
    return ret;
    }


void CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::UpdateFromL( const CMemSpyEngineHelperSysMemTrackerEntry& aEntry )
    {
    const CMemSpyEngineHelperSysMemTrackerEntrySystemMemory& entry = static_cast< const CMemSpyEngineHelperSysMemTrackerEntrySystemMemory& >( aEntry );
    
    // Update state
    iLast = iCurrent;
    iCurrent = entry.iCurrent;
    }


void CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::CreateChangeDescriptorL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )
    {
    CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory* changeDescriptor = CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::NewLC( Attributes(), iType, iCurrent, iLast );
    aCycle.AddAndPopL( changeDescriptor );
    }


TBool CMemSpyEngineHelperSysMemTrackerEntrySystemMemory::HasChangedL( const TMemSpyEngineHelperSysMemTrackerConfig& /*aConfig*/ ) const
    {
    const TBool hasChanged = ( iCurrent != iLast );
    return hasChanged;
    }































CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory( TUint8 aAttribs, TSystemMemoryType aType, TInt aCurrent, TInt aLast )
:   CMemSpyEngineHelperSysMemTrackerCycleChange( aAttribs ), iType( aType ), iCurrent( aCurrent ), iLast( aLast )
    {
    }


CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::~CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory()
    {
    }


void CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::ConstructL()
    {
    BaseConstructL();
    }


CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory* CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::NewLC( TUint8 aAttribs, TSystemMemoryType aType, TInt aCurrent, TInt aLast )
    {
    CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory( aAttribs, aType, aCurrent, aLast );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


TMemSpyEngineSysMemTrackerType CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::Type() const
    {
    return EMemSpyEngineSysMemTrackerTypeSystemMemory;
    }
   

void CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::OutputHeaderL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )
    {
    _LIT( KHeaderSystemMemory, "Type, Name, Size, Attribs");
    aSink.OutputLineL( KHeaderSystemMemory );
    }
 

void CMemSpyEngineHelperSysMemTrackerCycleChangeSystemMemory::OutputContentL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )
    {
    _LIT( KFormat, "%S,%S,%d,%S" );
    //
    TMemSpySWMTTypeName category;
    FormatType( category );
    //
    TBuf<20> attribs;
    FormatAttributes( attribs );
    //
    _LIT( KTypeSystemMemoryFree, "Free" );
    _LIT( KTypeSystemMemoryTotal, "Total" );
    TBuf<20> type( KTypeSystemMemoryFree );
    if ( iType == ETypeTotal )
        {
        type = KTypeSystemMemoryTotal;
        }
    //
    aSink.OutputLineFormattedL( KFormat, &category, &type, iCurrent, &attribs );
    }