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

#include <featmgr.h>         // for Feature Manager

#include <commsdattypesv1_1.h>

#include <metadatabase.h> 

#include <commsdattypeinfov1_1_internal.h>

using namespace CommsDat;

const TInt KMicroSecInSec = 1000000;

const TInt KIdleTimer = 2;

const TInt KOfflineTimer = 5;

// ============================ 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),

	iDeltaTimerCallBack(ConnectionCloseTimerExpired, this)

#ifdef CPPUNIT_TEST

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

    , iProfileCache(1),

    iObservers(1),

    iMigrationControllers(1)

#endif

    {

		iFeatMgrInitialized = EFalse;

		iDeltaTimerEntry.Set(iDeltaTimerCallBack);

    }

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

// CSIPProfileServerCore::ConstructL

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

//

void CSIPProfileServerCore::ConstructL()

    {

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

    FeatureManager::InitializeLibL();

    iFeatMgrInitialized = ETrue;

	iDeltaTimer = CDeltaTimer::NewL(CActive::EPriorityStandard);

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

	iApnManager = CSIPApnManager::NewL( *this );

	LoadSystemStateMonitorL();

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

    LoadProfilesL(EFalse);

    iNotify = CSIPProfileStorageSecureBackup::NewL(this);

    iServer = CSIPProfileCSServer::NewL(*this);

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

    delete iNotify;

    iWaitForApnSettings.Reset();

    if(iFeatMgrInitialized)

        {

        FeatureManager::UnInitializeLib();

        }

	delete iDeltaTimer;

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

    if(aContextId == 0 && item)

        {

        if(item->IsApnSwitchEnabled())

            {

            UsePrimaryApn(aProfile.IapId());

            }

        }

    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)

            	}

        	}

        //For Profiles which were in RegInProgress and has moved to Registered State,

        //needs to be deregistered if Offline or RFs or Vpn if in Use has been triggered.

        TBool eventCompleted = EFalse;

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

                (FeatureManager::FeatureSupported( KFeatureIdFfImsDeregistrationInVpn )&& 

                        item->IsVpnInUse())))

            {

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

                    }

                else if (status == CSIPConcreteProfile::ERegistered)

                    {

                    if(item->IsOfflineInitiated())

                        {                        

                        //Don't do anything. If the ProfileStatusEvent = Registered in Offline, it

                        //will only be for WLAN so don't deregister it. If ProfileStatusEvent = Deregistered

                        //means application triggered deregistration so ProfileAgent should not attempt registering it.

                        }

                    else

                        {

                        iProfileCache[i]->ShutdownInitiated();

                        }

                    } //end if unregistered

            if ( !count )

                eventCompleted = ETrue;

                } //end for

            } //end outer if

        if(eventCompleted)

            {

            if (item->IsRfsInprogress())

                StartConnectionCloseTimer(KIdleTimer);

            else if(item->IsOfflineInitiated() )

                ConfirmSystemstateMonitor(CSipSystemStateMonitor::ESystemState);

            else if((FeatureManager::FeatureSupported( KFeatureIdFfImsDeregistrationInVpn )&& 

                        item->IsVpnInUse()))

                ConfirmSystemstateMonitor(CSipSystemStateMonitor::EVpnState);                

            }       

        if(FeatureManager::FeatureSupported( KFeatureIdFfSipApnSwitching))

            {

            if(item && item->IsApnSwitchEnabled() && aContextId)

                {

                CSIPConcreteProfile::TStatus status;

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

                if(status == CSIPConcreteProfile::EUnregistered)

                    {

                    UseBackupApn(item->Profile().IapId(), EFalse);

                    }

                }

            }

        }

    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((aError != KErrNone) && item->HasQueuedUpdate())

        {

        PROFILE_DEBUG4("ProfileServerCore::ProceedRegistration HasQueuedUpdate, err",

			item->HasQueuedUpdate(), aError)

        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 ( aVariable == CSipSystemStateMonitor::ESystemState )

	    {   

            // If the System is Shutting down

            if(aValue == CSipSystemStateMonitor::ESystemShuttingDown)

                {                

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

                    {

                    iProfileCache[i]->ShutdownInitiated();                                

                    }                

                } //end if Shutdown

            //If the System receives Offline event

            if(aValue == CSipSystemStateMonitor::ESystemOffline)

                {                

                StartConnectionCloseTimer(KOfflineTimer);

                TBool waitForDeregistration = EFalse;

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

                    {

                    CSIPConcreteProfile::TStatus status;

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

                    if(status != CSIPConcreteProfile::EUnregistered)

                        waitForDeregistration = ETrue;   

                    iProfileCache[i]->OfflineInitiated(ETrue);

                    }

                if(!waitForDeregistration)

                    {

                    ConfirmSystemstateMonitor(CSipSystemStateMonitor::ESystemState);

                    }

                } //end if Offline