/*

* Copyright (c) 2007-2009 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:

* Name        : SipProfileServerCore.h

* Part of     : SIP Profile Server

* Interface   : private

* The class providing core functionality of profile server

* Version     : 1.0

*

*/

/**

 @internalComponent

*/

#ifndef CSIPPROFILESERVERCORE_H

#define CSIPPROFILESERVERCORE_H

//  INCLUDES

#include "sipconcreteprofile.h"

#include "sipprofileagentobserver.h"

#include "sipprofileerrorhandler.h"

#include <sipsystemstateobserver.h>

#include "sipapnmanager.h"

#include "sipalrobserver.h"

#include <e32base.h>

// FORWARD DECLARATIONS

class CSIPProfileCSServer;

class CSIPProfileStorage;

class CSIPProfileStorageSecureBackup;

class CSIPProfileCacheItem;

class MSIPExtendedConcreteProfileObserver;

class CSIPProfilePlugins;

class CSIPPluginDirector;

class CSIPProfileState;

class CSIPProfileStateUnregistered;

class CSIPProfileStateRegistered;

class CSIPProfileStateUnregInProg;

class CSIPProfileStateRegInProg;

class CSIPProfileStateWaitForIAP;

class CSIPProfileStateWaitForPermission;

class CSIPProfileStateMigratingToNewIAP;

class CSIPProfileStateUnregisteringOldIAP;

class CImplementationInformation;

class CSipAlrHandler;

class CSipAlrMigrationController;

class CSipSystemStateMonitor;

// CLASS DECLARATION

/**

 * The class providing core functionality of profile server.

 */

class CSIPProfileServerCore : public CBase, 

                              public MSIPProfileAgentObserver,

                              public MSipProfileErrorHandler,

                              public MSipSystemStateObserver,

                              public MSIPApnChangeObserver

	{

    public:

    /*

     * struct to store ApnSwitchEnabled profiles in the event 

     * when IAPSettings are not same as required.

     */

    struct TStoreSwitchEnabledProfile

        {

    public:

        enum TOperation

            {

            Update =1,

            Enable,

            Register

            };

        CSIPConcreteProfile*                          iProfile;

        const MSIPExtendedConcreteProfileObserver*    iObserver;

        TOperation                                    operation;

        };

	public: // Constructors and destructor

	    /**

        * Two-phased constructor.

        * @param aServer server of the session

		* @return new instance

        */

		static CSIPProfileServerCore* NewL();

	    /**

        * Two-phased constructor.

        * @param aServer server of the session

		* @return new instance

        */

		static CSIPProfileServerCore* NewLC();

	    /**

        * Destructor.

        */

		~CSIPProfileServerCore();

	public: // From MSIPProfileAgentObserver

		void SIPProfileStatusEvent(

		    CSIPConcreteProfile& aProfile,

		    TUint32 aContextId);

		void SIPProfileErrorEvent(

		    CSIPConcreteProfile& aProfile,

		    TInt aError);

		TBool ProceedRegistration(CSIPConcreteProfile& aProfile, TInt aError);

        void GetFailedProfilesL(

            const TSIPProfileTypeInfo& aType,

            RPointerArray<CSIPConcreteProfile>& aFailedProfiles ) const;

	public: // MSipProfileErrorHandler

		TBool HandleProfileError(CSIPProfileCacheItem& aItem, TInt aOwnError);

	public: // MSipSystemStateObserver

        void SystemVariableUpdated( 

            CSipSystemStateMonitor::TSystemVariable aVariable,

    		TInt aObjectId,

    		TInt aValue );

	public: // MSIPApnChangeObserver

        void ApnChanged( const TDesC8& aApn, TUint32 aIapId, TInt aError );

    public: // New functions

	    /**

        * Stores client observer for sending events

		* @param aObserver observer to be stored

        */

		void SessionRegisterL(

			const MSIPExtendedConcreteProfileObserver& aObserver);

	    /**

        * Removes client observer

		* @param aObserver observer to be removed

        */

		void SessionCleanup(

			const MSIPExtendedConcreteProfileObserver& aObserver);

	    /**

        * Gets profile plugins containing plugins type info

		* @return profile plugins containing plugins type info

        */

		const CSIPProfilePlugins& ProfilePluginsL();

	    /**

        * Adds profile into permanent store, ownership is transferred

		* @param aProfile a stored profile

		* @param aObserver client observer of the profile

        */

		void AddProfileL(CSIPConcreteProfile* aProfile,

			const MSIPExtendedConcreteProfileObserver& aObserver);

	    /**

        * Does the first phase of a profile update, by making update to

        * permanent store.

		* @param aProfile Profile to store, ownership is transferred.

		* @param aObserver client observer of the profile

		* @return ETrue If can proceed to the next phase of the update

		*		  EFalse Must queue the update

        */

		TBool UpdateProfileToStoreL(CSIPConcreteProfile* aProfile,

			const MSIPExtendedConcreteProfileObserver& aObserver);

	    /**

        * Removes profile from permanent store

		* @param aProfileId a removed profile id

        */

		void RemoveProfileL(TUint32 aProfileId);

	    /**

        * Updates profile registration if needed

		* @param aProfileId a registered profile id

		* @param aObserver client observer of the profile

        */

		void UpdateRegistrationL(TUint32 aProfileId,

			const MSIPExtendedConcreteProfileObserver& aObserver);

	    /**

        * Enables profile for use

		* @param aProfileId a enabled profile id

		* @param aObserver client observer of the profile

		* @return status of the profile

        */

		CSIPConcreteProfile::TStatus EnableProfileL(

			TUint32 aProfileId,

			const MSIPExtendedConcreteProfileObserver& aObserver);

	    /**

        * Disables profile from use

		* @param aProfileId a enabled profile id

		* @param aObserver client observer of the profile

		* @return status of the profile

        */

		CSIPConcreteProfile::TStatus DisableProfileL(

			TUint32 aProfileId,

			const MSIPExtendedConcreteProfileObserver& aObserver);

		/**

		* Force disables profile from use

		* @param aProfileId a enabled profile id

		* @param aObserver client observer of the profile

		* @return status of the profile

		*/

		CSIPConcreteProfile::TStatus ForceDisableProfileL(

			TUint32 aProfileId,

			const MSIPExtendedConcreteProfileObserver& aObserver);

	    /**

        * Gets number of users of a profile

		* @param aProfileId a enabled profile id

		* @return number of users

        */

		TInt ProfileUsageL(TUint32 aProfileId) const;

	    /**

        * Gets profile.

		* This method should only be used for calculating profile size.

		* @param aProfileId a required profile id

		* @return Found profile, or NULL if not found. Ownership is not

		*		  transferred.

        */

		const CSIPConcreteProfile* Profile(TUint32 aProfileId) const;

		/**

        * Gets modifiable profile object pointer

		* This method should only be used when you need to update profile.

		* @param aProfileId a required profile id

		* @return Found profile, or NULL if not found. Ownership is not

		*		  transferred.

        */

		CSIPConcreteProfile* Profile(TUint32 aProfileId);

	    /**

        * Gets default profile

		* Ownership is not transferred.

		* This method should only be used for calculating profile size

		* @return profile

        */

		const CSIPConcreteProfile* ProfileDefaultL();

	    /**

        * Gets profile.

		* @param aProfileId a required profile id

		* @param aObserver client observer of the profile

		* @return Found profile

		* @leave KErrNotFound if profile was not found

        */

		CSIPConcreteProfile& ProfileL(

			TUint32 aProfileId,

			const MSIPExtendedConcreteProfileObserver& aObserver) const;

	    /**

        * Gets updated profile to refresh previously fetched data.

		* @param aProfileId a required profile id

		* @param aObserver client observer of the profile

		* @return Profile

        */

		CSIPConcreteProfile& ProfileRefreshL(

			TUint32 aProfileId,

			const MSIPExtendedConcreteProfileObserver& aObserver) const;

		/**

		* Creates new profile prefilled with default values.

		* Ownership is transferred.

		* @aParam aType type to match

		* @return new instance of CSIPConcreteProfile

		*/

		CSIPConcreteProfile* CreateProfileL(const TSIPProfileTypeInfo& aType);

	    /**

        * Gets array of all profiles

		* @param aObserver client observer of the profiles

		* @param aArray array to store profiles

        */

		void ProfilesL(const MSIPExtendedConcreteProfileObserver* aObserver,

			RPointerArray<CSIPConcreteProfile>& aArray) const;

		/**

        * Gets array of profiles with matching AOR

		* @param aAOR AOR to match

		* @param aObserver client observer of the profiles

		* @param aArray array to store profiles

        */

		void ProfilesByAORL(const TDesC8& aAOR,

			const MSIPExtendedConcreteProfileObserver* aObserver,

			RPointerArray<CSIPConcreteProfile>& aArray) const;

	    /**

        * Gets array of profiles with matching type

		* @param aType type to match

		* @param aObserver client observer of the profiles

		* @param aArray array to store matching profiles

        */

		void ProfilesByTypeL(const TSIPProfileTypeInfo& aType, 

			const MSIPExtendedConcreteProfileObserver* aObserver,

			RPointerArray<CSIPConcreteProfile>& aArray) const;

	    /**

        * Clears client observer from profile

		* @param aProfileId a required profile id

		* @param aObserver client observer of the profile

        */

		void DeleteProfileL(TUint32 aProfileId, 

			const MSIPExtendedConcreteProfileObserver& aObserver);

		/**

        * Checks if server can be stopped

		* @return ETrue, if there are no clients using the profiles

		*		  and there are not autoregistered profiles to be managed

        */

		TBool CanServerStop() const;

		/**

        * Checks if server is currently being backupped/restored

		* @return ETrue, if server is currently being backupped/restored

		*		  , EFalse otherwise

        */

		TBool BackupInProgress() const;

	    /**

        * Sends registration status event to observers of the profile

		* @param aItem holds profile and observers

        */

		void SendRegistrationStatusEventL(CSIPProfileCacheItem& aItem) const;

	    /**

        * Sends unregistered status event to observers of the profile

		* @param aItem holds profile and observers

        */

		void SendUnregisteredStatusEventL(CSIPProfileCacheItem& aItem) const;

	    /**

        * Sends error event to observers of the profile

		* @param aItem holds profile and observers

		* @param aStatus status indicating if error occurred

		*		  during registering (ERegistrationInProgress)

		*		  or deregistering (EUnregistrationInProgress)

		* @param aError error code

		* @return system wide error code on failure

        */

		TInt SendErrorEvent(CSIPProfileCacheItem& aItem,

							CSIPConcreteProfile::TStatus aStatus,

							TInt aError) const;

	    /**

        * Sends profile added event to all clients

		* @param aProfile added profile

        */

		void SendProfileAddedEvent(const CSIPConcreteProfile& aProfile) const;

	    /**

        * Sends profile update event to observers of the profile

		* @param aItem Holds the observers

		* @param aProfile Profile that has been updated

        */

		void SendProfileUpdatedEventL(const CSIPProfileCacheItem& aItem,

			const CSIPConcreteProfile& aProfile) const;

	    /**

        * Sends profile remove event to observers of the profile

		* @param aItem holds profile and observers

        */

		void SendProfileRemovedEventL(CSIPProfileCacheItem& aItem) const;		

		/**

		* Storage notifies that store file must be released. This

		* occurs during backup/restore process

		* aParam aRestoreOngoing ETrue if restore is ongoing,

		*						 EFalse if backup is ongoing

		*/

		void ReleaseStorage(TBool aRestoreOngoing);

		/**

		* Storage notifies that store file can again be reserved. This

		* occurs during backup/restore process

		* aParam aRestoreOngoing ETrue if restore is ongoing,

		*						 EFalse if backup is ongoing

		*/

		void ReserveStorage(TBool aRestoreOngoing);

		/**

		* Allows the migration from the old

		*  IAP to the new one.

		* @param aProfileId the SIP profile id

		* @param aIapId the new IAP id

		* @param aObserver Observer

		*/

		void AllowMigrationL(TUint32 aProfileId,

			TUint32 aIapId,

			const MSIPExtendedConcreteProfileObserver& aObserver);

		/**

		* Disallows the migration from the 

		* old IAP to the new one.

		* @param aProfileId the SIP profile id

		* @param aIapId the new IAP id.

		* @param aObserver Observer

		*/

		void DisallowMigrationL(TUint32 aProfileId,

			TUint32 aIapId,

			const MSIPExtendedConcreteProfileObserver& aObserver);

		/**

        * Refreshes the list of available IAPs for a profile.

		* @param aProfileId the SIP profile id

		*/

		void RefreshIapAvailabilityL(TUint32 aProfileId);

		/**

        * Migrating to an IAP has been initiated.

		* @param aItem Profile cache item

		* @param aSnapId SNAP id

		* @param aIapId IAP id

		*/

		void MigrationStartedL(const CSIPProfileCacheItem& aItem,

							   TUint32 aSnapId,

							   TUint32 aNewIapId) const;

		/**

        * Migrating to an IAP has been completed successfully.

		* @param aItem Profile cache item

		* @param aSnapId SNAP id

		* @param aIapId IAP id

		*/

		void MigrationCompletedL(const CSIPProfileCacheItem& aItem,

							     TUint32 aSnapId,

							     TUint32 aNewIapId) const;

		/**

        * Forward an ALR related error to client. These errors include etc.

        * "migration failed".

		* @param aItem Profile cache item

		* @param aError Error code.

		* @param aSnapId SNAP id

		* @param aIapId IAP id

		* @return system wide error code on failure

		*/

		TInt PassAlrErrorToClient(const CSIPProfileCacheItem& aItem,

								  TInt aError,

								  TUint32 aSnapId,

								  TUint32 aIapId) const;

		/**

        * Gets the migration controller of the given SNAP id. If a controller

        * does not exists, creates a new one.

		* @param aSnapData 

		* @return Migration controller, ownership is not transferred.

		*/

		CSipAlrMigrationController& MigrationControllerL(TSipSNAPConfigurationData aSnapData);

		CSIPProfileState& UnregisteredState();

		TUint32 GenerateProfileIdL();

		/**

		* Sends forcibly disable profile added event to all clients

		* @param aProfileId: Id of the profile being disabled forcibly 

		*/

		void SendProfileForciblyDisabledEvent(const CSIPProfileCacheItem& aItem) const;

    /**

    * Gets cached profile, leave if not found

    * ownership is not transfered

    * @param aProfileId id of profile. 

    * @return profile cache item 

    */

    CSIPProfileCacheItem* ProfileCacheItemL(TUint32 aProfileId) const;

		/**

		*Starts timer of type CDeltaTimer, 

		*which callback is ConnectionCloseTimerExpired function

		*/

		void StartConnectionCloseTimer(TInt aValue);

		/**

		* A callback for CDeltaTimer

		*/

		static TInt ConnectionCloseTimerExpired(TAny* aPtr);

		/**

		* Notify system state monitor about event processing completion

		*/

		void ConfirmSystemstateMonitor(

			CSipSystemStateMonitor::TSystemVariable aVariable);

		/*

         * Checks whether the Update can be performed when the profile

         * has IAP as modem bearer.

         */

        TBool IsUpdateAllowed( CSIPConcreteProfile *aProfile );

	private:

		/**

		* Default constructor

		* @param aServer server of the session

		*/

		CSIPProfileServerCore();