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

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



CMemSpyEngineUndertaker::CMemSpyEngineUndertaker( RMemSpyDriverClient& aDriver, TInt aPriority )
:	CActive( aPriority ), iDriver( aDriver )
	{
	CActiveScheduler::Add( this );
	}


CMemSpyEngineUndertaker::~CMemSpyEngineUndertaker()
	{
	Cancel();
    //
    if ( iEventMonitorHandle != KNullHandle )
        {
        iDriver.EventMonitorClose( iEventMonitorHandle );
        }
    //
    iObservers.Close();
	}


void CMemSpyEngineUndertaker::ConstructL()
	{
    const TInt error = iDriver.EventMonitorOpen( iEventMonitorHandle );
    User::LeaveIfError( error );
    //
	Request();
	}


CMemSpyEngineUndertaker* CMemSpyEngineUndertaker::NewL( RMemSpyDriverClient& aDriver, TInt aPriority )
	{
	CMemSpyEngineUndertaker* self = new(ELeave) CMemSpyEngineUndertaker( aDriver, aPriority );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}


void CMemSpyEngineUndertaker::AddObserverL( MMemSpyEngineUndertakerObserver& aObserver )
    {
    RemoveObserver( aObserver );
    iObservers.AppendL( &aObserver );
    }


void CMemSpyEngineUndertaker::RemoveObserver( MMemSpyEngineUndertakerObserver& aObserver )
    {
    const TInt count = iObservers.Count();
    for( TInt i=count-1; i>=0; i-- )
        {
        MMemSpyEngineUndertakerObserver* obs = iObservers[ i ];
        if ( obs == &aObserver )
            {
            iObservers.Remove( i );
            }
        }
    }


void CMemSpyEngineUndertaker::RunL()
	{
    const TUint notifiedId = iId;
    const TInt typeAsInt = iStatus.Int();
    User::LeaveIfError( typeAsInt );
	Request();
    //
    const TMemSpyDriverEventType type = static_cast< TMemSpyDriverEventType >( typeAsInt );
    switch( type )
        {
    case EMemSpyDriverEventTypeProcessRemove:
        {
        const TProcessId id( notifiedId );
        NotifyProcessDeadL( id );
        break;
        }
    case EMemSpyDriverEventTypeThreadKill:
        {
        const TThreadId id( notifiedId );
        NotifyThreadDeadL( id );
        break;
        }
    default:
        // Process removal not handled as not relevant
        break;
        }
	}


void CMemSpyEngineUndertaker::DoCancel()
	{
	iDriver.EventMonitorNotifyCancel( iEventMonitorHandle );
	}


void CMemSpyEngineUndertaker::Request()
	{
    Cancel();
    iDriver.EventMonitorNotify( iEventMonitorHandle, iStatus, iId );
	SetActive();
	}


void CMemSpyEngineUndertaker::NotifyProcessDeadL( const TProcessId& aId )
    {
    // NB: opening may fail - client's must tolerate this
    RProcess process;
    iDriver.OpenProcess( aId, process );
    CleanupClosePushL( process );
    //
    const TInt count = iObservers.Count();
    for( TInt i=0; i<count; i++ )
        {
        MMemSpyEngineUndertakerObserver* obs = iObservers[ i ];
        TRAP_IGNORE( obs->ProcessIsDeadL( aId, process ) );
        }
    //
    CleanupStack::PopAndDestroy( &process );
    }


void CMemSpyEngineUndertaker::NotifyThreadDeadL( const TThreadId& aId )
    {
    // NB: opening may fail - client's must tolerate this
    RThread thread;
    iDriver.OpenThread( aId, thread );
    CleanupClosePushL( thread );
    //
    const TInt count = iObservers.Count();
    for( TInt i=0; i<count; i++ )
        {
        MMemSpyEngineUndertakerObserver* obs = iObservers[ i ];
        TRAP_IGNORE( obs->ThreadIsDeadL( aId, thread ) );
        }
    //
    CleanupStack::PopAndDestroy( &thread );
    }