/*

* Copyright (c) 2007-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:   Calendar state machine

*

*/

// includes

#include "calendarui_debug.h"           // Debug macros

#include "calenstate.h"                 // Calendar States

#include "calencontroller.h"

#include "calenstatemachine.h"

#include "calennotifier.h"

#include "calenasynccallback.h"

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

// CCalenState::CCalenState

// C++ constructor

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

CCalenState::CCalenState( CCalenController& aController,RHashSet<TCalenNotification>&  aOutstandingNotifications )

    : iController( aController ),

      iOutstandingNotifications( aOutstandingNotifications ),

      iPreviousState( CCalenStateMachine::ECalenIdleState )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenState::ConstructL

// second phase construction

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

void CCalenState::BaseConstructL()

    {

    TRACE_ENTRY_POINT;

    TCalenCommand command;

    MCalenCommandHandler* handler( NULL );

    iCallBackPackage = new( ELeave ) CCalenCallbackPackage( this, command, handler );

    TRACE_EXIT_POINT;

    }

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

// CCalenState::~CCalenState

// Destructor

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

CCalenState::~CCalenState()

    {

    TRACE_ENTRY_POINT;

    delete iCallBackPackage;

    iCallBackPackage = NULL;

    delete iCmdCallback;

    TRACE_EXIT_POINT;

    }

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

// CCalenState::RequestCallback

// Request a callback

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

void CCalenState::RequestCallbackL( MCalenCommandHandler* aCommandHandler, const TCalenCommand& aCommand )

    {

    TRACE_ENTRY_POINT;

    iCallBackPackage->SetCommandHandler(this, aCommand, aCommandHandler);

    if( !iCmdCallback )

        {

        TCallBack callback( CommandCallback, iCallBackPackage );

        iCmdCallback = CCalenAsyncCallBack::NewL( callback, CActive::EPriorityHigh , iController );

       }

    TCallBack callback( CommandCallback, iCallBackPackage );

    iCmdCallback->Cancel();

    iCmdCallback->Set( callback );

    iCmdCallback->CallBack();

    TRACE_EXIT_POINT;

    }

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

// CCalenState::CommandCallback

// Static callback function

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

TInt CCalenState::CommandCallback( TAny* aCommandStruct )

    {

    TRACE_ENTRY_POINT;

    TBool continueCommand(EFalse);

    CCalenCallbackPackage* package = static_cast<CCalenCallbackPackage*>( aCommandStruct );

    continueCommand = package->HandleCallBack();

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CCalenState::HandleNotificationL

// Default behaviour for notification handling is to go back to previous state.

// Concrete states would be expected to check the notification is related

// to the command issued.

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

void CCalenState::HandleNotificationL(const TCalenNotification& aNotification,

                                      CCalenStateMachine& aStateMachine )

    {

    TRACE_ENTRY_POINT;

    switch( aNotification )

        {

        case ECalenNotifyAppBackgrounded:

        	{

        	CCalenStateMachine::TCalenStateIndex cachedState = aStateMachine.GetCurrentState();

        	if(cachedState != CCalenStateMachine::ECalenMapState) // Never send calendar to background state in MapState as maps will 

        	                                                        // launched in cahin mode not in stand alone mode

        	    {

                aStateMachine.SetCurrentState(CCalenStateMachine::ECalenBackgroundState);

                aStateMachine.SetCurrentPreviousState(cachedState);

                iOutstandingNotifications.InsertL(aNotification);

                aStateMachine.ActivateCurrentStateL();

        	    }

        	}

            break;

        default:

            iController.Notifier().BroadcastApprovedNotification( aNotification );

            break;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenState::PreviousState

// C++ constructor

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

CCalenStateMachine::TCalenStateIndex CCalenState::PreviousState()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iPreviousState;

    }

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

// CCalenState::SetPreviousState

// Sets previous state.

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

void CCalenState::SetPreviousState(const CCalenStateMachine::TCalenStateIndex& aPreviousState )

    {

    TRACE_ENTRY_POINT;

    iPreviousState = aPreviousState;

    TRACE_EXIT_POINT;

    }

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

// CCalenState::CommandExecuting

// From CCalenState

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

void CCalenState::CommandExecuting()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }  

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

// CCalenState::CCalenCallbackPackage::CCalenCallbackPackage

// C++ constructor

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

CCalenState::CCalenCallbackPackage::CCalenCallbackPackage( CCalenState* aSelf,

                        TCalenCommand aCommand,  MCalenCommandHandler* aCommandHandler)

    : iSelf( aSelf ), iCommand( aCommand ), iCommandHandler( aCommandHandler )                   

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenState::CCalenCallbackPackage::HandleCallBack

// Handles a callback

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

TBool CCalenState::CCalenCallbackPackage::HandleCallBack()

    {

    TRACE_ENTRY_POINT;

    TBool continueCommand(EFalse);

    iSelf->CommandExecuting();

    PIM_TRAPD_HANDLE ( continueCommand = iCommandHandler->HandleCommandL( iCommand ) );

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CCalenState::CCalenCallbackPackage::SetCommandHandler

// Sets the command handler and command

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

void CCalenState::CCalenCallbackPackage::SetCommandHandler(CCalenState* aSelf,

                        TCalenCommand aCommand,  MCalenCommandHandler* aCommandHandler)

    {

    TRACE_ENTRY_POINT;

    iSelf = aSelf;

    iCommand = aCommand;

    iCommandHandler = aCommandHandler; 

    TRACE_EXIT_POINT;    

    }

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

// CCalenState::HandleStateActivationL

// Default behavior when state is activated. Check and issue any outstanding

// notifications

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

void CCalenState::HandleStateActivationL(CCalenStateMachine& /*aStateMachine*/)

	{

    TRACE_ENTRY_POINT;

    // Can only issue one of the following Notifications

    // ECalenNotifySettingsChanged or 

    // ECalenNotifySystemLocaleChanged or

    // ECalenNotifySettingsClosed

    if(iOutstandingNotifications.Find(ECalenNotifySettingsChanged))

        {

        iOutstandingNotifications.Remove(ECalenNotifySystemLocaleChanged);

        iOutstandingNotifications.Remove(ECalenNotifySettingsClosed);

        }

    else if(iOutstandingNotifications.Find(ECalenNotifySystemLocaleChanged))

        {

        iOutstandingNotifications.Remove(ECalenNotifySettingsClosed);

        }

    THashSetIter<TCalenNotification> iterator(iOutstandingNotifications);

    const TCalenNotification* notification = iterator.Next();

    while(notification)

        {

        iController.Notifier().BroadcastApprovedNotification( *notification );

        notification = iterator.Next();

        }

    iOutstandingNotifications.Close();

    TRACE_EXIT_POINT;

	}

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

// CCalenState::SetCurrentState

// Sets the current state

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

void CCalenState::SetCurrentState(CCalenStateMachine& aStateMachine,

								  const CCalenStateMachine::TCalenStateIndex& aState )	

	{

    TRACE_ENTRY_POINT;

    aStateMachine.SetCurrentState(aState);

    TRACE_EXIT_POINT;	

	}

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

// CCalenState::GetCurrentState

// Gets the current state

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

CCalenStateMachine::TCalenStateIndex CCalenState::GetCurrentState(

											CCalenStateMachine& aStateMachine)

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	return aStateMachine.GetCurrentState();

	}

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

// CCalenState::SetPreviousState

// Sets the previous state through state machine

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

void CCalenState::SetCurrentPreviousState(CCalenStateMachine& aStateMachine, 

								const CCalenStateMachine::TCalenStateIndex& aState)

	{

	TRACE_ENTRY_POINT;

	aStateMachine.SetCurrentPreviousState(aState);

	TRACE_EXIT_POINT;

	}

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

// CCalenState::ActivateCurrentStateL

// Activate current state

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

void CCalenState::ActivateCurrentStateL(CCalenStateMachine& aStateMachine)

	{

    TRACE_ENTRY_POINT;

    aStateMachine.ActivateCurrentStateL();

    TRACE_EXIT_POINT;	

	}

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

// CCalenState::CancelPreviousCmd

// Cancel the previous command

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

void CCalenState::CancelPreviousCmd(CCalenStateMachine& aStateMachine)

	{

	TRACE_ENTRY_POINT;

	aStateMachine.CancelPreviousCmd();

	TRACE_EXIT_POINT;

	}

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

// CCalenState::CancelExecutingCmd

// Cancels executing command

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

void CCalenState::CancelExecutingCmd()

	{

    TRACE_ENTRY_POINT;

	if(iCmdCallback)

		{

		iCmdCallback->Cancel();

		}

    TRACE_EXIT_POINT;	

	}	

// End of file