/*

* 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:  Info Note implementation

*

*/

// System Includes

#include <eikenv.h>

#include <e32std.h>

#include <aknmessagequerydialog.h>

#include <bautils.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <AknNotiferAppServerApplication.h>

#include <aknPopupHeadingPane.h>

#include <evtinfonote.rsg>

#include <s32mem.h>

#include <eikbtgpc.h>

#include <gulicon.h>

#include <AknsUtils.h>

#include <eikimage.h>

#include <aknnotedialog.h>

// User Includes

#include "evtinfonoteparams.h"

#include "evtinfonote.h"

#include "evtinfonoteinterface.h"

#include "evtinfonoteconsts.hrh"

#include "evtinfonoteimpl.h"

#include "evtdebug.h"

// Constant Definitions

_LIT(KResourceFileName, "evtinfonote.rsc");

static const TInt KLengthOfNum = 64;

//

// ------------------------- Member Function definition ----------------------

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

// CEvtInfoNote::CEvtInfoNote()

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

//

CEvtInfoNote::CEvtInfoNote()

    : CActive( EPriorityStandard )

    {

    }

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

// CEvtInfoNote::~CEvtInfoNote()

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

//

CEvtInfoNote::~CEvtInfoNote()

    {    

    // If there is an existing message outstanding then

    // terminate the message

    CompleteMessage( KErrServerTerminated );

    Cancel();

    delete iInputBuffer;

    // Free the resources

    iEikEnv->DeleteResourceFile( iResourceFileFlag );

    if ( iAppSwitchSupress && iAppUi )

        {

        iAppUi->SuppressAppSwitching( EFalse ); 

        iAppSwitchSupress = EFalse;                        

        }            

    }

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

// void CEvtInfoNote::ConstructL()

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

//    

void CEvtInfoNote::ConstructL()

    {

    EVTUIDEBUG( "+ CEvtInfoNote::ConstructL" );

    // Store a Local pointer for Eikon Env

    iEikEnv = CEikonEnv::Static();

    iAppUi = static_cast< CAknNotifierAppServerAppUi* >( iEikEnv->EikAppUi());

    // Open the localized resource file

    TFileName dllDrive;;

    Dll::FileName( dllDrive );

    // File name without the drive letter.

    TFileName filename;

    filename += KDC_RESOURCE_FILES_DIR; 

    filename += KResourceFileName;        

    // Append the drive letter to the file name.    

    TParse parse;

	User::LeaveIfError( parse.Set( dllDrive, NULL, NULL ) );

    User::LeaveIfError( parse.Set( parse.Drive(), &filename, NULL ) );

	filename = parse.FullName();	                        

    BaflUtils::NearestLanguageFile(iEikEnv->FsSession(),filename);

    EVTUIDEBUG( "Before Resource File" );

    iResourceFileFlag=iEikEnv->AddResourceFileL(filename);

    EVTUIDEBUG( "After Resource File" );

    // Add the object to the Active scheduler

    CActiveScheduler::Add( this );

    EVTUIDEBUG( "- CEvtInfoNote::ConstructL" );

    }

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

// CEvtInfoNote* CEvtInfoNote::NewL()

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

//

CEvtInfoNote* CEvtInfoNote::NewL()

    {

    CEvtInfoNote* self = new ( ELeave ) CEvtInfoNote;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// void CEvtInfoNote::Release()

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

//    

void CEvtInfoNote::Release()  

    {

    EVTUIDEBUG( "+ CEvtInfoNote::Release" );

    // This method is called to free all the resources

    // associated with the Notifier. Here it would mean deleting

    // the notifier handle

    delete this;

    EVTUIDEBUG( "- CEvtInfoNote::Release" );        

    }

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

// MEikSrvNotifierBase2::TNotifierInfo CEvtInfoNote::Info() const

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

//    

MEikSrvNotifierBase2::TNotifierInfo CEvtInfoNote::Info() const

    {

    EVTUIDEBUG( "+ CEvtInfoNote::Info" );

    // Return the notifier information

    return iInfo;

    }

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

// TPtrC8 CEvtInfoNote::StartL

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

//    

TPtrC8 CEvtInfoNote::StartL( const TDesC8&        /* aBuffer */ )

    {    

    TPtrC8 ret( KNullDesC8 );

    return ( ret );    

    }

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

// void CEvtInfoNote::StartL

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

//    

void CEvtInfoNote::StartL( const TDesC8&          aBuffer,

                                  TInt            aReplySlot,

                            const RMessagePtr2&   aMessage )          

    {

    EVTUIDEBUG( "+ CEvtInfoNote::StartL" );

    // The notifier will handle only one request at a time.

    if ( IsActive())

        {

        User::Leave ( KErrInUse );

        }

    iTriggerEvent = EDisplayNotifier;      

    iMessage = aMessage;    

    // Delete the old buffer and copy the contents of the argument into this

    // buffer

    // This buffer needs to be stored because, the user is going to handle

    // the request asynchrnously.     

    delete iInputBuffer;  

    iInputBuffer = NULL;

    iInputBuffer = aBuffer.AllocL();

    // Copy the reply Slot

    iReplySlot = aReplySlot;

    TRequestStatus* status = &iStatus;

    SetActive();    

    User::RequestComplete( status, KErrNone );    

    EVTUIDEBUG( "- CEvtInfoNote::StartL" );

    }

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

// void CEvtInfoNote::Cancel

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

//    

void CEvtInfoNote::Cancel()

    {

    EVTUIDEBUG( "+ CEvtInfoNote::Cancel" );

    // Delete the running Information note

    delete iInfoNote;

    iInfoNote = NULL;

    CompleteMessage( KErrCancel );

    delete iInputBuffer;

    iInputBuffer = NULL;

    iTriggerEvent = ENone;   	         

    CActive::Cancel();

    EVTUIDEBUG( "- CEvtInfoNote::Cancel" );

    }

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

// TPtrC8 CEvtInfoNote::UpdateL

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

//    

TPtrC8 CEvtInfoNote::UpdateL( const TDesC8&   /* aBuffer */ )

    {

    TPtrC8 ret( KNullDesC8 );

    return ( ret );    

    }

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

// TPtrC8 CEvtInfoNote::UpdateL

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

//

void CEvtInfoNote::UpdateL( const TDesC8&         /* aBuffer */, 

                                   TInt            /* aReplySlot */, 

                             const RMessagePtr2&   aMessage)

    {

    aMessage.Complete( KErrNotSupported );

    }

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

// CEvtInfoNote::TNotifierInfo CEvtInfoNote::RegisterL()

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

//

CEvtInfoNote::TNotifierInfo CEvtInfoNote::RegisterL()

    {

    iInfo.iUid          = KEvtInfoNote;

    iInfo.iChannel      = KEvtInfoNoteChannel;

    iInfo.iPriority     = ENotifierPriorityHigh; 

    return iInfo;    

    }

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

// void CEvtInfoNote::CompleteMessage()

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

// 

void CEvtInfoNote::CompleteMessage( TInt        aError,

                                    TInt        aKeyPressEvent )

	{

	EVTUIDEBUG( "+ CEvtInfoNote::CompleteMessage" );

	// Check if the message is not NULL

	if ( !iMessage.IsNull() )

		{

		// Obtain the Reply slot and communicate the response

		// to the user

		TInt desLength = iMessage.GetDesLength( iReplySlot );

		if (  desLength >= KLengthOfNum )

		    {

		    TBuf8< KLengthOfNum > returnBuf;

		    returnBuf.AppendNum( aKeyPressEvent );

		    TInt length = returnBuf.Length();

		    length = length + 1;

		    TInt error = iMessage.Write( iReplySlot, returnBuf );

		    if ( !error )

		        {

		        EVTUIDEBUG1( "CEvtInfoNote::CompleteMessage - Write Error : %d", error );

		        }

		    }

		iMessage.Complete( aError );	

		}

    if ( iAppSwitchSupress && iAppUi )

        {

        iAppUi->SuppressAppSwitching( EFalse ); 

        iAppSwitchSupress = EFalse;                        

        }

    iTriggerEvent = ENone;

    EVTUIDEBUG( "- CEvtInfoNote::CompleteMessage" );		

	}

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

// void CEvtInfoNote::RunL()

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

//                             

void CEvtInfoNote::RunL()

    {

    EVTUIDEBUG( "+ CEvtInfoNote::RunL" );  

    // Do this only on KErrNone

    if ( !iStatus.Int())

    	{

    	switch( iTriggerEvent )

    		{

    		case EDisplayNotifier:

    			{

    			// Fetch the input parameters 

    			CEvtInfoNoteInputParam* param = GetInputParametersLC();

    			CleanupStack::Pop( param );

    			// Create a new dialog instance

    			CEvtInfoNoteImpl* queryDialog = CEvtInfoNoteImpl::NewLC( param );

	            // Display the dialog in cover UI

	            // queryDialog->PublishDialogL( SuplQueryId(), KCatUidSuplQuery );

			    // Store the value for the Query dialog. this would be useful

			    // for cancelling it.			    			    

			    iInfoNote = queryDialog;

			    // Supress the App switching

			    if ( !iAppSwitchSupress )

			        {

                    iAppUi->SuppressAppSwitching( ETrue );    	         

    	            iAppSwitchSupress = ETrue;			        

			        }

			    TEvtInfoNoteCmds flag;

			    TInt keypress = KErrNone;

		    	keypress = queryDialog->RunLD( &flag );

		    	iInfoNote = NULL;

		    	EVTUIDEBUG1( "Key Press : %d", keypress );

				EVTUIDEBUG1( "Return Code : %d", flag );

		    	if ( keypress )

			    	{

				    switch( flag )

				    	{

						case EEvtCmdOpenEvent:

							{

							CompleteMessage( KErrNone, EOpenTrigger );

							break;				

							}		

						case EEvtCmdSnoozeEvent:

							{

							CompleteMessage( KErrNone, ESnoozeTrigger );

							break;				

							}		

						case EEvtCmdShowDetails:

							{

							CompleteMessage( KErrNone, EShowDetails );

							break;				

							}	

						case ECloseInfoNote:

							{

							CompleteMessage( KErrNone, ECloseInfoNote );

							break;				

							}

						default:

							{

							break;				

							}    			

				    	}	

			    	}

			    else

			    	{

			    	CompleteMessage( KErrNone, ECloseInfoNote );

			    	}

		    	// Reset the trigger Event

		    	iTriggerEvent = ENone;

		    	break;

    			}   			

    		default:

    			{

    			User::Leave( KErrNotSupported );

    			break;

    			}

    		}

    	}

	else

		{

		EVTUIDEBUG1( "- CEvtInfoNote::Error %d ", iStatus.Int() );

		// Error Handling for non-KErrNone status

		CompleteMessage( iStatus.Int());

		}				

    EVTUIDEBUG( "- CEvtInfoNote::RunL" );

    }

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

// void CEvtInfoNote::DoCancel()

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

// 

void CEvtInfoNote::DoCancel()

    {    

    // Reset the state machine

    iTriggerEvent = ENone;    

    }

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

// TInt CEvtInfoNote::RunError()

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

//    

TInt CEvtInfoNote::RunError( TInt aError )

	{

	EVTUIDEBUG( "+ CEvtInfoNote::RunError" );

	// If the dialog value is set then the dialog must be

	// set to NULL because the dialog would have been destroyed

	// already since its present on the cleanup stack

    iInfoNote= NULL;

	// Complete the outstanding request with the error code

	CompleteMessage( aError );

    // Reset the state machine.

    iTriggerEvent = ENone;  

    EVTUIDEBUG( "- CEvtInfoNote::RunError" );	

	return CActive::RunError( aError );	

	}

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

// TInt CEvtInfoNoteInputParam::GetInputParametersLC()

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

//	

CEvtInfoNoteInputParam* CEvtInfoNote::GetInputParametersLC()

    {

    EVTUIDEBUG( "+ CEvtInfoNote::GetInputParametersLC" );

    // Create a new input paramter object. The ownership of 

    // this object will be transferred back to the calling

    // function.

	CEvtInfoNoteInputParam* input = CEvtInfoNoteInputParam::NewL();

	CleanupStack::PushL( input );

	// Obtain the parameters from the Input Buffer

	CBufFlat* inputParams = 

	            CBufFlat::NewL( iInputBuffer->Des().Length() );

	CleanupStack::PushL( inputParams );

	inputParams->ResizeL( iInputBuffer->Des().Length());

    inputParams->Ptr( 0 ).Copy( *iInputBuffer );

    // Set the Read buffer to read the values from input buffer

    RBufReadStream  readStream( *inputParams, 0 );

    CleanupClosePushL( readStream );

    // Internalize the input buffer string to the current object.

    input->InternalizeL( readStream );

    CleanupStack::PopAndDestroy( 2, inputParams );

    EVTUIDEBUG( "- CEvtInfoNote::GetInputParametersLC" );

    return input;  

    }