/*

* Copyright (c) 2006,2007 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:  LBT Server Logic implementation

*

*/

#ifndef C_LBTSERVERLOGIC_H

#define C_LBTSERVERLOGIC_H

// INCLUDE FILES

#include "lbtserverlogicbase.h" // interface 

#include "lbtaoobserver.h"

#include "lbttriggeringsupervisionobserver.h" // stratergy observer

#include "lbtbackuprestoreobserver.h" // For Backup and Restore observer

#include "lbtstrategytriggeringsystemstatus.h"

#include "lbtdeletesessiontriggers.h"

#include "lbtdeletesessiontriggerobserver.h"

#include "lbttriggerchangeobserver.h"

#include <lbttriggeringsystemmanagementsettings.h>

#include <lbttriggerchangeevent.h>

#include "lbtserverlogictriggerchangeobserver.h"

// FORWARD DECLARATIONS

class CLbtAOOperationBase;

class CLbtStratergyContainer;

class CLbtBackupRestoreListener;

class CLbtContainer;

class CLbtSettingsManager;

class CLbtNotificationMap;

class CLbtTriggerFireHandler;

class CLbtAppChangeHandler;

class CLbtCleanupHandler;

class CLbtSimChangeHandler;

/**

 * Class declaration for server logic implementation

 * 

 * @since S60 v4.0

 */

class CLbtServerLogic : public CLbtServerLogicBase, 

						public MLbtAOObserver,	// AOO operation observer

						public MLbtTriggeringSupervisionObserver,	// Stratergy observer

						public MLbtBackupRestoreObserver, // Backup and Restore observer

						public MLbtDeleteSessionTriggerObserver, // Delete session trigger observer

						public MLbtServerLogicTriggerChangeObserver

	{

	public:	

		/**

	     * Instantiates a new object of 

	     * CLbtServerLogic

	     *

	     * @return a pointer to an instance of 

	     * CLbtServerLogic

	     */

	    static CLbtServerLogic* NewL();

	    /**

	     * Destructor

	     *

	     */

	    ~CLbtServerLogic();

	public: // new functions

		/**

	     * Handles the servicing of a client request that 

	     * has been passed from server core session

	     *

	     * @aMessage The message containing the details of 

	     * the client request. The resposibility of completing

	     * the message is upto this object

	     *

	     */	     

	    void ServiceL(const RMessage2 &aMessage, TSubSessionType aType);

	    /**

	     * Loads stratergy plugin if not already loaded

	     * After loading it starts the supervision process.

	     * In case strategy is already loaded and there are no

	     * valid and enabled triggers in the system then strategy

	     * plugin is un-loaded.	     

	     */

	    void LoadOrUnloadStrategyPluginL();

	    /**

	     * Method is invoked when a session with a particular session

	     * id is being closed. One closure of this session all the 

	     * data pertaining to that session like session triggers,

	     * IPC messages has to be deleted

	     *

	     * @param aSessionId the id of the session which is being closed

	     */

	    void HandleSubSessionClosure(const TInt aSessionId, const CSession2* aSession);

	    /**

	     * Informs server logic implementation that all the sessions of

	     * client with a particular secure id has been closed. 

	     * 

	     * @param aSecureId the secure id of the client whose sessions

	     * are being closed

	     */

	    void HandleSessionClosureL(const TSecureId aSecureId);

	public: // from MLbtAOObserver

	    void HandleDeleteSessionTriggersClosureL(CLbtDeleteSessionTriggers*

	    												 aDeleteSessionTriggers);

	public: // from MLbtAOObserver

		void HandleOperationClosureL(CLbtAOOperationBase* aOperation, TInt aStatus);

	public: // from MLbtTriggeringSupervisionObserver

		void TriggerFiredL( CLbtGeoAreaBase::TGeoAreaType aAreaType,TLbtTriggerId aId, 

        					const TPositionInfo& aPosInfo );

		void SetTriggeringSupervisionDynamicInfo( 

   							const TLbtStrategySupervisionDynamicInfo& aStatus );

   		void GetTriggeringSupervisionSettings( 

 							TLbtStrategyTriggeringSupervisionSettings& aSettings );

	public: // from MLbtBackupRestoreObserver

		void HandleBackupRestoreOperationL(TBRState aState);

	public: // from	MLbtServerLogicTriggerChangeObserver

	    void HandleTriggersChange( RArray<TLbtTriggerId>& aTriggerIds,

                                   RArray<TUid>& aManagerUids,

                                   TLbtTriggerEventMask aEventMask  );

	private:

		/**

	     * Default C++ Constructor

	     *

	     */

	    CLbtServerLogic();

		/**

	     * 2nd phase constuctor for instantiating member variables

	     *

	     */

		void ConstructL();

	    /**

	     * Cancels all outstanding operation objects and destroys it

	     *

	     */

	    void CancelAllOperations();

	    /**

	     * Removes the meesage which matches the notification cancellation

	     * message received. The message in the notification map which matches 

	     * the session id and the service id of the received message is removed.

	     *

	     * @param aMessage the message to be removed from the message notification map

	     * @param aServiceId the service id for the cancellation of which this

	     *        message has been received

	     */

	    TInt RemoveFromNotificationMap( const RMessage2& aMessage, TInt aServiceId );

	    /**

	     * Checks if the received message is not a duplicate. If it is a duplicate

	     * request then the client message is completed with ELbtDuplicateRequest

	     *

	     * @param aMessage message to be inserted into the message notification map

	     * 

	     */

	    void InsertIntoNotificationMapL(const RMessage2& aMessage, TSubSessionType aType);

	    /**

	     * Makes capability checks and other Notify change related

	     * sanity checks on the message. Returns appropriate error

	     * code.

	     *

	     * @return KErrNone if trigger can be created and any one of the error 

	     * codes otherwise

	     */

	     TInt ValidateChangeNotification(const RMessage2& aMessage);

	     /**

	     * Makes capability checks for general LBT operation

	     * on the message. Returns appropriate error

	     * code.

	     *

	     * @return KErrNone if trigger can be created and any one of the error 

	     * codes otherwise

	     */

	     TInt ValidateGeneralOperation(const RMessage2& aMessage);

	    /**

	     * Makes capability checks and other create trigger related

	     * sanity checks on the message. Returns appropriate error

	     * code.

	     *

	     * @return KErrNone if trigger can be created and any one of the error 

	     * codes otherwise

	     */

		TInt ValidateCreateTriggerMessage(const RMessage2& aMessage);

		/**

	     * Makes capability checks and other get triggering setting related

	     * sanity checks on the message. Returns appropriate error

	     * code.

	     *

	     * @return KErrNone if trigger can be created and any one of the error 

	     * codes otherwise

	     */

		TInt ValidateGetTriggeringSysSetting(const RMessage2& aMessage);

		/**

	     * Makes capability checks and other set triggering setting related

	     * sanity checks on the message. Returns appropriate error

	     * code.

	     *

	     * @return KErrNone if trigger can be created and any one of the error 

	     * codes otherwise

	     */

		TInt ValidateSetTriggeringSetting(const RMessage2& aMessage);

		/**

	     * Makes capability checks and other Get triggering status related

	     * sanity checks on the message. Returns appropriate error

	     * code.

	     *

	     * @return KErrNone if trigger can be created and any one of the error 

	     * codes otherwise

	     */

		TInt ValidateGetTriggeringSysStatus(const RMessage2& aMessage);

		/**

		 * Checks if the provided service id is for a asynchronous

		 * notification request

		 * 

		 * @param[in] aServiceId the provided service id 

		 * @return ETrue if the provided service id is for a 

		 * asynchronous service request. EFalse otherwise		 

		 */

		TBool IsNotificationRequest(TInt aServiceId);

		/**

		 * Handles all asynchronous notifications except system settings 

		 * change notification. System settings change notification is valid

		 * only when management library changes the settings. Hence that 

		 * notification will be taken care by the active object handling 

		 * all management library requests

		 *

		 * @param aMessage the message to be removed from the message notification map

		 */

		void HandleNotificationOperationsL(CLbtAOOperationBase* aOperation, TInt aServiceId);

		/**

		 * Change the Settings used by the triggering engine.

		 * These settings values tweak the behaviour of triggering engine

		 * Only when management library changes the settings. 

		 *

		 * @param aSettings the new settings values for the triggering engine.

		 */

        void SetTriggeringSystemSettings( 

            TLbtTriggeringSystemManagementSettings& aSettings,

            TLbtManagementSettingsMask aSettingsMask );

        TInt GetTriggeringSystemSettings( const RMessage2& aMessage, TSubSessionType aClientType );

        void GetTriggeringSysStatus( TLbtTriggeringSystemStatus& aSystemStatus );

        void HandleSingleNotificationOperationsL(

            CLbtAOOperationBase* aOperation, 

            TInt aServiceId);

        void HandleMultipleNotificationOperationsL(

            CLbtAOOperationBase* aOperation, 

            TInt aServiceId);

        void SetNotificationEventType( 

            CLbtAOOperationBase* aOperation, 

            TLbtTriggerChangeEvent& aEvent );

       void NotifyTriggeringSystemSettingChange(TLbtManagementSettingsMask aSettingsMask );    

       void NotifyTriggeringSystemStatusChange();

	private: // Data

	    // Handle to RProperty server

	    RProperty    iProperty;

		// Array to maintain the list of ao operation running in server logic

		RPointerArray<CLbtAOOperationBase> iAOOArray;

		// Pointer to stratergy container

		CLbtStratergyContainer* iStratergyContainer;

		// Pointer to backup and restore event listener

		CLbtBackupRestoreListener* iBackupRestoreListener;

		// Pointer to location triggering container

		CLbtContainer* iContainer;

		// Pointer to the triggering settings manager

		CLbtSettingsManager* iSettingsManager;

		// Notification map to store all notification messages

		CLbtNotificationMap* iNotificationMap;

		// Trigger fire handler

		CLbtTriggerFireHandler* iFireHandler;

		// Array that maintains delete session triggers AO.

		RPointerArray<CLbtDeleteSessionTriggers> iDeleteSessionTriggersArray;

		// Strategy dynamic info structure.

		TLbtStrategySupervisionDynamicInfo iStrategyDynamicInfo;

		// Pointer to application change handler

		CLbtAppChangeHandler* iAppChangeHandler;

		// Pointer to sim change handler

		CLbtSimChangeHandler* iSimChangeHandler;

		// Pointer to cleanup handler

		CLbtCleanupHandler* iCleanupHandler;

	};

#endif // C_LBTSERVERLOGIC_H