/*

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

// System includes

#include <u32hal.h>

#include <e32rom.h>

#include <memspy/driver/memspydriverobjectsshared.h>

// Shared includes

#include "MemSpyDriverOpCodes.h"

#include "MemSpyDriverObjectsInternal.h"

// User includes

#include "MemSpyDriverUtils.h"

#include "MemSpyDriverDevice.h"

#include "MemSpyDriverInspectedProcess.h"

#include "MemSpyDriverInspectedProcessManager.h"

DMemSpyDriverLogChanProcessInspection::DMemSpyDriverLogChanProcessInspection( DMemSpyDriverDevice& aDevice, DThread& aThread )

:   DMemSpyDriverLogChanBase( aDevice, aThread )

    {

    TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::DMemSpyDriverLogChanProcessInspection() - this: 0x%08x", this ));

    }

DMemSpyDriverLogChanProcessInspection::~DMemSpyDriverLogChanProcessInspection()

	{

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::~DMemSpyDriverLogChanProcessInspection() - START - this: 0x%08x", this ));

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::~DMemSpyDriverLogChanProcessInspection() - END - this: 0x%08x", this ));

	}

TInt DMemSpyDriverLogChanProcessInspection::Request( TInt aFunction, TAny* a1, TAny* a2 )

	{

	TInt r = DMemSpyDriverLogChanBase::Request( aFunction, a1, a2 );

    if  ( r == KErrNone )

        {

	    switch( aFunction )

		    {

        case EMemSpyDriverOpCodeProcessInspectOpen:

            r = ProcessInspectionOpen( (TUint) a1 );

            break;

        case EMemSpyDriverOpCodeProcessInspectClose:

            r = ProcessInspectionClose( (TUint) a1 );

            break;

        case EMemSpyDriverOpCodeProcessInspectRequestChanges:

            r = ProcessInspectionRequestChanges( (TRequestStatus*) a1, (TMemSpyDriverProcessInspectionInfo*) a2 );

            break;

        case EMemSpyDriverOpCodeProcessInspectRequestChangesCancel:

            r = ProcessInspectionRequestChangesCancel( (TUint) a1 );

            break;

        case EMemSpyDriverOpCodeProcessInspectAutoStartListReset:

            r = ProcessInspectionAutoStartItemsClear();

            break;

        case EMemSpyDriverOpCodeProcessInspectAutoStartListAdd:

            r = ProcessInspectionAutoStartItemsAdd( (TUint) a1 );

            break;

        default:

            r = KErrNotSupported;

		    break;

		    }

        }

    //

    return r;

	}

TBool DMemSpyDriverLogChanProcessInspection::IsHandler( TInt aFunction ) const

    {

    return ( aFunction > EMemSpyDriverOpCodeProcessInspectBase && aFunction < EMemSpyDriverOpCodeProcessInspectEnd );

    }

TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionOpen( TUint aPid )

    {

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionOpen() - START"));

    NKern::ThreadEnterCS();

    TInt error = OpenTempObject( aPid, EProcess );

    if  ( error == KErrNone )

    	{

        DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();

        error = pidManager.ProcessOpen( (DProcess*) TempObject() );

	    CloseTempObject();

    	}

    //

    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionOpen() - END - error: %d", error ));

    return error;

    }

TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionClose( TUint aPid )

    {

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionClose() - START"));

    NKern::ThreadEnterCS();

    TInt error = OpenTempObject( aPid, EProcess );

    if  ( error == KErrNone )

    	{

        DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();

        error = pidManager.ProcessClose( (DProcess*) TempObject() );

	    CloseTempObject();

    	}

    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionClose() - END - error: %d", error ));

    return error;

    }

TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChanges( TRequestStatus* aStatus, TMemSpyDriverProcessInspectionInfo* aInfo )

    {

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChanges() - START"));

    NKern::ThreadEnterCS();

    // Read client info

    TMemSpyDriverProcessInspectionInfo info;

	TInt error = Kern::ThreadRawRead( &ClientThread(), aInfo, &info, sizeof(TMemSpyDriverProcessInspectionInfo) );

    //

    if  ( error == KErrNone )

        {

        DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();

        DMemSpyInspectedProcess* pid = pidManager.InspectedProcessByProcessId( info.iProcessId );

        //

        if ( pid != NULL )

            {

            error = pid->NotifyOnChange( &ClientThread(), aStatus, aInfo );

            }

        else

            {

            error = KErrNotFound;

            }

        }

    // NB: Let client take care of completing request in error situations

    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChanges() - END - error: %d", error ));

    return error;

    }

TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChangesCancel( TUint aPid )

    {

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChangesCancel() - START"));

    NKern::ThreadEnterCS();

    TInt error = KErrNotFound;

    DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();

    DMemSpyInspectedProcess* pid = pidManager.InspectedProcessByProcessId( aPid );

    //

    if ( pid != NULL )

        {

        error = pid->NotifyOnChangeCancel();

        }

    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChangesCancel() - END - error: %d", error ));

    return error;

    }

TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsClear()

    {

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsClear() - START"));

    NKern::ThreadEnterCS();

    DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();

    pidManager.AutoStartListReset();

    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsClear() - END" ));

    return KErrNone;

    }

TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsAdd( TUint aSID )

    {

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsAdd() - START - aSID: 0x%08x", aSID ));

    NKern::ThreadEnterCS();

    DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();

    const TInt error = pidManager.AutoStartListAdd( aSID );

    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsAdd() - END - error: %d", error ));

    return error;

    }