/*

* 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 controller

*

*/

#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 "calencontroller.h"            // CCalenController

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

#include "calenservicesimpl.h"          // MCalenServices implementation

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

#include "calencustomisationmanager.h"  // Customisation Manager

#include "calennotificationhandler.h"

#include "calennotifier.h"

#include "hb_calencommands.hrh"

#include "calendarui_debug.h"           // Debug macros

#include "calenstatemachine.h"

#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

const TInt KCustomCommandRangeStart     = ECalenLastCommand; 

const TInt KNumberOfCommandsPerServices = 100;

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

// 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

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

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

//

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::InstanceL

// Returns a pointer to the single instance of the Calendar Controller.

// Leaves with KErrNotReady if the controller has not already been created

// using NewL.  A leave here means that the Calendar application is not running

// but someone is trying to use the services API.

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

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

//

CCalenController* CCalenController::InstanceL()

    {

    OstTraceFunctionEntry0( CCALENCONTROLLER_INSTANCEL_ENTRY );

    CCalenController* self = NULL;

    TAny* tlsPtr = Dll::Tls();

    // Check Thread local storage

    if( !tlsPtr )

        {

        // The Controller has not yet been constructed.  Someone is probably

        // trying to use the Services API outside of a customisation

        // plugin.  We don't allow that.

        User::Leave( KErrNotReady );

        }

    else

        {

        self = static_cast<CCalenController*>( tlsPtr );

        }

    ++self->iRefCount;

    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.

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

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

//

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

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

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

//

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 );

    }

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

// CCalenController::~CCalenController

// Private destructor, called from Release() when reference count is 0.

// Frees all resources.

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

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

//

CCalenController::~CCalenController()

    {

    OstTraceFunctionEntry0( DUP1_CCALENCONTROLLER_CCALENCONTROLLER_ENTRY );

    if(iStateMachine) {

    	delete iStateMachine;

    	iStateMachine = NULL;

    }

    if ( iServices )

        {

        iServices->Release();

        }

    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;

 	   }

    if( iNotifier )

		{

    	delete iNotifier;

    	iNotifier = NULL;

		}

    if( iViewManager )

		{

    	delete iViewManager;

    	iViewManager = NULL;

		}

    if( iCustomisationManager )

		{

    	delete iCustomisationManager;

    	iCustomisationManager = NULL;

		}

    if (mAgendaUtil) {

        delete mAgendaUtil;

        mAgendaUtil = 0;

    }

    Dll::SetTls( NULL );

    OstTraceFunctionExit0( DUP1_CCALENCONTROLLER_CCALENCONTROLLER_EXIT );

    }

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

// CCalenController::IssueCommmandL

// Adds the passed command to the comand queue. Commands are handled

// asynchronously in HandleCommandL

// Returns EFalse if the passed command is not in the issuers command range

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

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

//

TBool CCalenController::IssueCommandL( TInt aCommand )

    {

    OstTraceFunctionEntry0( CCALENCONTROLLER_ISSUECOMMANDL_ENTRY );

    TCalenCommand cmd;

    cmd.SetCommandAndContextL( aCommand ,context());

    TBool ret = iStateMachine->HandleCommandL( cmd );

    OstTraceFunctionExit0( CCALENCONTROLLER_ISSUECOMMANDL_EXIT );

    return ret;

    }

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

// CCalenController::Services

// Returns the services

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

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

//

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

// Passes the notification to the Calendar Notifier.  The notification will

// then be broadcast to all observers

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

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

//

void CCalenController::BroadcastNotification( TCalenNotification aNotification )

    {

    OstTraceFunctionEntry0( CCALENCONTROLLER_BROADCASTNOTIFICATION_ENTRY );

    iNotifier->BroadcastNotification( aNotification );

    OstTraceFunctionExit0( CCALENCONTROLLER_BROADCASTNOTIFICATION_EXIT );

    }

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

// CCCalenController::RegisterForNotificationsL

// Registers the passed notification handler with the Calendar Notifier

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

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

//

void CCalenController::RegisterForNotificationsL( MCalenNotificationHandler* aHandler,

                                                            TCalenNotification aNotification )

    {

    OstTraceFunctionEntry0( CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_ENTRY );

    iNotifier->RegisterForNotificationsL( aHandler, aNotification );

    OstTraceFunctionExit0( CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_EXIT );

    }

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

// CCCalenController::RegisterForNotificationsL

// Registers the passed notification handler with the Calendar Notifier

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

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

//

void CCalenController::RegisterForNotificationsL( MCalenNotificationHandler* aHandler,

                                                            RArray<TCalenNotification>& aNotifications )

    {

    OstTraceFunctionEntry0( DUP1_CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_ENTRY );

    iNotifier->RegisterForNotificationsL( aHandler, aNotifications );

    OstTraceFunctionExit0( DUP1_CCALENCONTROLLER_REGISTERFORNOTIFICATIONSL_EXIT );

    }

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

// CCCalenController::CancelNotifications

// Removes the passed handler from the notifier.

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

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

//

void CCalenController::CancelNotifications( MCalenNotificationHandler* aHandler )

    {

    OstTraceFunctionEntry0( CCALENCONTROLLER_CANCELNOTIFICATIONS_ENTRY );

    iNotifier->CancelNotifications( aHandler );

    OstTraceFunctionExit0( CCALENCONTROLLER_CANCELNOTIFICATIONS_EXIT );

    }

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

// CCCalenController::GetCommandHandlerL

// Searches for a command handler for a particular command.  Customisations

// are searched first.  If no customisation wants to handle the command it is

// handled by the view manager or the action uis

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

MCalenCommandHandler* CCalenController::GetCommandHandlerL( TInt aCommand )

    {

    OstTraceFunctionEntry0( CCALENCONTROLLER_GETCOMMANDHANDLERL_ENTRY );

    MCalenCommandHandler* handler( NULL );

    // Stop non-published commands from being customised

    if ( aCommand != ECalenShowSettings

        && aCommand != ECalenSwitchView )

        {

        // See if a plugin wants the command

        handler = iCustomisationManager->GetCommandHandlerL( aCommand );

        }

    // See if the view manager wants the command

    if ( !handler )

        {

        if (   aCommand >= ECalenViewCommandBase

            && aCommand < ECalenEditCommandBase )

            {

            handler = iViewManager;

            }

     	else if( aCommand >= ECalenMissedAlarmCommandBase

      		&& aCommand < ECalenLastCommand )

	    	{

	    	//handler = iAlarmManager;

	    	} 

        else 

            {

            handler = iActionUi->GetCommandHandlerL( aCommand );

            }

        }

    // No command handler is an error  

    OstTraceFunctionExit0( CCALENCONTROLLER_GETCOMMANDHANDLERL_EXIT );

    // return the handler

    return handler;

    }

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

// CCCalenController::NewServicesL

// Factory function for creating new MCalenServices objects

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