/*

* 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:  Handler for notifier on Event

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <AknGlobalNote.h>  // CAknGlobalNote

#include "evtdebug.h"

#include "evtnotifierhandler.h"

#include "evtnotifierobserver.h"

#include "evttoneaction.h"

#include "evtglobalquery.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

//S60 Event Notifier plugin id

const TUid KEvtNotifierUidS60 = { 0x2001E66C };

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

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

// CEvtNotifierHandler::NewL

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

CEvtNotifierHandler* CEvtNotifierHandler::NewL(

        	MEvtNotifierObserver& aNotifierObserver,

        	TEvtEventInfo aEventInfo )

    {

    CEvtNotifierHandler* self = new ( ELeave ) CEvtNotifierHandler( aNotifierObserver, aEventInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CEvtNotifierHandler::CEvtNotifierHandler

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

CEvtNotifierHandler::CEvtNotifierHandler( 

	MEvtNotifierObserver& aNotifierObserver, TEvtEventInfo aEventInfo )

    : CActive( EPriorityStandard ), 

      iNotifierObserver( aNotifierObserver ),iEventInfo(aEventInfo)

    {

    CActiveScheduler::Add( this );

    }

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

// CEvtNotifierHandler::~CEvtNotifierHandler

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

CEvtNotifierHandler::~CEvtNotifierHandler()

    {

    delete iInputParam;

    delete iInputBuffer;

    Cancel();

    if(iEvtGlobalQuery)

        {

        delete iEvtGlobalQuery;

        iEvtGlobalQuery = NULL;

        }

    iNotifier.Close();

    delete iEvent;

    delete iEventManager;

    }

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

// CEvtNotifierHandler::ConstructL

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

void CEvtNotifierHandler::ConstructL()

    {

    EVTUIDEBUG("+ CEvtNotifierHandler::ConstructL");    

    iInputBuffer = CBufFlat::NewL( KEvtNotifierBufferLength );        

    iInputParam  = CEvtInfoNoteInputParam::NewL();    

    iResponseBuffer.Zero();

    iResponseBuffer.SetLength( KEventIdLength );  

    iEventManager = CEvtEventManager::NewL();

    EVTUIDEBUG( "- CEvtNotifierHandler::ConstructL" );

    }

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

// CEvtNotifierHandler::IsLaunchable

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

TBool CEvtNotifierHandler::IsLaunchable()

	{    

    EVTUIDEBUG( "+ CEvtNotifierHandler::IsLaunchable" );	

	TBool launchable = EFalse;

    TRAPD( evtErr, iEvent = iEventManager->GetEventL( iEventInfo.iEventId ) );

    if( !evtErr && iEvent && iEvent->EventStatus() == EActive )

		{

		launchable = ETrue;

		}

    return launchable;

	}

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

// CEvtNotifierHandler::StartEvtNotifier

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

void CEvtNotifierHandler::StartEvtNotifierL()

	{    

    EVTUIDEBUG( "+ CEvtNotifierHandler::StartEvtNotifierL" );	

    if( iEvent )

    	{

    	CEvtInfoNoteInputParam::TEvtTriggerAccuracy accuracy;

    	accuracy = static_cast<	CEvtInfoNoteInputParam::TEvtTriggerAccuracy>(iEventInfo.iAccuracy);

		// set the subject and description of notifier

	    iInputParam->SetSubjectL( iEvent->Subject() );

	    iInputParam->SetDescriptionL( iEvent->Description() );

	    iInputParam->SetTrigerringAccuracy( accuracy );    

	    iInputParam->SetToneEnabled( iEventInfo.iPlayTone );    	      

	    iInputParam->SetShowSnooze( iEventInfo.iSnooze );

        if( iEventInfo.iPlayTone && iEvent->HasAction() )

            {      

            // Populate the Tone.

       		CEvtToneAction* tone = CEvtToneAction::NewLC();

            tone->InternalizeL( iEvent->Action() );

            iInputParam->SetToneL( tone->FileName() );

            iInputParam->SetToneRepeat( tone->ToneLoop() );    

        	CleanupStack::PopAndDestroy(tone);      

            }

        EVTUIDEBUG( "Trigger Fired Event" );

        if(iEvent->Subject().Length())

	        {

	        TPtrC subject( iEvent->Subject() );        

        	EVTUIDEBUG1( "Subject  = %S", &subject );	

	        }

        EVTUIDEBUG1( "Tigger ID  = %d", iEvent->EventId() );

	    RBufWriteStream writeStream( *iInputBuffer, 0 );

	    CleanupClosePushL( writeStream );                

	    iInputParam->ExternalizeL( writeStream );

	    TPtr8 bufPtr( const_cast< TUint8 *>( iInputBuffer->Ptr( 0 ).Ptr() ),

	                  iInputBuffer->Ptr( 0 ).Length(),

	                  iInputBuffer->Ptr( 0 ).Length() );

	    iHandlerType = EHandlerNotifier;

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

	    iNotifier.StartNotifierAndGetResponse( iStatus, KEvtNotifierUidS60, bufPtr, iResponseBuffer );

	    SetActive();

	    CleanupStack::Pop(); // writeStream	    	

    	}	    

    EVTUIDEBUG( "- CEvtNotifierHandler::StartEvtNotifierL" );

	}

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

// CEvtNotifierHandler::RunL

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

void CEvtNotifierHandler::RunL()

    {

    EVTUIDEBUG1( "+ CEvtNotifierHandler::RunL %d", iStatus.Int() );

    TEvtInfoNoteResult result = ECloseInfoNote; 

    switch( iStatus.Int() )

        {

        case KErrNone:

            {

    	    TInt retVal = 0;

    	    TLex8  lexer( iResponseBuffer );

    	    TInt   error = lexer.Val( retVal );    

    	    EVTUIDEBUG1( "Event %d", retVal ); 

    	    switch( retVal )

    	    	{

    			case EOpenTrigger:

    				{

    				result = EOpenTrigger;

    				break;				

    				}			

    			case EShowDetails:

    				{

    				result = EShowDetails;

    				break;				

    				}		 

                case ESnoozeTrigger:

                    {

                    result = ESnoozeTrigger;

                    break;              

                    }   

    			case ECloseInfoNote:

    			default:

    				{

    				result = ECloseInfoNote;

    				break;				

    				}  			

    	    	}

            // Complete the event note launching

            iNotifierObserver.HandlerCompleteL( result, iEvent ); 

            break;

            }

		default:

			{

			if(iHandlerType == EHandlerNotifier)

			    {

			    iHandlerType = EHandlerGlobalNote;

                iStatus = KRequestPending;

				if(iEvtGlobalQuery)

					{

					delete iEvtGlobalQuery;

					iEvtGlobalQuery = NULL;

					}

                iEvtGlobalQuery = CEvtGlobalQuery::NewL(*iInputParam);

                iEvtGlobalQuery->StartGlobalQueryL( iStatus, iResponseBuffer );

                SetActive();

			    }

			else

			    {

			    // Complete the event note launching

		        iNotifierObserver.HandlerCompleteL( result, iEvent ); 

			    }

			break;				

			}

        }

    EVTUIDEBUG( "- CEvtNotifierHandler::RunL" );

    }

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

// CEvtNotifierHandler::DoCancel

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

void CEvtNotifierHandler::DoCancel()

    {

    EVTUIDEBUG( "+ CEvtNotifierHandler::DoCancel()" );

	if(iHandlerType == EHandlerNotifier)

	    {

    	iNotifier.CancelNotifier( KEvtNotifierUidS60 );

		}

	else

		{

		iEvtGlobalQuery->CancelDialog();

		}

    EVTUIDEBUG( "- CEvtNotifierHandler::DoCancel()" );

    }

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

// CEvtNotifierHandler::RunError

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

TInt CEvtNotifierHandler::RunError( TInt /*aError*/ )

    {

    return KErrNone;    

    }

//  End of File