#include <e32std.h>

#include <hbmainwindow.h>

#include <hbwidget.h>

#include <hbinstance.h>

#include <hbapplication.h> //Activity Manager

#include <xqserviceutil.h> // service utils

// User includes

#include "calenviewmanager.h"           // Responsible for all view activations        

#include "calenactionui.h"              // Default command handling

#include "calennotificationhandler.h"

#include "calennotifier.h"

#include "hb_calencommands.hrh"

#include "calendarui_debug.h"           // Debug macros

#include "calenservicesimpl.h"          // Calendar service implementation

#include "CalenUid.h"

#include "calencontextimpl.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "calencontrollerTraces.h"

#endif

// Constants

// CCalenController::CCalenController

// Constructor

// (other items were commented in a header).

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

//

CCalenController::CCalenController()

{

    OstTraceFunctionEntry0( CCALENCONTROLLER_CCALENCONTROLLER_ENTRY );

	// Check the Application Startup reason, set iIsFromServiceFrmWrk if application

	// is started by service framework, false otherwise

    /*Hb::ActivationReasonService == qobject_cast<HbApplication*>(qApp)->activateReason() ? 

        iIsFromServiceFrmWrk = true:

        iIsFromServiceFrmWrk = false; */

    // Check if calendar is launched thru XQService framework

    iIsFromServiceFrmWrk = XQServiceUtil::isService(); // Since activateReason 

    //of hbapplication is not returning right value if the activity is started 

    //as services so using the above line temporarily untill a fix is available in 

    // hbappliacation. Need to remove this line after the fix is available for hbapplcation

    iNextServicesCommandBase = KCustomCommandRangeStart;

    iRefCount = 0;

    mAgendaUtil = 0;

    OstTraceFunctionExit0( CCALENCONTROLLER_CCALENCONTROLLER_EXIT );

}

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

// CCalenController::constuctController

// Construct the controller completely

void CCalenController::constructController()

{

	OstTraceFunctionEntry0( CCALENCONTROLLER_CONSTRUCTCONTROLLER_ENTRY );

	// Store the pointer in tls, also avoid multiple creations

	checkMultipleCreation();

	// Get an instance of AgendaUtil interface class

	// This will take care of 

	mAgendaUtil = new AgendaUtil();

	iStateMachine = CCalenStateMachine::NewL( *this );

	// Create the notifier.

	iNotifier = new( ELeave )CalenNotifier( *iStateMachine );

	// Construct the context

	mContext = new CalenContextImpl(iNotifier);

	// Set the default context.Once will start use of calencmdlinelauncher,

	// Then need to remove this function

	SetDefaultContext();

	RArray<TCalenNotification> notificationArray;

	// Complete construction of the notifier and register the

	// global data for notifications

	iNotifier->ConstructL();

	// Create the services

	iServices = CalenServicesImpl::NewL();

	// Create the customisation manager, and register for 

	// notifications

	iCustomisationManager = CCalenCustomisationManager::NewL( *this,

	                                                          *iServices );

	// Create the view manager, and register for notifications

	iViewManager = new CalenViewManager(*this);

	iViewManager->SecondPhaseConstruction();

	hbInstance->allMainWindows().first()->show();

	// Create the action uis.

	iActionUi = CCalenActionUi::NewL( *this );

	notificationArray.Append(ECalenNotifySettingsChanged);

	notificationArray.Append(ECalenNotifyCheckPluginUnloading);

	notificationArray.Append(ECalenNotifyEComRegistryChanged);

	notificationArray.Append(ECalenNotifySystemLanguageChanged);

	RegisterForNotificationsL( iCustomisationManager,notificationArray);

	notificationArray.Reset();

	notificationArray.Append(ECalenNotifyViewPopulationComplete);

	notificationArray.Append(ECalenNotifyExternalDatabaseChanged);

	notificationArray.Append(ECalenNotifyMultipleEntriesDeleted);

	notificationArray.Append(ECalenNotifyDialogClosed);

	notificationArray.Append(ECalenNotifyEntrySaved);

	notificationArray.Append(ECalenNotifyEntryDeleted);

	notificationArray.Append(ECalenNotifyInstanceDeleted);

	notificationArray.Append(ECalenNotifySystemLocaleChanged);

	notificationArray.Append(ECalenNotifySystemLanguageChanged);

	notificationArray.Append(ECalenNotifySystemTimeChanged);

	notificationArray.Append(ECalenNotifyEntryClosed);

	notificationArray.Append(ECalenNotifySettingsClosed);

	RegisterForNotificationsL( iViewManager, notificationArray );

	notificationArray.Reset();  

	notificationArray.Close();

	OstTraceFunctionExit0( CCALENCONTROLLER_CONSTRUCTCONTROLLER_EXIT );

}

void CCalenController::checkMultipleCreation()

{

	OstTraceFunctionEntry0( CCALENCONTROLLER_CHECKMULTIPLECREATION_ENTRY );

	TAny* tlsPtr = Dll::Tls();

	// Check Thread local storage

	if( !tlsPtr )

		{

		// Store a self pointer in TLS

		User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( this ) ) );

		// Increment ref count right away. If we don't do it here, and someone

		// calls Controller::InstanceL in ConstructL and then ConstructL

		// leaves, we will double delete the controller.

		++this->iRefCount;

		}

	else

		{

		// An instance of the controller exists already.

		// This function should only have been called once, by CCalenAppUi

		User::Leave( KErrAlreadyExists );

		}	

	OstTraceFunctionExit0( CCALENCONTROLLER_CHECKMULTIPLECREATION_EXIT );

}

CCalenController* CCalenController::InstanceL()

    OstTraceFunctionEntry0( CCALENCONTROLLER_INSTANCEL_ENTRY );

    OstTraceFunctionExit0( CCALENCONTROLLER_INSTANCEL_EXIT );

    return self;    

// CCalenController::ReleaseCustomisations

// Releases any plugins by deleting the customisation manager

// should only be called on exiting by the application.

void CCalenController::ReleaseCustomisations()

    OstTraceFunctionEntry0( CCALENCONTROLLER_RELEASECUSTOMISATIONS_ENTRY );

    delete iCustomisationManager;

    iCustomisationManager = NULL;

    OstTraceFunctionExit0( CCALENCONTROLLER_RELEASECUSTOMISATIONS_EXIT );

// CCalenController::Release

// Decrement the reference count of this singleton.

// When the reference count is 0, the controller will self delete and free

// all resources

void CCalenController::Release()

    OstTraceFunctionEntry0( CCALENCONTROLLER_RELEASE_ENTRY );

    --iRefCount;

    // The controller owns its own instance of the services, therefore the

    // reference count will be one, immediatley before deletion.

    if (iRefCount == 1)

        {

        delete this;

        }

    OstTraceFunctionExit0( CCALENCONTROLLER_RELEASE_EXIT );

    {

    OstTraceFunctionEntry0( DUP1_CCALENCONTROLLER_CCALENCONTROLLER_ENTRY );

    if(iStateMachine) {

    	delete iStateMachine;

    	iStateMachine = NULL;

    }

    if( mContext )

		{

		delete mContext;

		mContext = NULL;

		}

    // iActionUi has to be deleted before iNotifier

    // as the unregistering of the notifications has to be done

    if( iActionUi )

 	   {

 	   delete iActionUi;

 	   iActionUi = NULL;

 	   }

		{

    	delete iNotifier;

    	iNotifier = NULL;

		}

    if( iViewManager )

		{

    	delete iViewManager;

    	iViewManager = NULL;

		}

    if( iCustomisationManager )

		{

    	delete iCustomisationManager;

    	iCustomisationManager = NULL;

		}

    if (mAgendaUtil) {

        delete mAgendaUtil;

        mAgendaUtil = 0;

    }

    OstTraceFunctionExit0( DUP1_CCALENCONTROLLER_CCALENCONTROLLER_EXIT );

TBool CCalenController::IssueCommandL( TInt aCommand )

    OstTraceFunctionEntry0( CCALENCONTROLLER_ISSUECOMMANDL_ENTRY );

    TCalenCommand cmd;

    cmd.SetCommandAndContextL( aCommand ,context());

    OstTraceFunctionExit0( CCALENCONTROLLER_ISSUECOMMANDL_EXIT );

// CCalenController::Services

// Returns the services

MCalenServices& CCalenController::Services()

    OstTraceFunctionEntry0( CCALENCONTROLLER_SERVICES_ENTRY );

    OstTraceFunctionExit0( CCALENCONTROLLER_SERVICES_EXIT );

    return *iServices;

// CCalenController::ViewManager

// Returns a reference to the view manager

// (other items were commented in a header).

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

CalenViewManager& CCalenController::ViewManager()

    {

    OstTraceFunctionEntry0( CCALENCONTROLLER_VIEWMANAGER_ENTRY );

	OstTraceFunctionExit0( CCALENCONTROLLER_VIEWMANAGER_EXIT );

	return *iViewManager;

    }

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

// CCalenController::MainWindow

// Returns a reference to the MainWindow

// (other items were commented in a header).

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

HbMainWindow& CCalenController::MainWindow()

    {

    OstTraceFunctionEntry0( DUP1_CCALENCONTROLLER_MAINWINDOW_ENTRY );

    OstTraceFunctionExit0( DUP1_CCALENCONTROLLER_MAINWINDOW_EXIT );

    return *(hbInstance->allMainWindows().first());

    }    

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

// CCCalenController::BroadcastNotification

void CCalenController::BroadcastNotification( TCalenNotification aNotification )

    OstTraceFunctionEntry0( CCALENCONTROLLER_BROADCASTNOTIFICATION_ENTRY );

    OstTraceFunctionExit0( CCALENCONTROLLER_BROADCASTNOTIFICATION_EXIT );

// CCCalenController::RegisterForNotificationsL

void CCalenController::RegisterForNotificationsL( MCalenNotificationHandler* aHandler,

    OstTraceFunctionEntry0( CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_ENTRY );

    OstTraceFunctionExit0( CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_EXIT );

// CCCalenController::RegisterForNotificationsL

void CCalenController::RegisterForNotificationsL( MCalenNotificationHandler* aHandler,

    OstTraceFunctionEntry0( DUP1_CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_ENTRY );

    OstTraceFunctionExit0( DUP1_CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_EXIT );

// CCCalenController::CancelNotifications

void CCalenController::CancelNotifications( MCalenNotificationHandler* aHandler )

    OstTraceFunctionEntry0( CCALENCONTROLLER_CANCELNOTIFICATIONS_ENTRY );

    OstTraceFunctionExit0( CCALENCONTROLLER_CANCELNOTIFICATIONS_EXIT );

// CCCalenController::GetCommandHandlerL

    OstTraceFunctionEntry0( CCALENCONTROLLER_GETCOMMANDHANDLERL_ENTRY );

    if ( !handler )

        if (   aCommand >= ECalenViewCommandBase

     	else if( aCommand >= ECalenMissedAlarmCommandBase

      		&& aCommand < ECalenLastCommand )

	    	//handler = iAlarmManager;

            handler = iActionUi->GetCommandHandlerL( aCommand );

    OstTraceFunctionExit0( CCALENCONTROLLER_GETCOMMANDHANDLERL_EXIT );

    // return the handler

    return handler;

// CCCalenController::NewServicesL