/*

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

// System includes

#include <e32debug.h>

// Driver includes

#include <memspy/driver/memspydriverclient.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyenginemidwife.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyenginehelperchunk.h>

#include <memspy/engine/memspyenginehelpercodesegment.h>

#include <memspy/engine/memspyenginehelperthread.h>

#include <memspy/engine/memspyengineprocessmemorytracker.h>

CMemSpyEngineHelperProcess::CMemSpyEngineHelperProcess( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineHelperProcess::~CMemSpyEngineHelperProcess()

    {

    delete iUndertaker;

    iEngine.Midwife().RemoveObserver( *this );

    //

    iMemoryTrackers.ResetAndDestroy();

    iMemoryTrackers.Close();

    iMemoryTrackerAutoStartProcessList.Close();

    }

void CMemSpyEngineHelperProcess::ConstructL()

    {

    iUndertaker = CMemSpyEngineUndertaker::NewL( iEngine.Driver() );

    iUndertaker->AddObserverL( *this );

    iEngine.Midwife().AddObserverL( *this );

    }

CMemSpyEngineHelperProcess* CMemSpyEngineHelperProcess::NewL( CMemSpyEngine& aEngine )

    {

    CMemSpyEngineHelperProcess* self = new(ELeave) CMemSpyEngineHelperProcess( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C void CMemSpyEngineHelperProcess::ImpersonateL( TUint32 aSID )

    {

    const TInt err = iEngine.Driver().Impersonate( aSID );

    User::LeaveIfError( err );

    }

EXPORT_C void CMemSpyEngineHelperProcess::OutputProcessInfoL( const CMemSpyProcess& aProcess )

    {

    OutputProcessInfoL( aProcess, EFalse );

    }

EXPORT_C void CMemSpyEngineHelperProcess::OutputProcessInfoDetailedL( const CMemSpyProcess& aProcess )

    {

    OutputProcessInfoL( aProcess, ETrue );

    }

void CMemSpyEngineHelperProcess::OutputProcessInfoL( const CMemSpyProcess& aProcess, TBool aDetailed )

    {

    const TUint pid = aProcess.Id();

    const TUint sid = aProcess.SID();

    RProcess process;

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

    CleanupClosePushL( process );

    const TPtrC procName( aProcess.Name() );

    TBuf<512> infoBuf;

    //

    _LIT(KProcessInfo, "SUMMARY FOR PROCESS \'%S\'");

    infoBuf.Format(KProcessInfo, &procName);

    iEngine.Sink().OutputSectionHeadingL( infoBuf, '=' );

    _LIT(KProcessId, "Id");

    iEngine.Sink().OutputItemAndValueL( KProcessId, pid );

    _LIT(KProcessPri, "Priority");

    TBuf<30> priority;

    const TProcessPriority procPriValue = process.Priority();

    CMemSpyProcess::AppendPriority( priority, procPriValue );

    iEngine.Sink().OutputItemAndValueL( KProcessPri, priority );

    _LIT(KProcessSID, "SID");

    iEngine.Sink().OutputItemAndValueL( KProcessSID, sid, ETrue );

    CleanupStack::PopAndDestroy( &process );

    if  ( aDetailed )

        {

        iEngine.ProcessSuspendLC( pid );

        iEngine.HelperChunk().OutputChunkInfoForProcessL( aProcess );

        iEngine.HelperCodeSegment().OutputCodeSegmentsL( pid, infoBuf, KNullDesC, '-', ETrue );

        CleanupStack::PopAndDestroy(); // ProcessSuspendLC

        }

    const TInt count = aProcess.Count();

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

        {

        const CMemSpyThread& thread = aProcess.At( i );

        iEngine.HelperThread().OutputThreadInfoL( thread, aDetailed );

        }

    }

EXPORT_C void CMemSpyEngineHelperProcess::SetMemoryTrackingAutoStartProcessListL( const RArray<TUid>& aProcessUids )

    {

    iEngine.Driver().ProcessInspectionAutoStartItemsReset();

    //

    const TInt count = aProcessUids.Count();

    iMemoryTrackerAutoStartProcessList.Reset();

    //

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

        {

        const TUid uid = aProcessUids[ i ];

#ifdef _DEBUG

        RDebug::Printf( "CMemSpyEngineHelperProcess::SetMemoryTrackingAutoStartProcessListL() - uid[%2d] => 0x%08x", i, uid.iUid );

#endif

        //

        User::LeaveIfError( iMemoryTrackerAutoStartProcessList.Append( uid ) );

        //

        const TInt driverErr = iEngine.Driver().ProcessInspectionAutoStartItemsAdd( uid.iUid );

#ifdef _DEBUG

        RDebug::Printf( "CMemSpyEngineHelperProcess::SetMemoryTrackingAutoStartProcessListL() - driver err: %d", driverErr );

#endif

        User::LeaveIfError( driverErr );

        }

    }

CMemSpyEngineProcessMemoryTracker* CMemSpyEngineHelperProcess::TrackerOrNull( const TProcessId& aId )

    {

    CMemSpyEngineProcessMemoryTracker* ret = NULL;

    //

    const TInt count = iMemoryTrackers.Count();

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

        {

        CMemSpyEngineProcessMemoryTracker* tracker = iMemoryTrackers[ i ];

        //

        if ( tracker->ProcessId() == aId )

            {

            ret = tracker;

            break;

            }

        }

    //

    return ret;

    }

CMemSpyEngineProcessMemoryTracker& CMemSpyEngineHelperProcess::TrackerL( const TProcessId& aId )

    {

    CMemSpyEngineProcessMemoryTracker* tracker = TrackerOrNull( aId );

    //

    if  ( tracker == NULL )

        {

        // Make a new entry

        tracker = CMemSpyEngineProcessMemoryTracker::NewLC( iEngine, aId );

        User::LeaveIfError( iMemoryTrackers.Append( tracker ) );

        CleanupStack::Pop( tracker );

        }

    //

    return *tracker;

    }

CMemSpyEngineProcessMemoryTracker& CMemSpyEngineHelperProcess::TrackerL( const CMemSpyProcess& aProcess )

    {

    return TrackerL( aProcess.Id() );

    }

void CMemSpyEngineHelperProcess::ThreadIsBornL( const TThreadId& aId, const RThread& aThread )

    {

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineHelperProcess::ThreadIsBornL() - aId: 0x%08x, aThread handle: 0x%08x", (TUint) aId, aThread.Handle() );

#else

    (void) aId;

    (void) aThread;

#endif

    }

void CMemSpyEngineHelperProcess::ProcessIsBornL( const TProcessId& aId, const RProcess& aProcess )

    {

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineHelperProcess::ProcessIsBornL() - aId: 0x%08x, aProcess handle: 0x%08x", (TUint) aId, aProcess.Handle() );

#else

    (void) aId;

    (void) aProcess;

#endif

    if ( aProcess.Handle() != KNullHandle )

        {

        const TBool isAutoStart = IsAutoStartupProcess( aProcess.SecureId() );

        //

        if ( isAutoStart )

            {

            CMemSpyEngineProcessMemoryTracker& tracker = TrackerL( aId );

            tracker.StartL();

            }

        }

    }

void CMemSpyEngineHelperProcess::ThreadIsDeadL( const TThreadId& aId, const RThread& aThread )

    {

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineHelperProcess::ThreadIsDeadL() - aId: 0x%08x, aThread handle: 0x%08x", (TUint) aId, aThread.Handle() );

#else

    (void) aId;

    (void) aThread;

#endif

    }

void CMemSpyEngineHelperProcess::ProcessIsDeadL( const TProcessId& aId, const RProcess& aProcess )

    {

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineHelperProcess::ProcessIsDeadL() - aId: 0x%08x, aProcess handle: 0x%08x", (TUint) aId, aProcess.Handle() );

#else

    (void) aProcess;

#endif

    CMemSpyEngineProcessMemoryTracker* tracker = TrackerOrNull( aId );

    if  ( tracker )

        {

#ifdef _DEBUG

        RDebug::Printf( "CMemSpyEngineHelperProcess::ProcessIsDeadL() - tracker for this process should take care of cleanup by itself..." );

#endif

        }

    }

TBool CMemSpyEngineHelperProcess::IsAutoStartupProcess( TUid aUid ) const

    {

    TBool match = EFalse;

    //

    const TInt count = iMemoryTrackerAutoStartProcessList.Count();

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

        {

        const TUid uid = iMemoryTrackerAutoStartProcessList[ i ];

        if ( uid == aUid )

            {

            match = ETrue;

            break;

            }

        }

    //

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineHelperProcess::IsAutoStartupProcess() - aUid: 0x%08x, ret: %d", aUid.iUid, match );

#endif

    return match;

    }