/*

* 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:   It is handler class to handle editor commands

*

*/

#include <evtmgmteditorui.rsg>

#include <AknQueryDialog.h> 

#include <StringLoader.h>

#include <lbsposition.h>

#include <aknlistquerydialog.h>

#include <StringLoader.h>

#include <AknIconArray.h>       // Icon Array

#include <evteditor.mbg>

#include <AknsUtils.h>

#include <AknsSkinInstance.h>

#include <data_caging_path_literals.hrh>

#include <gulicon.h>            // Gul Icon

#include <eikapp.h>

#include <aknlistquerydialog.h>

#include <eikserverapp.h>

#include <aknappui.h>

#include <eikenv.h>

#include "evteditor.h"

#include "evtevent.h"

#include "evttoneaction.h"

#include "evtaction.h"

#include "evtmgmteditorui.hrh"

#include "evtmgmtuieditorcmdhandler.h"

#include "evtmgmtuiplacecomponent.h"

#include "evtmgmtuidesccomponent.h"

#include "evtmgmtuiringtonecomponent.h"

#include "evtmgmtuimapnavigationadapter.h"

#include "evtdebug.h"

#include "evteditorconsts.h"

#include "evtmgmtuiwaitdlglauncher.h"

#include "evtmgmtuiengine.h"

#include "evtmgmtuilbtadapter.h"

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

// CEvtEditor ::NewL()

// @param[in] aExitCmdHandler - handler to handle all commands which 

//                              may result into closing editor

// @param[in/out] aEvent - event object which contains current event information.

//                         event details may be changed while executing commands

// @param[in] aEditorObserver - observer to handle editor specific operations 

//                              after command is executed   

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

//

CEvtMgmtUiEditorCmdHandler* CEvtMgmtUiEditorCmdHandler::NewL( 

                                CEvtEvent&                      aEvent, 

                                MEvtMgmtUiEditorObserver&       aEditorObserver,

                                CEvtMgmtUiEngine&               aEventEngine )

    {

    CEvtMgmtUiEditorCmdHandler * self = 

                    new ( ELeave ) CEvtMgmtUiEditorCmdHandler( aEvent, 

                                                               aEditorObserver,

                                                               aEventEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CEvtMgmtUiEditorCmdHandler ::~CEvtMgmtUiEditorCmdHandler()

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

//

CEvtMgmtUiEditorCmdHandler::~CEvtMgmtUiEditorCmdHandler()

    {

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

    // Unregister the command handler as an observer

    iEventEngine.RemoveObserver( this );

    //cancel any asychronous operation

    Cancel();

    // Reset the Array

    iEvtIdArray.Reset(); 

    iEvtIdArray.Close();

    //Delete iMapAdapter 

    if( iMapAdapter )

        {

        delete iMapAdapter;

        iMapAdapter = NULL;

        }

    //Delete iRingtoneComponent

    if( iRingtoneComponent )

        {

        delete iRingtoneComponent;

        iRingtoneComponent = NULL;

        }

    //Delete iDescComponent

    if( iDescComponent )

        {

        delete iDescComponent;

        iDescComponent = NULL;

        }

    //Delete iPlaceComponent

    if( iPlaceComponent )

        {

        delete iPlaceComponent;

        iPlaceComponent = NULL;

        }

    //Delete iClientLibrary

    if( iClientLibrary )

        {

        delete iClientLibrary;

        iClientLibrary = NULL;

        }

    //Delete wait launcher

    if( iWaitDialogLauncher )

        {

        delete iWaitDialogLauncher;

        iWaitDialogLauncher = NULL;

        }

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

    }

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

// CEvtMgmtUiEditorCmdHandler ::ConstructL()

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

//

void CEvtMgmtUiEditorCmdHandler::ConstructL()

    {   

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

    CActiveScheduler::Add( this );

    iEvtIdArray.Append(iEvent.EventId());

    // Set the Command Handler as the observer

    iEventEngine.SetObserver( this );

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

    }

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

// CEvtMgmtUiEditorCmdHandler ::CEvtMgmtUiEditorCmdHandler()

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

//

CEvtMgmtUiEditorCmdHandler::CEvtMgmtUiEditorCmdHandler( 

                        CEvtEvent&                      aEvent, 

                        MEvtMgmtUiEditorObserver&       aEditorObserver,

                        CEvtMgmtUiEngine&               aEventEngine )

    :CActive( EPriorityStandard ), 

     iEvent( aEvent ), 

     iEditorObserver( aEditorObserver ),

     iEventEngine( aEventEngine )

    {

    iWaitDialogLauncher = NULL;

    }

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

// CEvtMgmtUiEditorCmdHandler ::HandleEditorCmdL()

// It will handle all editor commands

// @param[in] aCommand - command id of the command to be handled.

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

//

void CEvtMgmtUiEditorCmdHandler::HandleEditorCmdL( TInt     aCommand )

    {

    EVTUIDEBUG("+ CEvtMgmtUiEditorCmdHandler::HandleEditorCmdL()" );

    // return if already Active

    if ( IsActive() || (iWaitDialogLauncher && iWaitDialogLauncher->IsActive()) )

        {

        return;

        }

    //set state of the state-machine.

    iState = aCommand;

    switch( aCommand )

        {     

        case EEvtEditorCmdNavigateToPlace:  

        case EEvtEditorCmdShowOnMap:  

        case EEvtEditorCmdAddDescNew:

        case EEvtEditorCmdEditDesc:

        case EEvtEditorCmdAddDescFromExisting:  

        case EEvtEditorCmdAssignTone:  

        case EEvtEditorCmdActivate:

        case EEvtEditorCmdSaveDraft:

        case EEvtEditorCmdDelete:  

            {           

            // Schedule a request onto yourself for completion

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

            SetActive();                                  

            break;

            }

        case EEvtMgmtUiEventUiPosSettings:

            {

            if( !iClientLibrary )

                iClientLibrary  = CLocSettingsUiClient::NewL();  

            iClientLibrary->LaunchPosSettingsAsEmbeddedAppL( iStatus );

            SetActive();

            break;

            }

        case EEvtEditorCmdSetPlace: // set place

            {

            SetActive();

            iStatus = KRequestPending;

            if(!iPlaceComponent)    

                iPlaceComponent = CEvtMgmtUiPlaceComponent::NewL( iEvent.Place(), iEvent.Location() );

            iPlaceComponent->DisplayPlacePopupDlg( iStatus );                

            break;

            }

        default:

            {

            EVTUIDEBUG("Error CEvtMgmtUiEditorCmdHandler::HandleEditorCmdL()" );

            }

        }

    EVTUIDEBUG("- CEvtMgmtUiEditorCmdHandler::HandleEditorCmdL()" );

    }

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

// CEvtMgmtUiEditorCmdHandler ::StopWaitDialogL()

// Stop the Wait Loop

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

//

void CEvtMgmtUiEditorCmdHandler::StopWaitDialogL()

    {

    // Handle the notification completion event. Stop the Wait Dialog

    if( iWaitDialogLauncher )

        {

        iWaitDialogLauncher->StopWaitDialogL();  

        }

    }

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

// CEvtMgmtUiEditorCmdHandler ::StartWaitDialogL()

// Launch the Wait Loop

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

//

void CEvtMgmtUiEditorCmdHandler::StartWaitDialogL(TInt aResourceId)

    {

    // Create the wait loop if it doesn't exit

    if( !iWaitDialogLauncher )

        {

        // Create the Wait loop

        iWaitDialogLauncher = CEvtMgmtUiWaitDialogLauncher::NewL(); 

        iWaitDialogLauncher->SetObserver( this ); 

        // No Cancel operation

        iWaitDialogLauncher->AllowUserToCancel( ETrue );                                          

        }

    if( iWaitDialogLauncher )

        {

        // Set the CBA accordingly

        iWaitDialogLauncher->SetTextL( aResourceId );

        // Finally start the Wait Dialog in Synchronous format

        iWaitDialogLauncher->StartWaitDialogL();                                           

        } 

    }

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

// CEvtMgmtUiEditorCmdHandler ::HandleDialogDismissed()

// Derived from CActive

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

//

void CEvtMgmtUiEditorCmdHandler::HandleDialogDismissed( TInt aButtonId )

    {

    EVTUIDEBUG("+ CEvtMgmtUiEditorCmdHandler::HandleDialogDismissed()");

    if( EEikBidCancel == aButtonId )

        {

        EVTUIDEBUG("wait dialog is dismissed manually" );

        //Cancel Outstanding Request

        iEventEngine.CancelRequest();  

        }

    EVTUIDEBUG("- CEvtMgmtUiEditorCmdHandler::HandleDialogDismissed()");

    }

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

// CEvtMgmtUiEditorCmdHandler ::RunError()

// Derived from CActive

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

//

TInt CEvtMgmtUiEditorCmdHandler::RunError( TInt aError )

    {

    EVTUIDEBUG("+ CEvtMgmtUiEditorCmdHandler::RunError()" );

    if( aError != KErrNone )

        {

        if( iWaitDialogLauncher )

            {

            TRAP_IGNORE(iWaitDialogLauncher->StopWaitDialogL());

            }

        EVTUIDEBUG1("Error = %d", aError );   

        }

    EVTUIDEBUG("- CEvtMgmtUiEditorCmdHandler::RunError()" );

    return aError;

    }

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

// CEvtMgmtUiEditorCmdHandler ::RunL()

// Derived from CActive

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

//

void CEvtMgmtUiEditorCmdHandler::RunL()

    {    

    TInt error = iStatus.Int();    

    EVTUIDEBUG1("+ CEvtMgmtUiEditorCmdHandler::RunL() Error = %d", error );    

    //if no error, handle the command

    switch( iState )

        {

        case EEvtEditorCmdActivate:           

        case EEvtEditorCmdSaveDraft:

            {

            StartWaitDialogL( R_LOCEV_NOTE_SAVING_EVENT );

            if( iEvent.EventId() ) //if present, modify event

                {

                iEventEngine.ModifyEventL(iEvent, iEventAttributeMask );                

                }

            else 

                {

                iEventEngine.AddEventL( iEvent );

                }

            return;

            }

        case EEvtEditorCmdDelete:

            {

            StartWaitDialogL( R_LOCEV_NOTE_SINGLEEVT_DELETE );

            iEventEngine.DeleteEventsL( &iEvtIdArray );

            return;    

            }

        case EEvtEditorCmdSetPlace:

            {  

            if( error == KErrCancel ) 

                {

                iEditorObserver.NotifyEditorL( iState,KErrCancel );

                if( iPlaceComponent )

                   {

                   delete iPlaceComponent;

                   iPlaceComponent = NULL;

                   }

                return;

                }

            //handle 'set place' command 

            HandleSetPlaceCommandL();

            break;

            }

        case EEvtMgmtUiEventUiPosSettings:

            {

            if(iClientLibrary)

                {

                delete iClientLibrary;

                iClientLibrary = NULL;

                }

            break;

            }

        case EEvtEditorCmdNavigateToPlace:

            {

            HandleNavigateToPlaceCommandL();

            break;

            }

        case EEvtEditorCmdShowOnMap:  

            {

            HandleShowOnMapCommandL();

            break;

            }

        case EEvtEditorCmdAddDescNew:

        case EEvtEditorCmdEditDesc:

        case EEvtEditorCmdAddDescFromExisting:  

            {

            error = HandleDescCommandsL( iState );

            break;

            }

        case EEvtEditorCmdAssignTone:

            {

            error = HandleAssignToneCommandL();

            break;

            }

        default:

            {

            EVTUIDEBUG("Error in CEvtMgmtUiEditorCmdHandler::HandleEditorCmdL()" );

            }  

        }

    //Notify editor status of the operation in order to do any UI specific updates

    iEditorObserver.NotifyEditorL(iState,error);

    EVTUIDEBUG("- CEvtMgmtUiEditorCmdHandler::RunL()" );

    }

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

// CEvtMgmtUiEditorCmdHandler ::DoCancel()

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

//

void CEvtMgmtUiEditorCmdHandler::DoCancel()

    {    

    switch( iState )

        {

        case EEvtEditorCmdActivate:           

        case EEvtEditorCmdSaveDraft:

        case EEvtEditorCmdDelete:

            {

            iEventEngine.CancelRequest();  

            return; 

            }

        case EEvtEditorCmdSetPlace:

            {  

            if( iPlaceComponent )

               {

               delete iPlaceComponent;

               iPlaceComponent = NULL;

               }

            break;

            }

        case EEvtMgmtUiEventUiPosSettings:

            {

            if( iClientLibrary )

               {

               iClientLibrary->ClosePosSettings();

               delete iClientLibrary;

               iClientLibrary = NULL;

               }

            break;

            }

        case EEvtEditorCmdNavigateToPlace:

        case EEvtEditorCmdShowOnMap:  

            {

            if( iMapAdapter )

               {

               delete iMapAdapter;

               iMapAdapter = NULL;

               }

            break;

            }

        case EEvtEditorCmdAddDescNew:

        case EEvtEditorCmdEditDesc:

        case EEvtEditorCmdAddDescFromExisting:  

            {

            if( iDescComponent )

               {

               delete iDescComponent;

               iDescComponent = NULL;

               }

            break;

            }

        case EEvtEditorCmdAssignTone:

            {

            if( iRingtoneComponent )

               {

               delete iRingtoneComponent;

               iRingtoneComponent = NULL;

               }

            break;

            }

        default:

            {

            break;

            }  

        }

    }

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

// CEvtMgmtUiEditorCmdHandler::DisplayConfirmationQueryDlg()

// It shows confirmation query dialog

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

//

TBool CEvtMgmtUiEditorCmdHandler::DisplayConfirmationQueryDlgL( TInt aResourceId )

    {

    EVTUIDEBUG("+ CEvtMgmtUiEditorCmdHandler::DisplayConfirmationQueryDlgL()" );

    HBufC* msg = StringLoader::LoadLC( aResourceId );

    TBool response= EFalse;

    CAknQueryDialog* confirmationQuery = CAknQueryDialog::NewL();     

    response = confirmationQuery->ExecuteLD( R_EVTUI_CONFIRMATION_QUERY, *msg );         

    CleanupStack::PopAndDestroy(msg);

    EVTUIDEBUG("- CEvtMgmtUiEditorCmdHandler::DisplayConfirmationQueryDlgL()" );

    return response;

    }

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

//  CEvtMgmtUiEditorCmdHandler::HandleSetPlaceCommandL

//  It will handle'set place' operation.

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

//

void CEvtMgmtUiEditorCmdHandler::HandleSetPlaceCommandL()

    {

    EVTUIDEBUG("= Details recieved from Set Place component" ); 

    EVTUIDEBUG1("TriggerId = %d", iEvent.EventId() );

	TPtrC placePtr = iPlaceComponent->Place();

    EVTUIDEBUG1("Place = %S", &placePtr );

    EVTUIDEBUG1("Lat = %f", iPlaceComponent->TriggerLocation().Latitude() );

    EVTUIDEBUG1("Long = %f", iPlaceComponent->TriggerLocation().Longitude() );

    EVTUIDEBUG("= Finish Details recieved from Set Place component" );

    //if place is already set

    if( iEvent.Place().Compare(KNullDesC ) != 0 )

        {

        //display confirmation message to replace old details

        if( DisplayConfirmationQueryDlgL( R_EVTUI_EDITOR_CONFIRM_PLACESAVE ) )

           { 

           //if yes, then replace

           iEvent.SetPlaceL( iPlaceComponent->Place() );  

           iEventAttributeMask  = iEventAttributeMask | CEvtMgmtUiEngine::EEvtEventAttributePlace;

           }       

        }

    else //if place is not already set, then set it

        {

        iEvent.SetPlaceL( iPlaceComponent->Place() );   

        iEventAttributeMask  = iEventAttributeMask | CEvtMgmtUiEngine::EEvtEventAttributePlace;

        }

    }

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

//  CEvtMgmtUiEditorCmdHandler::HandleDescCommandsL