/*

* 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:  server implementation for Events Handler Server

*

*/

#include "evthandlerclientserver.h"

#include "evthandlerserversession.h"

#include "evthandlerserverconsts.h"

#include "evtnotifierhandler.h"

#include "evtmgmtuiengine.h"

#include "evtevent.h"

#include "evtdebug.h"

#include "evthandlerserver.h"

#include <AknGlobalNote.h>  // CAknGlobalNote

#include <w32std.h>

#include <apgtask.h>

#include <apgcli.h>

#include <apacmdln.h>

#include <bacline.h>

static const TInt KHandlerAppUid = 0x2001E668;

_LIT(KHandlerEXE, "evthandler.exe");

_LIT( KDelimiter, ":");

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

// CEvtHandlerServer::CEvtHandlerServer()

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

//

inline CEvtHandlerServer::CEvtHandlerServer()

		:CServer2( 0, ESharableSessions ), 

		iEventsQueue( KEvtItemArrayGranularity )

	{}

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

// CEvtHandlerServer::~CEvtHandlerServer()

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

//

CEvtHandlerServer::~CEvtHandlerServer()

	{

    EVTUIDEBUG( "+ CEvtHandlerServer::~CEvtHandlerServer()" );	

	if( iEvtSnoozeHandler )

		{

		delete iEvtSnoozeHandler;		

		}

	if( iEvtNotifierHandler )

		{

		delete iEvtNotifierHandler;		

		}    

    iEventsQueue.Close();

    EVTUIDEBUG( "- CEvtHandlerServer::~CEvtHandlerServer()" );

	}

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

// CEvtHandlerServer::NewLC()

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

//

CServer2* CEvtHandlerServer::NewLC()

	{

    EVTUIDEBUG( "+ CEvtHandlerServer::NewLC()" );

	CEvtHandlerServer* self = new ( ELeave ) CEvtHandlerServer;

	CleanupStack::PushL( self );

	self->ConstructL();

	EVTUIDEBUG( "- CEvtHandlerServer::NewLC()" );

	return self;

	}

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

// CEvtHandlerServer::ConstructL()

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

//

void CEvtHandlerServer::ConstructL()

/*

 * 2nd phase construction - ensure the timer and server objects are running

 */

	{

    EVTUIDEBUG( "+ CEvtHandlerServer::ConstructL()" );

	StartL( KEvtHandlerServerName );

	iShutdownTimer.ConstructL();

	iEvtSnoozeHandler = CEvtSnoozeHandler::NewL( *this );	

    EVTUIDEBUG( "- CEvtHandlerServer::ConstructL()" );

	}

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

// CEvtHandlerServer::NewSessionL()

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

//

CSession2* CEvtHandlerServer::NewSessionL( const TVersion&, const RMessage2& ) const

/*

 * Cretae a new client session. This should really check the version number.

 */

	{

    EVTUIDEBUG( "+ CEvtHandlerServer::NewSessionL()" );

	return new ( ELeave ) CEvtHandlerServerSession();

	}

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

// CEvtHandlerServer::HandleNewEventL()

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

//

void CEvtHandlerServer::HandleNewEventL( const TEvtEventId aEventId, const TInt aAccuracy )

    {

	EVTUIDEBUG2("+ CEvtHandlerServer::HandleNewEventL() - EventId = %d, Accuracy = %d", aEventId, aAccuracy);

    iShutdownTimer.Cancel();

    // Stop any running request

	delete iEvtNotifierHandler;		

	iEvtNotifierHandler = NULL;    

    // Remove if it was present in Snooze Que

	TTime time;

	time.HomeTime();

	TEvtSnoozeItem snoozeItem( aEventId, static_cast<TEvtFireAccuracy>(aAccuracy), time );

    iEvtSnoozeHandler->RemoveIfPresent( snoozeItem );	

    // Create an Event Info structure

    TEvtEventInfo evtInfo( aEventId, static_cast<TEvtFireAccuracy>(aAccuracy), ETrue, ETrue );

    TIdentityRelation<TEvtEventInfo> matcher(TEvtEventInfo::Match);

    TInt index = iEventsQueue.Find(evtInfo,matcher);

    // Remove if it was present in Notifier Que

    if( index != KErrNotFound )

        {

        iEventsQueue.Remove( index );

        }

    // Append this element to the front of queue

    iEventsQueue.Insert( evtInfo, 0 );

    // Restart the request handling process

    HandleNextEventL();

	EVTUIDEBUG("- CEvtHandlerServer::HandleNewEventL()");

    }

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

// CEvtHandlerServer::HandleNextEventL()

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

//

void CEvtHandlerServer::HandleNextEventL()

	{

	EVTUIDEBUG( "+ CEvtHandlerServer::HandleNextEventL()")

	TInt evtCount  = iEventsQueue.Count();

	if( evtCount )

		{		

		EVTUIDEBUG1( "EventId = %d", iEventsQueue[ 0 ].iEventId );

		iEvtNotifierHandler = CEvtNotifierHandler::NewL( *this, iEventsQueue[ 0 ] );

		// Check if the Event is Launchable - Is it present and Active	

		if( iEvtNotifierHandler->IsLaunchable() )

			{

			iEvtNotifierHandler->StartEvtNotifierL();

	        // Set the tone play to False So that it does not play tone next time.

	        if( iEventsQueue[ 0 ].iPlayTone )

	        	iEventsQueue[ 0 ].iPlayTone = EFalse;

			}

		else

			{

			delete iEvtNotifierHandler;		

			iEvtNotifierHandler = NULL;    

			iEventsQueue.Remove( 0 );

			evtCount  = iEventsQueue.Count();

			}

		}

	if( !evtCount )

        {

        if( iEvtSnoozeHandler->IsSnoozeQueEmpty() )

            {

            EVTUIDEBUG( "Handler Server shutdown")

            iShutdownTimer.Start();    

            }

        }

    EVTUIDEBUG( "- CEvtHandlerServer::HandleNextEventL()" );

	}

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

// CEvtHandlerServer::SnoozeCompleteL()

// 

// Derived from MEvtSnoozeObserver 

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

//

void CEvtHandlerServer::SnoozeCompleteL( 

    	TEvtSnoozeItem& aSnoozeItem, 

    	TBool aSnoozeAgain )

    {

	EVTUIDEBUG2("+ CEvtHandlerServer::SnoozeCompleteL() - EventId = %d, Snooze = %d", 

	                    aSnoozeItem.iEventId, aSnoozeAgain);

    // Stop any running request

	delete iEvtNotifierHandler;		

	iEvtNotifierHandler = NULL;    

    // Create an Event Info structure

    TEvtEventInfo evtInfo( aSnoozeItem.iEventId, aSnoozeItem.iAccuracy, ETrue, aSnoozeAgain );

    // Append this element to the front of queue

    iEventsQueue.Insert( evtInfo, 0 );

    // Restart the request handling process

    HandleNextEventL();

	EVTUIDEBUG("- CEvtHandlerServer::SnoozeCompleteL()");

    }

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

// CEvtHandlerServer::HandlerCompleteL()

// 

// Derived from MEvtNotifierObserver 

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

//

void CEvtHandlerServer::HandlerCompleteL( 

    	TEvtInfoNoteResult aResult,

        CEvtEvent* aEvent )

	{	

    EVTUIDEBUG2( "+ CEvtHandlerServer::HandlerCompleteL() - EventId = %d, Notifier Action = %d", iEventsQueue[ 0 ].iEventId, aResult );

	TEvtEventId evtId = aEvent->EventId();

	TBool repeat = aEvent->Repeat();

	// Delete the previous running instance of the server

	delete iEvtNotifierHandler;

	iEvtNotifierHandler = NULL;

	switch( aResult )

		{

		case EOpenTrigger:

		case EShowDetails:

			{

			EVTUIDEBUG( "Open Event" );

	        TBuf8< KEvtCommandMessageLength > buffer;

	        buffer.AppendNum( evtId );

	        buffer.Append( KDelimiter );

	        buffer.AppendNum( aResult );

	        buffer.Append( KDelimiter );

	        // Create a session to Windows server to check the running of 

	        // handler ui

		    RWsSession  ws;

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

		    CleanupClosePushL( ws ); // pushing to cleanupstack

		    // Check if Handler Application is already running. Incase its

		    // send the command message to the application

		    TApaTaskList taskList( ws );

		    TApaTask task = taskList.FindApp( TUid::Uid( KHandlerAppUid ) );

		    if ( task.Exists() )

		        {

		        // Bring the task to the foreground and send a message to it.		        	       

		        task.BringToForeground();

		        User::LeaveIfError( task.SendMessage( TUid::Uid( KUidApaMessageSwitchOpenFileValue ), buffer ));		        

		        }

		    else

		    	{

		    	// Start and instance of the new application

		    	LaunchAppL( TUid::Uid( KHandlerAppUid), buffer );			    

	            }

	        CleanupStack::PopAndDestroy();	// ws	

	        // Remove if it was present in Snooze Que

			TTime time;

			time.HomeTime();

			TEvtSnoozeItem snoozeItem( iEventsQueue[0].iEventId, iEventsQueue[0].iAccuracy, time );

            iEvtSnoozeHandler->RemoveIfPresent( snoozeItem );		    		

	        break;

			}		

		case ESnoozeTrigger:

			{

			EVTUIDEBUG( "Snooze Event" );		

			TTime time;

			time.HomeTime();

			TEvtSnoozeItem snoozeItem( iEventsQueue[0].iEventId, iEventsQueue[0].iAccuracy, time );

			iEvtSnoozeHandler->Snooze( snoozeItem );

            break;			

			}

		case ECloseInfoNote:

			{

			EVTUIDEBUG( "Closing Note" );	

            // Update State if needed.

            if( !repeat )

                ChangeStateL( evtId );

	        // Remove if it was present in Snooze Que

			TTime time;

			time.HomeTime();

			TEvtSnoozeItem snoozeItem( iEventsQueue[0].iEventId, iEventsQueue[0].iAccuracy, time );

            iEvtSnoozeHandler->RemoveIfPresent( snoozeItem );		

            break;			

			}

		default:

		    {

	        // Remove if it was present in Snooze Que

			TTime time;

			time.HomeTime();

			TEvtSnoozeItem snoozeItem( iEventsQueue[0].iEventId, iEventsQueue[0].iAccuracy, time );

            iEvtSnoozeHandler->RemoveIfPresent( snoozeItem );	

		    break;    

		    }					

		}

    // The note has been handled. Remove the note from the queue		

	iEventsQueue.Remove( 0 );

	HandleNextEventL();	

    EVTUIDEBUG( "- CEvtHandlerServer::HandlerCompleteL()" );

	}

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

// CEvtHandlerServer::ChangeStateL() 

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

//

void CEvtHandlerServer::ChangeStateL( TEvtEventId aEvtId )

    {  

    EVTUIDEBUG1( "Change State of %d", aEvtId );

    TBuf16< KEvtCommandMessageLength > buffer;

    buffer.AppendNum( EEvtActionChangeState );

    buffer.Append( KDelimiter );

    buffer.AppendNum( aEvtId );

    RProcess proc;

    TInt retVal = proc.Create( KHandlerEXE(), buffer);

    if(retVal == KErrNone)

        {

        proc.Resume();

        }

    proc.Close();

    }

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

// CEvtHandlerServer::LaunchAppL() 

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

//

void CEvtHandlerServer::LaunchAppL(

                                TUid                    aApplicationUid,

                          const TDesC8&                  aCmdLineArg )

    {  

    DEBUG("+ CEvtHandlerServer::LaunchAppL");

    // Create the Session handle and connect to the Application architecture

    // server. This is required to obtain the details of the application from

    // the Application UID.

    RApaLsSession lsSession;

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

    CleanupClosePushL( lsSession );

    DEBUG("+ CEvtHandlerServer::LaunchAppL - Get the Application Information");

    // Get the Application Information.

    TApaAppInfo appInfo;    

    TInt error = lsSession.GetAppInfo( appInfo, aApplicationUid );

    if ( error )

    	{

    	EVTUIDEBUG1("Get the Application Information Error : %d", error );

    	User::Leave( error );

    	}

    DEBUG("+ CEvtHandlerServer::LaunchAppL - Fill the command line argument structure");

    // Fill the command line argument structure

    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

    DEBUG("+ CEvtHandlerServer::LaunchAppL - Set the Application name");

    // Set the Application name.    

    TFileName appName = appInfo.iFullName;

    cmdLine->SetExecutableNameL( appName );

    DEBUG("+ CEvtHandlerServer::LaunchAppL - Set the Command");

    // Set the Command

    cmdLine->SetCommandL( EApaCommandRun );

    DEBUG("+ CEvtHandlerServer::LaunchAppL - Set the Command line arguments");

    // Set the Command line arguments.

    if ( aCmdLineArg.Length())

        {

        // These arguments would be sent as Tail end arguments to the launched

        // Application. Its left to the application to handle those

        HBufC8* tailEnd = HBufC8::NewLC( aCmdLineArg.Length());

        tailEnd->Des().Copy( aCmdLineArg );

        // The Tail end buffer is copied to the Command line structure. Hence,

        // can delete this variable after the set operation succeeds.

        cmdLine->SetTailEndL( tailEnd->Des());

        CleanupStack::PopAndDestroy( tailEnd );

        }

    DEBUG("+ CEvtHandlerServer::LaunchAppL - Start the Application");

	// Start the Application

	User::LeaveIfError( lsSession.StartApp( *cmdLine ));

    // Clean up all the allocated heap variables.

    CleanupStack::PopAndDestroy( cmdLine );

    CleanupStack::PopAndDestroy(); //lsSession 		         

    DEBUG("- CEvtHandlerServer::LaunchAppL");

    }

// End of File