/*
* 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();
/**
* Symbian 2nd phase constructor
*/
void ConstructL();
/**
* Sends status event to observers of the profile
* @param aItem holds profile and observers
*/
void SendStatusEventL(CSIPProfileCacheItem& aItem,
CSIPConcreteProfile::TStatus aStatus) const;
/**
* Loads profiles from store to cache, register
* markes as autoregistration on.
* Runned after server is started and after
* store file is modified by external party
* like backup system.
*/
void LoadProfilesL(TBool aNotifyProfileCreation);
/**
* Terminates usage of profiles and cleans cache.
* Runned when external party has modified store.
*/
void TerminateProfilesL();
/**
* Gets cached profile, returns 0 if not found
* ownership is not transfered
* @param aProfileId id of profile.
* @return profile cache item
*/
CSIPProfileCacheItem* ProfileCacheItem(TUint32 aProfileId) const;
/**
* Gets cached profile, returns 0 if not found
* ownership is not transfered
* @param aIndex, index of item in array
* @return profile cache item
*/
CSIPProfileCacheItem* FindProfileCacheItem(TInt aIndex) const;
/**
* Checks if profile is cached
* @param aProfileId id of profile.
* @return index of profile, KErrNotFound if not found
*/
TInt ProfileCached(TUint32 aProfileId) const;
/**
* Searches the profile cache for an item with a mathing storage id.
* @param aStorageId Storage id
* @return Found item
* @leave KErrNotFound If matching item was not found
*/
CSIPProfileCacheItem&
ProfileCacheItemByStorageIdL(TUint32 aStorageId) const;
/**
* Searches the profile cache for an item with a mathing storage id.
* @param aStorageId Storage id
* @return Found item or NULL if not found. Ownership is not transferred.
*/
CSIPProfileCacheItem*
ProfileCacheItemByStorageId(TUint32 aStorageId) const;
/**
* Registers profiles marked as auto-register in startup
*/
void RegisterProfiles();
/**
* Add a profile to array and check if the observer should be added to
* the profile.
* @param aObserver Observer
* @param aArray Array where the profile is added
* @param aItem Profile cache item containing the profile
*/
void HandleMatchingProfileL(
const MSIPExtendedConcreteProfileObserver* aObserver,
RPointerArray<CSIPConcreteProfile>& aArray,
CSIPProfileCacheItem& aItem) const;
/**
* Removes client observer, leaves on failure
* @param aObserver observer to be removed
*/
void SessionCleanupL(
const MSIPExtendedConcreteProfileObserver& aObserver);
/**
* Converts ECom plugin into profile type
* @param aEcomInfo ECom plugin info
* @param aInfo returned profile type info
*/
void ConvertTypeInfoL(const CImplementationInformation& aEcomInfo,
TSIPProfileTypeInfo& aInfo) const;
/**
* Checks if the server can stop, informs CS-server
* if can be stopped;
*/
void CheckServerStatus() const;
/**
* Get status weather error occurred during registration
* or deregistartion
* @param aItem profile cache item to be validated
* @return in progress status of cached profile
*/
CSIPConcreteProfile::TStatus ValidateErrorStatus(
CSIPProfileCacheItem& aItem) const;
/**
* Registration status event occurred.
* @param aProfileId a profile id
* @param aContextId a registration context identifier
*/
void SIPProfileStatusEventL(
TUint32 aProfileId,
TUint32 aContextId);
/**
* Handles possible asynchronous errors from plugin manager
* @param aItem profile item to be handled
* @param aStatus status indicating if error occurred
* during registering (ERegistrationInProgress)
* or deregistering (EUnregistrationInProgress)
* @param aError Error code to be handled
*/
void HandleAsyncError(CSIPProfileCacheItem& aItem,
CSIPConcreteProfile::TStatus aStatus,
TInt aError);
/**
* 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 ReleaseStorageL(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 ReserveStorageL(TBool aRestoreOngoing);
/**
* Cleans up array in case of failure
* ownership of aArray is transferred
* @param aArray array to be cleaned up
*/
static void ResetAndDestroy(TAny* aArray);
/**
* Cleans up array in case of failure
* ownership of aArray is transferred
* @param aArray array to be cleaned up
*/
static void ResetAndDestroyInfo(TAny* aArray);
/**
* Reverts back cache in case of failure
* @param aItem cache cleanup item
*/
static void CrashRevert(TAny* aItem);
/**
* Handles the errors occured during the profile restore
* @param aErr
* @param fileStore specifies the kind of the file on which
* the storage error has occured
*/
void HandleProfileStorageErrorL(TInt aErr, TBool fileStore=EFalse);
/**
* Remove the cached profile entry identified by aProfileId.
* @param aProfileId Profile id
*/
void RemoveProfileItem(TUint32 aProfileId);
/**
* Removes unused migration controllers, except if it uses the specified
* SNAP id.
* @param aSnapId SNAP id
*/
void RemoveUnusedMigrationControllers(TUint32 aSnapId);
void LoadSystemStateMonitorL();
/**
* Gets the default profile
* @return Pointer to the default profile, or NULL if not found.
*/
CSIPConcreteProfile* FindDefaultProfile() const;
TBool ShouldChangeIap(CSIPConcreteProfile& aProfile, TInt aError) const;
/**
* @return ETrue if any registered profile is using aIap
*/
TBool AnyRegisteredProfileUsesIap(TUint aIap) const;
/**
* Add profiles in Profile Cache
* @param aProfiles Array of the profiles to be added
* @param aNotifyProfileCreation specifies whether the notification
* to be sent to the profile clients
*/
void AddProfilesInCacheL(RPointerArray<CSIPConcreteProfile>& aProfiles,
TBool aNotifyProfileCreation);
/**
* Gets the IAP Count in the Snap
* @return number of aIaps in the Snap
*/
TInt IAPCountL(TUint32 aSnapId) const;
/*
* Checks whether the current seetings are same as
* required seetings for Registeration.
* @ returns ETrue when the seetings are correct
* EFalse otherwise
*/
TBool IsRegistrationAllowedWithCurrentApnSettings( TUint32 aIapId );
/**
** Selecting Initial Apn for the profile
**/
void SelectInitialApnL( const CSIPConcreteProfile& aProfile );
/**
* Checks whether the profile's IAP is switch enabled
* @ returns ETrue when the profile is APN switch enabled
* EFalse otherwise
*/
TBool CheckApnSwitchEnabledL( const CSIPConcreteProfile& aProfile );
/**
* Checks the IAP settings
* @ returns ETrue when all the settings are correct
* EFalse otherwise
*/
TBool CheckIapSettings(TUint32 aProfileId);
/**
* Issues the change of APN to PrimaryAPN
*/
void UsePrimaryApn(TUint32 aIapId);
/**
* Issues the change of APN to SecondaryAPN
*/
void UseBackupApn( TUint32 aIapId, TBool aFatalFailure = ETrue );
/**
* Compares the two plugin typr info
* @returns ETrue if the match completely
* EFalse otherwise
*/
static TBool Compare(const TSIPProfileTypeInfo& first,
const TSIPProfileTypeInfo& second);
public:
/**
* Returns the count of profiles in the cache
*/
TInt GetProfileCacheCount() const;
private: // Data
RFs iFs;
TBool iBackupInProgress;
// Owned
CSIPProfileCSServer* iServer;
// Owned
CSIPProfileStorage* iProfileStorage;
// Owned
CSIPProfileStorageSecureBackup* iNotify;
// Array items are owned
RPointerArray<CSIPProfileCacheItem> iProfileCache;
// Array items are not owned
RPointerArray<MSIPExtendedConcreteProfileObserver>
iObservers;
// Owned
CSIPProfilePlugins* iProfilePlugins;
// Owned
CSIPPluginDirector* iPluginDirector;
// Owned
CSIPProfileCacheItem* iFindEntry;
// Profile states. Owned.
CSIPProfileStateUnregistered* iUnregistered;
CSIPProfileStateRegistered* iRegistered;
CSIPProfileStateUnregInProg* iUnregInProg;
CSIPProfileStateRegInProg* iRegInProg;
CSIPProfileStateWaitForIAP* iWaitForIAP;
CSIPProfileStateWaitForPermission* iWaitForPermission;
CSIPProfileStateMigratingToNewIAP* iMigratingToNewIAP;
CSIPProfileStateUnregisteringOldIAP* iUnregisteringOldIAP;
// Owned
CSipAlrHandler* iAlrHandler;
// Migration controllers. Array items are owned.
RPointerArray<CSipAlrMigrationController> iMigrationControllers;
// Owned
CSipSystemStateMonitor* iSystemStateMonitor;
//ApnManager
CSIPApnManager* iApnManager; // iBackupApnSettings;
RArray<TStoreSwitchEnabledProfile> iWaitForApnSettings;
TBool iFeatMgrInitialized;
CDeltaTimer* iDeltaTimer;
TCallBack iDeltaTimerCallBack;
TDeltaTimerEntry iDeltaTimerEntry;
private: // For testing purposes
#ifdef CPPUNIT_TEST
friend class CSIPProfileServerCoreTest;
friend class CSIPProfileCSSessionTest;
friend class CSIPProfileCSServerTest;
friend class CSIPProfileStateTest;
friend class CSIPProfileStateRegInProgTest;
friend class CSIPProfileStateRegisteredTest;
friend class CSIPProfileStateUnregInProgTest;
friend class CSIPProfileStateUnregisteredTest;
friend class CSIPProfileStateWaitForIAPTest;
friend class CSIPProfileStateWaitForPermissionTest;
friend class CSIPProfileStateMigratingToNewIAPTest;
friend class CSIPProfileStateUnregisteringOldIAPTest;
friend class CSipAlrHandlerTest;
friend class CSIPProfileAlrTest;
friend class CSIPProfileCacheItemTest;
#endif
};
#endif // CSIPPROFILESERVERCORE_H