/*

* Copyright (c) 2008 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:  Client Provider for Events Handler Server

*

*/

//INCLUDE FILES

//SYSTEM INCLUDES

#include <e32base.h>

#include <bacline.h> 		// CCommandLineArguments

//USER INCLUDES

#include "evthandler.h"

#include "evthandlerclientserver.h"

#include "evthandlerclient.h"

#include "evthandlerserverconsts.h"

#include "evtdebug.h"

#include "evtmgmtuiengine.h"

#include "evtevent.h"

#include "evteventmanager.h"

//CONSTANTS

_LIT( KEventId,"%d");

_LIT(KEvtHandler,"Handler Ui Panic");

static const TInt KSchedulerCreate = 1;

// ----------------------------------------------------------------------------

// void EvtHandlerStartup::HandleEventL()

// ----------------------------------------------------------------------------

//

void EvtHandlerStartup::HandleEventL()

	{

	EVTUIDEBUG("+ EvtHandlerStartup::HandleEventL()");

	TBuf<KEvtCommandMessageLength> cmdArg;

	TBuf<KEventIdLength> eventId;

    TEvtConsoleAction evtAction = EEvtActionNone;

	TEvtEventId evtId = 0;

	TInt action=0;

	TBool isValidEventId = EFalse;

	// create and install the active scheduler we need

	CActiveScheduler* scheduler=new(ELeave) CActiveScheduler;

	__ASSERT_ALWAYS(scheduler!=NULL,User::Panic(KEvtHandler, KSchedulerCreate));

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);  

	while( ETrue )

		{

		//Create CommandLine Arguments and read it.

		CCommandLineArguments* args = CCommandLineArguments::NewLC();

		// check for valid argument count

		TInt cnt = args->Count();

        TPtrC cmdPrt1( args->Arg( 0 ) );

		if( cnt == 2 ) // 2 - Process name, Console Action:Event Id

			{

			TPtrC cmdPrt( args->Arg( 1 ) ); // read first argument - Console Action:Event Id

			cmdArg.Copy( cmdPrt );

			}

		CleanupStack::PopAndDestroy( args );

		// Check for valid arguments 

		if( cmdArg.Length() <= 0 )

			{

			break;

			}

		// Extract the Action for Event

		TLex lex( cmdArg );

		TInt errorCode = lex.Val( action );

		if( errorCode != KErrNone)

			{

			break;

			}

		// Get the meaningful Action.

		evtAction = static_cast<TEvtConsoleAction>(action);

        // Increment the Delimiter

        lex.Inc();

        // Extract the Id of Event

		errorCode = lex.Val( evtId, EDecimal );

        if( errorCode != KErrNone)

            {

            break;

            }

        // Format the Event Id buffer

		eventId.Format( KEventId, evtId );

		// Set the Valid Event Id flag as True 

		isValidEventId = ETrue;

		break;

		}

	if ( isValidEventId )

		{

		EVTUIDEBUG1("EvtHandlerStartup::HandleEventL - Event Id %S",&eventId);

		// Create an engine instance to handle the requested actions.

		CEvtMgmtUiEngine* engine = CEvtMgmtUiEngine::NewLC();

		switch( evtAction )

		    {

		    case EEvtActionFired:

				{

		        // Calculate the Accuracy of the Fired Event

		        TEvtFireAccuracy accuracy = engine->CalculateFiredAccuracyL( evtId );

		        // Launch the Server to handle the fired event

		        REvtHandlerSession popupClient;

		        CleanupClosePushL( popupClient );

		        User::LeaveIfError( popupClient.Connect() );

		        popupClient.SendEventId( eventId, accuracy );

		        CleanupStack::PopAndDestroy( );   // popupClient

		        break;

				}

		    case EEvtActionChangeState:

		        {

				// Handle the Change State

		        engine->HandleFiredTriggerStateL( evtId );

		        break;

				}

		    default:

		        break;

		    }

		CleanupStack::PopAndDestroy( );	// engine

		}

	// Delete active scheduler

   	CleanupStack::PopAndDestroy(scheduler);

	EVTUIDEBUG("- EvtHandlerStartup::HandleEventL()");

	}

// ---------------------------------------------------------------------------

// TInt EvtHandlerServerStartup::StartEvtHandlerServer()

// ---------------------------------------------------------------------------

//

TInt EvtHandlerStartup::StartEvtHandler()

    {

	EVTUIDEBUG("+ EvtHandlerStartup::StartEvtHandler()");

    __UHEAP_MARK;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    TInt ret = KErrNoMemory;

    if ( cleanupStack )

        {

        TRAP(ret, HandleEventL());

        delete cleanupStack;

        }

    __UHEAP_MARKEND;

	EVTUIDEBUG("- EvtHandlerStartup::StartEvtHandler()");

    return ret;    

    }

// -----------------------------------------------------------------------------

// TInt E32Main

// Server process entry-point

// -----------------------------------------------------------------------------

//

TInt E32Main()

    {

	EVTUIDEBUG("+ E32Main()");

    return EvtHandlerStartup::StartEvtHandler();    

    }

// End of File