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

// Part of     : SIP Profile Server

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include "SipProfileServerCore.h"

#include "SipProfileCSServer.h"

#include "sipextendedconcreteprofileobserver.h"

#include "SIPProfileStorage.h"

#include "SipProfileStorageSecureBackup.h"

#include "SipProfileCacheItem.h"

#include "SipProfileCacheCleanupItem.h"

#include "sipconcreteprofile.h"

#include "sipprofileplugins.h"

#include "sipplugindirector.h"

#include "SipProfileStateUnregistered.h"

#include "SipProfileStateRegistered.h"

#include "SipProfileStateRegInProg.h"

#include "SipProfileStateUnregInProg.h"

#include "sipprofilestatewaitforiap.h"

#include "sipprofilestatewaitforpermission.h"

#include "sipprofilestatemigratingtonewiap.h"

#include "sipprofilestateunregisteringoldiap.h"

#include "SipProfileLog.h"

#include "sipalrhandler.h"

#include "sipalrmigrationcontroller.h"

#include "sipmanagedprofile.h"

#include "sipprofile.h"

#include "sipprofilecs.h"

#include "SIPProfileStorageIndex.h"

#include <siperr.h>

#include <sipsystemstatemonitor.h>

#include <random.h>

// ============================ MEMBER FUNCTIONS ===============================

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

// CSIPProfileServerCore::NewL

// Two-phased constructor.

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

//

CSIPProfileServerCore* CSIPProfileServerCore::NewL()

    {

    CSIPProfileServerCore* self = CSIPProfileServerCore::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPProfileServerCore::NewLC

// Two-phased constructor.

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

//

CSIPProfileServerCore* CSIPProfileServerCore::NewLC()

    {

    CSIPProfileServerCore* self = new(ELeave)CSIPProfileServerCore();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CSIPProfileServerCore::CSIPProfileServerCore

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

//

CSIPProfileServerCore::CSIPProfileServerCore() :

	iBackupInProgress(EFalse)

#ifdef CPPUNIT_TEST

    // Set the array granularity to 1, so they allocate memory for every append    

    , iProfileCache(1),

    iObservers(1),

    iMigrationControllers(1)

#endif

    {

    }

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

// CSIPProfileServerCore::ConstructL

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

//

void CSIPProfileServerCore::ConstructL()

    {

    User::LeaveIfError(iFs.Connect());

    iFindEntry = CSIPProfileCacheItem::NewL(*this, iUnregistered);

    iPluginDirector = CSIPPluginDirector::NewL(*this);

    iUnregistered = CSIPProfileStateUnregistered::NewL(*iPluginDirector);

    iRegistered = CSIPProfileStateRegistered::NewL(*iPluginDirector);

    iUnregInProg = CSIPProfileStateUnregInProg::NewL(*iPluginDirector);

    iRegInProg = CSIPProfileStateRegInProg::NewL(*iPluginDirector);

    iWaitForIAP = CSIPProfileStateWaitForIAP::NewL(*iPluginDirector);

    iWaitForPermission =

    	CSIPProfileStateWaitForPermission::NewL(*iPluginDirector);

    iMigratingToNewIAP =

    	CSIPProfileStateMigratingToNewIAP::NewL(*iPluginDirector);

    iUnregisteringOldIAP =

    	CSIPProfileStateUnregisteringOldIAP::NewL(*iPluginDirector);

    iUnregistered->SetNeighbourStates(*iRegInProg, *iWaitForIAP);

    iRegistered->SetNeighbourStates(*iUnregInProg,

    								*iUnregistered,

    								*iRegInProg,

    								*iWaitForPermission);

    iUnregInProg->SetNeighbourStates(*iUnregistered, *iRegistered);

    iRegInProg->SetNeighbourStates(*iRegistered,

    							   *iUnregistered,

    							   *iUnregInProg,

    							   *iWaitForIAP,

    							   *iWaitForPermission);

    iWaitForIAP->SetNeighbourStates(*iWaitForPermission,

    								*iRegInProg,

    								*iUnregInProg,

    								*iUnregistered);

    iWaitForPermission->SetNeighbourStates(*iWaitForIAP,

    	*iMigratingToNewIAP,

    	*iRegInProg,

    	*iRegistered,

    	*iUnregInProg,

    	*iUnregistered);

    iMigratingToNewIAP->SetNeighbourStates(*iUnregisteringOldIAP,

    									   *iWaitForIAP,

    									   *iRegistered,

    									   *iUnregInProg,

    									   *iUnregistered);

	iUnregisteringOldIAP->SetNeighbourStates(*iRegistered, *iUnregInProg);

	LoadSystemStateMonitorL();

	iAlrHandler = CSipAlrHandler::NewL(*this,iSystemStateMonitor);

    LoadProfilesL(EFalse);

    iNotify = CSIPProfileStorageSecureBackup::NewL(this);

    iServer = CSIPProfileCSServer::NewL(*this);

	iOfflineEventReceived = EFalse;

    PROFILE_DEBUG1("ProfileServer started")

    }

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

// CSIPProfileServerCore::~CSIPProfileServerCore

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

//

CSIPProfileServerCore::~CSIPProfileServerCore()

    {

    // If the monitor plug-in is deleted later in destructor, leaks memory.

    if (iSystemStateMonitor)

    	{

    	iSystemStateMonitor->StopMonitoring( 

    	    CSipSystemStateMonitor::ESystemState, 0, *this);

    	delete iSystemStateMonitor;

    	}

    delete iServer;    

    iObservers.Reset();

	// Profile cache entries use migration controllers, so delete entries first

    iProfileCache.ResetAndDestroy();

	// Migration controllers use ALR handler, so delete controllers first

	iMigrationControllers.ResetAndDestroy();

	delete iAlrHandler;

    delete iProfileStorage;

    delete iPluginDirector;

    delete iProfilePlugins;

    delete iFindEntry;

    delete iUnregistered;

    delete iRegistered;

    delete iUnregInProg;

    delete iRegInProg;

    delete iWaitForIAP;

    delete iWaitForPermission;

    delete iMigratingToNewIAP;

    delete iUnregisteringOldIAP;

    delete iNotify;

    iFs.Close();

    PROFILE_DEBUG1("ProfileServer stopped")

#ifdef _BullseyeCoverage

    // Store coverage measurement

    cov_write();

#endif

    }

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

// CSIPProfileServerCore::SIPProfileStatusEvent

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

//

void CSIPProfileServerCore::SIPProfileStatusEvent(CSIPConcreteProfile& aProfile,

												  TUint32 aContextId)

    {

    CSIPProfileCacheItem* item = ProfileCacheItem(aProfile.Id());

    TRAPD(err, SIPProfileStatusEventL(aProfile.Id(), aContextId));

    if (err != KErrNone)

        {

		if (item)

        	{

        	HandleAsyncError(*item,

        					 CSIPConcreteProfile::ERegistrationInProgress,

        					 err);

        	}

        }

    }

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

// CSIPProfileServerCore::SIPProfileStatusEventL

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

//

void CSIPProfileServerCore::SIPProfileStatusEventL(TUint32 aProfileId,

    											   TUint32 aContextId)

    {

    PROFILE_DEBUG4("ProfileServerCore::SIPProfileStatusEventL id,ctxId",

    			   aProfileId, aContextId)

    CSIPProfileCacheItem* item = ProfileCacheItem(aProfileId);

    if (item)

    	{

		// In MigratingToNewIAP state, only profile in use is new IAP's register

    	CSIPConcreteProfile::TStatus status;

        iPluginDirector->State(status, item->UsedProfile());

        item->RegistrationStatusEventL(status, aContextId);

        if (!item->IsActiveState() )

        	{

        	if (status == CSIPConcreteProfile::ERegistered)

        		item->RemoveL();

        	else

        	if (item->CanBePermanentlyRemoved())

        		{

        		RemoveProfileItem(aProfileId);

            	delete item;

				item = NULL;

            	PROFILE_DEBUG3(

            	"ProfileServerCore::SIPProfileStatusEventL(removed) id",

                	aProfileId)

            	}

        	}

        if (item && item->IsRfsInprogress())

            {

            CSIPConcreteProfile::TStatus status;

            TInt count = iProfileCache.Count();

            for (TInt i = 0; i < iProfileCache.Count(); i++)

                {

                iPluginDirector->State(status, iProfileCache[i]->UsedProfile());

                if (status == CSIPConcreteProfile::EUnregistered)

                    count--;

                }

            if (!count)

                {

                iSystemStateMonitor->EventProcessingCompleted(

								CSipSystemStateMonitor::ERfsState, 0, *this);

                }

            }

        }

		if (iOfflineEventReceived)

        {

        CSIPConcreteProfile::TStatus status;

        TInt count = iProfileCache.Count();

        for (TInt i = 0; i < iProfileCache.Count(); i++)

            {

            iPluginDirector->State(status, iProfileCache[i]->UsedProfile());

            if (status == CSIPConcreteProfile::EUnregistered)

                count--;

            }

        if (!count)

            {

            iSystemStateMonitor->EventProcessingCompleted(CSipSystemStateMonitor::ESystemState, 0, *this);

            }

        }

    CheckServerStatus();

    }

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

// CSIPProfileServerCore::SIPProfileErrorEvent

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

//

void CSIPProfileServerCore::SIPProfileErrorEvent(CSIPConcreteProfile& aProfile,

    											 TInt aError)

    {

    PROFILE_DEBUG4("ProfileServerCore::SIPProfileErrorEvent id,err", 

                   aProfile.Id(), aError)

    CSIPProfileCacheItem* item = ProfileCacheItem(aProfile.Id());

    if (item)

    	{

    	CSIPConcreteProfile::TStatus status = ValidateErrorStatus(*item);

        HandleAsyncError(*item, status, aError);

        iPluginDirector->StartTimerForCleanup();

    	}

    CheckServerStatus();

    }

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

// CSIPProfileServerCore::ProceedRegistration

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

//

TBool CSIPProfileServerCore::ProceedRegistration

		(CSIPConcreteProfile& aProfile, TInt aError)

    {

    PROFILE_DEBUG4("ProfileServerCore::ProceedRegistration id, err", aProfile.Id(), aError)

    CSIPProfileCacheItem* item = ProfileCacheItem(aProfile.Id());

    if (!item)

    	{

    	return EFalse;

    	}

    if ( ShouldChangeIap(item->UsedProfile(), aError) && 

    	 !item->SnapRetryCountReached() )

        {

        PROFILE_DEBUG1("CSIPProfileServerCore::ProceedRegistration, IAP should be changed")

        // If IAP should be changed, handle this like an error, so the profile

        // can ask for a new IAP.

        SIPProfileErrorEvent(item->UsedProfile(), aError);

        // Return false so that the profile agent does not retry registration

        // with old IAP.

        return EFalse;

        }

	PROFILE_DEBUG1("CSIPProfileServerCore::ProceedRegistration, IAP should NOT be changed")        

    if (!item->IsActiveState())

        {

        PROFILE_DEBUG1("ProceedRegistration, profile removed")

        return EFalse;

        }

    if (item->ReferenceCount() == 0)

    	{

    	if (!item->LatestProfile().IsAutoRegistrationEnabled())

            {

            PROFILE_DEBUG1("ProceedRegistration, profile not used")

            return EFalse;

            }

    	if (item->HasProfileUpdate())

            {

            PROFILE_DEBUG1("ProceedRegistration, profile updated, not used")

            return EFalse;

            }

    	}

    PROFILE_DEBUG1("ProceedRegistration, profile untouched")

    return ETrue;    

    }    

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

// CSIPProfileServerCore::GetFailedProfilesL

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

//

void CSIPProfileServerCore::GetFailedProfilesL(const TSIPProfileTypeInfo& aType,

    RPointerArray<CSIPConcreteProfile>& aFailedProfiles) const

    {

    for (TInt i = 0; i < iProfileCache.Count(); i++)

        {

        const CSIPConcreteProfile& profile = iProfileCache[i]->Profile();

        if (profile.ProfileType().iSIPProfileClass == aType.iSIPProfileClass &&

        	profile.ProfileType().iSIPProfileName  == aType.iSIPProfileName &&

            (profile.IsEnabled() || profile.IsAutoRegistrationEnabled()) &&

             profile.Status() == CSIPConcreteProfile::EUnregistered &&

             profile.LastRegistrationError() != KErrNone)

        	{

        	aFailedProfiles.AppendL(&profile);

        	}

        }

    }

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

// CSIPProfileServerCore::HandleProfileError

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

//

TBool CSIPProfileServerCore::HandleProfileError(CSIPProfileCacheItem& aItem,

											    TInt aOwnError)

	{

    iPluginDirector->TerminateHandling(aItem.UsedProfile());

    return aItem.HandleError(aOwnError);

	}

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

// CSIPProfileServerCore::SystemVariableUpdated

// If a system shutdown event is received, initiate de-registering each profile

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

//

void CSIPProfileServerCore::SystemVariableUpdated( 

    CSipSystemStateMonitor::TSystemVariable aVariable,

    TInt /*aObjectId*/,

    TInt aValue )

    {

    PROFILE_DEBUG3("CSIPProfileServerCore::SystemVariableUpdated System State changed to value", aValue)

    //If the SystemState is Offline, turn the boolean variable to true so that Profile-Server

    //can indicate System State monitor that event processing is completed, provided all the 

    //profiles have got deregistered

    if (CSipSystemStateMonitor::ESystemOffline == aValue)

        iOfflineEventReceived = ETrue;

	if ( aVariable == CSipSystemStateMonitor::ESystemState &&

	     (aValue == CSipSystemStateMonitor::ESystemShuttingDown || 

	     aValue == CSipSystemStateMonitor::ESystemOffline

			 ))

	    {    

        for (TInt i = 0; i < iProfileCache.Count(); i++)

            {

            iProfileCache[i]->ShutdownInitiated();

            }	    

	    }

	//If the System State is Online, register all the profiles in always on mode

	else if(aVariable == CSipSystemStateMonitor::ESystemState && 

		aValue == CSipSystemStateMonitor::ESystemOnline)

		{

		iOfflineEventReceived = EFalse;

		for (TInt i = 0; i < iProfileCache.Count(); i++)

		    {

		    iProfileCache[i]->ResetShutdownvariable();

		    CSIPProfileCacheItem* item = iProfileCache[i];

		    if (item->Profile().IsAutoRegistrationEnabled())

		        {

                TRAPD(err, item->StartRegisterL(*iWaitForIAP, *iRegInProg, ETrue));

		        if (err != KErrNone)

		            {

		            HandleAsyncError(*item,CSIPConcreteProfile::ERegistrationInProgress,err);

		            }

				}

			}

		}

	else if(aVariable == CSipSystemStateMonitor::ERfsState)

	    {

	    if(aValue == CSipSystemStateMonitor::ERfsStarted)

	        {

	        PROFILE_DEBUG1("RFS Started, de-registering the profiles")

	        for (TInt i = 0; i < iProfileCache.Count(); i++)

	            {

	            iProfileCache[i]->RfsInprogress(ETrue);

	            }

	        }

	    else if(aValue == CSipSystemStateMonitor::ERfsFailed)

	        {

	        PROFILE_DEBUG1("RFS Failed, re-registering the profiles")

	        for (TInt i = 0; i < iProfileCache.Count(); i++)

	            {

	            iProfileCache[i]->RfsInprogress(EFalse);

	            if (iProfileCache[i]->IsReferred())

	                {

	                TRAPD(err, iProfileCache[i]->StartRegisterL(*iWaitForIAP, *iRegInProg, ETrue));

	                if (err != KErrNone)

	                    {

	                    HandleAsyncError(*iProfileCache[i],

	                            CSIPConcreteProfile::ERegistrationInProgress,

	                            err);	                            

	                    }

	                }

	            }

	        }

	    else if(aValue == CSipSystemStateMonitor::ERfsCompleted)

	        {

	        PROFILE_DEBUG1("RFS Completed")

	        for (TInt i = 0; i < iProfileCache.Count(); i++)

	            {

	            iProfileCache[i]->RfsInprogress(EFalse);

	            }

	        }

	    }

    }

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

// CSIPProfileServerCore::SessionRegisterL

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

//

void CSIPProfileServerCore::SessionRegisterL(

	const MSIPExtendedConcreteProfileObserver& aObserver)

    {

    iObservers.AppendL(&aObserver);

    }

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

// CSIPProfileServerCore::SessionCleanup

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

//

void CSIPProfileServerCore::SessionCleanup(	

	const MSIPExtendedConcreteProfileObserver& aObserver)

    {

    TRAP_IGNORE(SessionCleanupL(aObserver))

    }

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

// CSIPProfileServerCore::ProfilePluginsL

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

//

const CSIPProfilePlugins& CSIPProfileServerCore::ProfilePluginsL()

    {

    delete iProfilePlugins;

    iProfilePlugins = NULL;