/*

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

// System includes

#include <e32debug.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>

// Constants

const TInt KMemSpyNumberOfChangesReceivedProcessNotYetOpen = -1;

const TInt KMemSpyNumberOfChangesReceivedProcessNowOpen = 0;

CMemSpyEngineProcessMemoryTracker::CMemSpyEngineProcessMemoryTracker( CMemSpyEngine& aEngine, const TProcessId& aProcessId )

:   CActive( EPriorityStandard ), iEngine( aEngine ), iProcessId( aProcessId ), iNumberOfChangesReceived( KMemSpyNumberOfChangesReceivedProcessNotYetOpen )

    {

    CActiveScheduler::Add( this );

    }

CMemSpyEngineProcessMemoryTracker::~CMemSpyEngineProcessMemoryTracker()

    {

    Cancel();

    // Don't close the process if we didn't successfully open it...

    if  ( iNumberOfChangesReceived != KMemSpyNumberOfChangesReceivedProcessNotYetOpen )

        {

        iEngine.Driver().ProcessInspectionClose( iProcessId );

        }

    iObservers.Close();

    delete iProcessName;

    }

void CMemSpyEngineProcessMemoryTracker::ConstructL()

    {

    // Cache name    

    RProcess process;

    User::LeaveIfError( iEngine.Driver().OpenProcess( iProcessId, process ) );

    CleanupClosePushL( process );

    iProcessName = process.FullName().AllocL();

    iSID = process.SecureId();

    CleanupStack::PopAndDestroy( &process );

    // Indicate that we've opened the process

    iNumberOfChangesReceived = KMemSpyNumberOfChangesReceivedProcessNowOpen;

    // Open driver session

    const TInt error = iEngine.Driver().ProcessInspectionOpen( iProcessId );

    User::LeaveIfError( error );

    // Pull out the first change which the driver always prepares for us when

    // we open an initial connection.

    TRequestStatus status = KRequestPending;

    iEngine.Driver().ProcessInspectionRequestChanges( iProcessId, status, iInfoCurrent );

    User::WaitForRequest( status );

    // And update our HWM value based upon this initial seed...

    UpdatePeaks( iInfoCurrent );

    UpdateHWMIncShared( iInfoCurrent );

    UpdateHWMExcShared( iInfoCurrent );

    }

CMemSpyEngineProcessMemoryTracker* CMemSpyEngineProcessMemoryTracker::NewLC( CMemSpyEngine& aEngine, const TProcessId& aProcessId )

    {

    CMemSpyEngineProcessMemoryTracker* self = new(ELeave) CMemSpyEngineProcessMemoryTracker( aEngine, aProcessId );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

EXPORT_C TBool CMemSpyEngineProcessMemoryTracker::AmTracking() const

    {

    return iAmTracking;

    }

EXPORT_C void CMemSpyEngineProcessMemoryTracker::StartL()

    {

    Cancel();

    iNumberOfChangesReceived = 0;

    //

    iEngine.Driver().ProcessInspectionRequestChanges( iProcessId, iStatus, iInfoCurrent );

    SetActive();

    iAmTracking = ETrue;

    //

    const TInt count = iObservers.Count();

    for( TInt i=0; i<count; i++ )

        {

        MMemSpyEngineProcessMemoryTrackerObserver* obs = iObservers[ i ];

        TRAP_IGNORE( obs->HandleMemoryTrackingStartedL() );

        }

    }

EXPORT_C void CMemSpyEngineProcessMemoryTracker::Stop()

    {

    Cancel();

    //

    iAmTracking = EFalse;

    //

    const TInt count = iObservers.Count();

    for( TInt i=0; i<count; i++ )

        {

        MMemSpyEngineProcessMemoryTrackerObserver* obs = iObservers[ i ];

        TRAP_IGNORE( obs->HandleMemoryTrackingStoppedL() );

        }

    }

EXPORT_C void CMemSpyEngineProcessMemoryTracker::AddObserverL( MMemSpyEngineProcessMemoryTrackerObserver& aObserver )

    {

    RemoveObserver( aObserver );

    User::LeaveIfError( iObservers.Append( &aObserver ) );

    }

EXPORT_C void CMemSpyEngineProcessMemoryTracker::RemoveObserver( MMemSpyEngineProcessMemoryTrackerObserver& aObserver )

    {

    TInt pos = iObservers.Find( &aObserver );

    while( pos >= 0 )

        {

        iObservers.Remove( pos );

        pos = iObservers.Find( &aObserver );

        }

    }

EXPORT_C void CMemSpyEngineProcessMemoryTracker::ResetHWML()

    {

    iInfoHWMIncShared.iMemoryStack = 0;

    iInfoHWMIncShared.iMemoryHeap = 0;

    iInfoHWMIncShared.iMemoryChunkLocal = 0;

    iInfoHWMIncShared.iMemoryChunkShared = 0;

    iInfoHWMIncShared.iMemoryGlobalData = 0;

    //

    iInfoHWMExcShared.iMemoryStack = 0;

    iInfoHWMExcShared.iMemoryHeap = 0;

    iInfoHWMExcShared.iMemoryChunkLocal = 0;

    iInfoHWMExcShared.iMemoryChunkShared = 0;

    iInfoHWMExcShared.iMemoryGlobalData = 0;

    //

    const TInt count = iObservers.Count();

    for( TInt i=0; i<count; i++ )

        {

        MMemSpyEngineProcessMemoryTrackerObserver* obs = iObservers[ i ];

        TRAP_IGNORE( obs->HandleMemoryChangedL( iProcessId, InfoCurrent(), InfoHWMIncShared(), InfoHWMExcShared() ) );

        }

    }

void CMemSpyEngineProcessMemoryTracker::RunL()

    {

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::RunL() - START" );

    ++iNumberOfChangesReceived;

    // Copy current results and request next event providing the driver didn't

    // indicate an error (e.g. KErrDied in the case of process termination)

    TMemSpyDriverProcessInspectionInfo info( iInfoCurrent );

    if  ( iStatus.Int() >= KErrNone )

        {

        iEngine.Driver().ProcessInspectionRequestChanges( iProcessId, iStatus, iInfoCurrent );

        SetActive();

        }

    else

        {

        //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::RunL() - iStatus: %d, not requesting further changes...", iStatus.Int() );

        }

    // Update stats

    UpdatePeaks( info );

    UpdateHWMIncShared( info );

    UpdateHWMExcShared( info );

    // Print out change to file/trace

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::RunL() - printing info..." );

    PrintInfoL( info );

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::RunL() - done printing info" );

    // Reset peak flags for next cycle

    iInfoPeaks.ResetPeakFlags();

    // Notify observers

    const TInt count = iObservers.Count();

    for( TInt i=0; i<count; i++ )

        {

        MMemSpyEngineProcessMemoryTrackerObserver* obs = iObservers[ i ];

        TRAP_IGNORE( obs->HandleMemoryChangedL( iProcessId, info, InfoHWMIncShared(), InfoHWMExcShared() ) );

        }

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::RunL() - END" );

    }

void CMemSpyEngineProcessMemoryTracker::DoCancel()

    {

    ////RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::DoCancel() - START - iStatus: %d", iStatus.Int() );

    iEngine.Driver().ProcessInspectionRequestChangesCancel( iProcessId );

    ////RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::DoCancel() - END - iStatus: %d", iStatus.Int() );

    }

void CMemSpyEngineProcessMemoryTracker::UpdatePeaks( const TMemSpyDriverProcessInspectionInfo& aLatestInfo )

    {

    if  ( aLatestInfo.iMemoryStack > iInfoPeaks.iMemoryStack )

        {

        iInfoPeaks.iPeakStack = ETrue;

        iInfoPeaks.iMemoryStack = aLatestInfo.iMemoryStack;

        }

    if  ( aLatestInfo.iMemoryHeap > iInfoPeaks.iMemoryHeap )

        {

        iInfoPeaks.iPeakHeap = ETrue;

        iInfoPeaks.iMemoryHeap = aLatestInfo.iMemoryHeap;

        }

    if  ( aLatestInfo.iMemoryChunkLocal > iInfoPeaks.iMemoryChunkLocal )

        {

        iInfoPeaks.iPeakChunkLocal = ETrue;

        iInfoPeaks.iMemoryChunkLocal = aLatestInfo.iMemoryChunkLocal;

        }

    if  ( aLatestInfo.iMemoryChunkShared > iInfoPeaks.iMemoryChunkShared )

        {

        iInfoPeaks.iPeakChunkShared = ETrue;

        iInfoPeaks.iMemoryChunkShared = aLatestInfo.iMemoryChunkShared;

        }

    if  ( aLatestInfo.iMemoryGlobalData > iInfoPeaks.iMemoryGlobalData )

        {

        iInfoPeaks.iPeakGlobalData = ETrue;

        iInfoPeaks.iMemoryGlobalData = aLatestInfo.iMemoryGlobalData;

        }

    }

void CMemSpyEngineProcessMemoryTracker::UpdateHWMIncShared( const TMemSpyDriverProcessInspectionInfo& aLatestInfo )

    {

    const TUint32 totalCurrent = aLatestInfo.TotalIncShared();

    const TUint32 totalHWM = iInfoHWMIncShared.TotalIncShared();

    //

    if  ( totalCurrent > totalHWM )

        {

        // Got new HWM

        iInfoHWMIncShared = aLatestInfo;

        }

    }

void CMemSpyEngineProcessMemoryTracker::UpdateHWMExcShared( const TMemSpyDriverProcessInspectionInfo& aLatestInfo )

    {

    const TUint32 totalCurrent = aLatestInfo.TotalExcShared();

    const TUint32 totalHWM = iInfoHWMExcShared.TotalExcShared();

    //

    if  ( totalCurrent > totalHWM )

        {

        // Got new HWM

        iInfoHWMExcShared = aLatestInfo;

        }

    }

void CMemSpyEngineProcessMemoryTracker::PrintInfoL( const TMemSpyDriverProcessInspectionInfo& aInfo )

    {

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - START" );

    TBuf<128> timeBuf;

    TTime time( aInfo.iTime );

    MemSpyEngineUtils::FormatTimeSimple( timeBuf, time );

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - got time..." );

    // Output changes

    const TBool noOverwrite = EFalse;

    const TBool noTimeStamp = EFalse;

    // Prepare prefix

    _LIT( KMemSpyProcessMemoryTrackerPrefix, "[Change %05d] " );

    TBuf<25> prefixBuf;

    prefixBuf.Format( KMemSpyProcessMemoryTrackerPrefix, iNumberOfChangesReceived );

    iEngine.Sink().OutputPrefixSetLC( prefixBuf );

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - set prefix" );

    // Resume (or create) a data stream

    _LIT( KMemSpyFolder, "Process Memory Tracking" );

    _LIT( KMemSpyContext, "Process [0x%08x]" );

    HBufC* context = HBufC::NewLC( KMaxFileName );

    TPtr pContext( context->Des() );

    pContext.Format( KMemSpyContext, (TUint) iSID );

    iEngine.Sink().DataStreamBeginL( pContext, KMemSpyFolder, KNullDesC, noOverwrite, noTimeStamp );

    CleanupStack::PopAndDestroy( context );

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - set context" );

    // Preapre peak characters

    const TText KItemPeaked     = '*';

    const TText KItemDidNotPeak = ' ';

    const TText peakStack       = ( iInfoPeaks.iPeakStack       ? KItemPeaked : KItemDidNotPeak );

    const TText peakHeap        = ( iInfoPeaks.iPeakHeap        ? KItemPeaked : KItemDidNotPeak );

    const TText peakChunkLocal  = ( iInfoPeaks.iPeakChunkLocal  ? KItemPeaked : KItemDidNotPeak );

    const TText peakChunkShared = ( iInfoPeaks.iPeakChunkShared ? KItemPeaked : KItemDidNotPeak );

    const TText peakGlobalData  = ( iInfoPeaks.iPeakGlobalData  ? KItemPeaked : KItemDidNotPeak );

    // Write data

    _LIT( KMemSpyMemChangeFormat, "%S - pID: 0x%04x, stack[%c]: %6d, heap[%c]: %10d, local[%c]: %10d, shared[%c]: %10d, globalD[%c]: %10d, totalC: [%10d/%10d], totalHWM: [%10d/%10d] %S" );

    HBufC* buf = HBufC::NewLC( 1024 );

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - formatting buffer..." );

    buf->Des().Format( KMemSpyMemChangeFormat, &timeBuf, (TUint) iProcessId, 

                                               peakStack, aInfo.iMemoryStack,

                                               peakHeap, aInfo.iMemoryHeap,

                                               peakChunkLocal, aInfo.iMemoryChunkLocal,

                                               peakChunkShared, aInfo.iMemoryChunkShared, 

                                               peakGlobalData, aInfo.iMemoryGlobalData, 

                                               aInfo.TotalIncShared(), aInfo.TotalExcShared(), 

                                               InfoHWMIncShared().TotalIncShared(), InfoHWMExcShared().TotalExcShared(), 

                                               iProcessName );

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - outputting - 1, sinkType: %d", iEngine.Sink().Type() );

    //RDebug::Print( _L("%S"), buf );

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - outputting - 2" );

    iEngine.Sink().OutputLineL( *buf, ETrue );

    CleanupStack::PopAndDestroy( buf );

    // End stream

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - ending stream" );

    iEngine.Sink().DataStreamEndL();

    // Remove prefix

    CleanupStack::PopAndDestroy();

    //RDebug::Printf( "CMemSpyEngineProcessMemoryTracker::PrintInfoL() - END" );

    }