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

// System includes
#include <e32debug.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/memspyenginehelpersysmemtrackercycle.h>
#include <memspy/engine/memspyenginehelpersysmemtrackerobserver.h>
#include "MemSpyEngineHelperSysMemTrackerEntryManager.h"

// Constants
const TInt KMemSpyDefaultTrackerTimerPeriod = 30; // Seconds


CMemSpyEngineHelperSysMemTrackerImp::CMemSpyEngineHelperSysMemTrackerImp( CMemSpyEngine& aEngine )
:   CTimer( EPriorityStandard ), iEngine( aEngine )
    {
    CActiveScheduler::Add( this );
    iConfig.iTimerPeriod = TTimeIntervalMicroSeconds32( KMemSpyDefaultTrackerTimerPeriod * 1000000 );
    }

    
CMemSpyEngineHelperSysMemTrackerImp::~CMemSpyEngineHelperSysMemTrackerImp()
    {
    Cancel();
    //
    delete iEntryManager;
    //
    iCompletedCycles.ResetAndDestroy();
    iCompletedCycles.Close();
    }


void CMemSpyEngineHelperSysMemTrackerImp::ConstructL()
    {
    CTimer::ConstructL();
    }


CMemSpyEngineHelperSysMemTrackerImp* CMemSpyEngineHelperSysMemTrackerImp::NewL( CMemSpyEngine& aEngine )
    {
    CMemSpyEngineHelperSysMemTrackerImp* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerImp( aEngine );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


void CMemSpyEngineHelperSysMemTrackerImp::StartL( const TMemSpyEngineHelperSysMemTrackerConfig& aConfig )
    {
    TRACE( RDebug::Printf("CMemSpyEngineHelperSysMemTrackerImp::StartL() - START - timer period: %d", Config().TimerPeriod().Int() ) );

    // Zap any old data
    Reset();

    // Cache client settings
    iConfig = aConfig;

    // Make new cycle
    PrepareInitialCycleL();

    // Start tracking via timer - future updates will by driven by RunL().
    After( Config().TimerPeriod() );
    TRACE( RDebug::Printf("CMemSpyEngineHelperSysMemTrackerImp::END() - START - timer period: %d", Config().TimerPeriod().Int() ) );
    }


void CMemSpyEngineHelperSysMemTrackerImp::StopL()
    {
    Cancel();
    }


void CMemSpyEngineHelperSysMemTrackerImp::SetObserver( MMemSpyEngineHelperSysMemTrackerObserver* aObserver )
    {
    iObserver = aObserver;
    }


void CMemSpyEngineHelperSysMemTrackerImp::RemoveObserver( MMemSpyEngineHelperSysMemTrackerObserver* aObserver )
    {
    if  ( iObserver == aObserver )
        {
        iObserver = NULL;
        }
    }


const RPointerArray< CMemSpyEngineHelperSysMemTrackerCycle >& CMemSpyEngineHelperSysMemTrackerImp::CompletedCycles() const
    {
    return iCompletedCycles;
    }


void CMemSpyEngineHelperSysMemTrackerImp::Reset()
    {
    Cancel();
    iCompletedCycles.ResetAndDestroy();
    //
    if  ( iObserver )
        {
        TRAP_IGNORE( iObserver->HandleCyclesResetL() );
        }
    }


void CMemSpyEngineHelperSysMemTrackerImp::CheckForChangesNowL()
    {
    const TInt count = iCompletedCycles.Count();
    TRACE( RDebug::Printf("CMemSpyEngineHelperSysMemTrackerImp::CheckForChangesNowL() - START - isActive: %d, cycleCount: %d", IsActive(), count ) );

    if  ( IsActive() )
        {
        Cancel();
        CheckForChangesL();
        After( Config().TimerPeriod() );
        }
    else
        {
        // Timer not running, so we're probably being poked by some external-to-memspy client that
        // wants to force an update.
        //
        // If we've never yet performed an initital cycle, then prep that. Otherwise, just proceed as normal
        // as if we had been called back via RunL().
        if  ( count == 0 )
            {
            PrepareInitialCycleL();
            }
        else
            {
            CheckForChangesL();
            }
        }

    TRACE( RDebug::Printf("CMemSpyEngineHelperSysMemTrackerImp::CheckForChangesNowL() - END - isActive: %d, cycleCount: %d", IsActive(), iCompletedCycles.Count() ) );
    }


TInt CMemSpyEngineHelperSysMemTrackerImp::MdcaCount() const
    {
    return iCompletedCycles.Count();
    }


TPtrC CMemSpyEngineHelperSysMemTrackerImp::MdcaPoint( TInt aIndex ) const
    {
    const CMemSpyEngineHelperSysMemTrackerCycle* cycleInfo = iCompletedCycles[ aIndex ];
    const TPtrC ret( cycleInfo->Caption() );
    return ret;
    }


void CMemSpyEngineHelperSysMemTrackerImp::NotifyObserverCycleStartedL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )
    {
    if  ( iObserver )
        {
        TRAP_IGNORE( iObserver->HandleCycleStartedL( aCycle ) );
        }
    }


void CMemSpyEngineHelperSysMemTrackerImp::NotifyObserverCycleFinishedL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )
    {
    if  ( iObserver )
        {
        TRAP_IGNORE( iObserver->HandleCycleFinishedL( aCycle ) );
        aCycle.DiscardChanges();
        }
    }


void CMemSpyEngineHelperSysMemTrackerImp::AddCycleAndPopL( CMemSpyEngineHelperSysMemTrackerCycle* aCycle )
    {
    iCompletedCycles.AppendL( aCycle );
    CleanupStack::Pop( aCycle );
    aCycle->FinalizeL();
    }


CMemSpyEngineHelperSysMemTrackerCycle* CMemSpyEngineHelperSysMemTrackerImp::LastCycleOrNull()
    {
    CMemSpyEngineHelperSysMemTrackerCycle* ret = NULL;
    //
    const TInt count = iCompletedCycles.Count();
    if  ( count )
        {
        ret = iCompletedCycles[ count - 1 ];
        }
    //
    return ret;
    }


void CMemSpyEngineHelperSysMemTrackerImp::PrepareInitialCycleL()
    {
    // Create seed items
    CMemSpyEngineHelperSysMemTrackerEntryManager* entryManager = CMemSpyEngineHelperSysMemTrackerEntryManager::NewL( *this );
    delete iEntryManager;
    iEntryManager = entryManager;

    // Everything changes on the first cycle.
    CMemSpyEngineHelperSysMemTrackerCycle* baselineCycle = CMemSpyEngineHelperSysMemTrackerCycle::NewLC( iConfig );
    NotifyObserverCycleStartedL( *baselineCycle );
    iEntryManager->EverythingHasChangedL( *baselineCycle );
    AddCycleAndPopL( baselineCycle );
    NotifyObserverCycleFinishedL( *baselineCycle );
    }


void CMemSpyEngineHelperSysMemTrackerImp::CheckForChangesL()
    {
    // Create info structure 
    CMemSpyEngineHelperSysMemTrackerCycle* cycle = CMemSpyEngineHelperSysMemTrackerCycle::NewLC( iConfig, LastCycleOrNull() );

    // Notify 
    NotifyObserverCycleStartedL( *cycle );

    // Find changes
    iEntryManager->IdentifyChangesL( *cycle );

    // Finalise the cycle and save it
    AddCycleAndPopL( cycle );

    // Notify
    NotifyObserverCycleFinishedL( *cycle );
    }


void CMemSpyEngineHelperSysMemTrackerImp::RunL()
    {
    CheckForChangesL();
    After( Config().TimerPeriod() );
    }


TInt CMemSpyEngineHelperSysMemTrackerImp::RunError( TInt aError )
    {
    RDebug::Printf( "CMemSpyEngineHelperSysMemTrackerImp::RunError() - aError: %d", aError );
    (void) aError;
    //
    Cancel();
    After( Config().TimerPeriod() );
    //
    return KErrNone;
    }