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

// System includes
#include <memspy/driver/memspydriverobjectsshared.h>

// Shared includes
#include "MemSpyDriverOpCodes.h"
#include "MemSpyDriverObjectsInternal.h"

// User includes
#include "MemSpyDriverUtils.h"
#include "MemSpyDriverUserEventMonitor.h"



DMemSpyDriverLogChanUserEventMonitor::DMemSpyDriverLogChanUserEventMonitor( DMemSpyDriverDevice& aDevice, DThread& aThread )
:   DMemSpyDriverLogChanBase( aDevice, aThread )
    {
    TRACE( Kern::Printf("DMemSpyDriverLogChanThreadAndProcess::DMemSpyDriverLogChanThreadAndProcess() - this: 0x%08x", this ));
    }


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

    NKern::ThreadEnterCS();
    delete iEventMonitorManager;
    NKern::ThreadLeaveCS();

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


TInt DMemSpyDriverLogChanUserEventMonitor::Construct()
    {
    TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::Construct() - START"));
    //
    TInt error = BaseConstruct();
    //
    if  ( error == KErrNone )
        {
        iEventMonitorManager = new DMemSpyDriverClientEMManager( MemSpyDevice() );

        if  ( iEventMonitorManager )
            {
            TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::DoCreate - creating event monitor" ));

            error = iEventMonitorManager->Create();

            TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::DoCreate - event monitor create error: %d", error ));
            }
        }
    //
    TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::Construct() - END - error: %d", error ));
    return error;
    }



TInt DMemSpyDriverLogChanUserEventMonitor::Request( TInt aFunction, TAny* a1, TAny* a2 )
	{
	TInt r = DMemSpyDriverLogChanBase::Request( aFunction, a1, a2 );
    if  ( r == KErrNone )
        {
	    switch( aFunction )
		    {
        case EMemSpyDriverOpCodeEventMonitorOpen:
            r = EventMonitorOpen( a1 );
            break;
        case EMemSpyDriverOpCodeEventMonitorClose:
            r = EventMonitorClose( (TUint) a1 );
            break;
        case EMemSpyDriverOpCodeEventMonitorNotify:
            r = EventMonitorNotify( (TMemSpyDriverInternalEventMonitorParams*) a1 );
            break;
        case EMemSpyDriverOpCodeEventMonitorNotifyCancel:
            r = EventMonitorNotifyCancel( (TUint) a1 );
            break;

        default:
            r = KErrNotSupported;
		    break;
		    }
        }
    //
    return r;
	}


TBool DMemSpyDriverLogChanUserEventMonitor::IsHandler( TInt aFunction ) const
    {
    return ( aFunction > EMemSpyDriverOpCodeEventMonitorBase && aFunction < EMemSpyDriverOpCodeEventMonitorEnd );
    }



















TInt DMemSpyDriverLogChanUserEventMonitor::EventMonitorOpen( TAny* aHandle )
    {
	TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorOpen() - START") );
    NKern::ThreadEnterCS();
    
    DMemSpyDriverClientEM* monitor = iEventMonitorManager->EMOpen();
    TInt error = ( monitor != NULL )? KErrNone : KErrNoMemory;
    const TUint handle = ( monitor != NULL )? monitor->Handle() : KNullHandle;
    
    // Write handle back
    const TInt writeErr = Kern::ThreadRawWrite( &ClientThread(), aHandle, &handle, sizeof(TUint) );
	if  ( writeErr != KErrNone )
		{
        TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorOpen() - write error: %d", writeErr ) );
        error = writeErr;
		}
    //
    NKern::ThreadLeaveCS();
	TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorOpen() - END - handle: 0x%08x, error: %d", handle, error ));
    return error;
    }


TInt DMemSpyDriverLogChanUserEventMonitor::EventMonitorClose( TUint aHandle )
    {
	TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorClose() - START - aHandle: 0x%08x", aHandle));

    NKern::ThreadEnterCS();
    const TInt error = iEventMonitorManager->EMClose( aHandle );
    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorClose() - END - error: %d", error ));
    return error;
    }


TInt DMemSpyDriverLogChanUserEventMonitor::EventMonitorNotify( TMemSpyDriverInternalEventMonitorParams* aParams )
    {
	TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorNotify() - START"));
    NKern::ThreadEnterCS();

    // Read client info
    TMemSpyDriverInternalEventMonitorParams params;
	TInt error = Kern::ThreadRawRead( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverInternalEventMonitorParams) );
    //
    if  ( error == KErrNone )
        {
        DMemSpyDriverClientEM* monitor = iEventMonitorManager->EMInstance( params.iHandle );
        //
        if  ( monitor != NULL )
            {
            error = monitor->NotifyChanges( &ClientThread(), params.iStatus, params.iContext );
            }
        else
            {
            error = KErrNotFound;
            }
        }

    // NB: Let client take care of completing request in error situations
    NKern::ThreadLeaveCS();

    TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorNotify() - END - error: %d", error ));
    return error;
    }


TInt DMemSpyDriverLogChanUserEventMonitor::EventMonitorNotifyCancel( TUint aHandle )
    {
	TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorNotifyCancel() - START - aHandle: 0x%08x", aHandle));
    NKern::ThreadEnterCS();

    TInt error = KErrNotFound;
    DMemSpyDriverClientEM* monitor = iEventMonitorManager->EMInstance( aHandle );
    //
    if  ( monitor != NULL )
        {
        error = monitor->NotifyChangesCancel();
        }

    NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanUserEventMonitor::EventMonitorNotifyCancel() - END - error: %d", error ));
    return error;
    }