// Copyright (c) 2008-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        : sipprofilecacheitem.cpp

// Part of     : SIP Profile Server

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include "SipProfileCacheItem.h"

#include "SipProfileServerCore.h"

#include "sipextendedconcreteprofileobserver.h"

#include "SipProfileState.h"

#include "SipProfileLog.h"

#include "sipalrmigrationcontroller.h"

#include <sipprofile.h>

#include <cmmanager.h>

#include<e32const.h>

const TInt KSnapRetryCountThreshold = 3;

const TUint32 KDefaultSNAPIdentifier = KMaxTUint32;

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

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

// CSIPProfileCacheItem::NewL

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

//

CSIPProfileCacheItem*

CSIPProfileCacheItem::NewL(CSIPProfileServerCore& aCore,

    					   CSIPProfileState* aUnregistered)

	{

    CSIPProfileCacheItem* self =

    	CSIPProfileCacheItem::NewLC(aCore, aUnregistered);

    CleanupStack::Pop(self);

    return self;

	}

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

// CSIPProfileCacheItem::NewLC

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

//

CSIPProfileCacheItem*

CSIPProfileCacheItem::NewLC(CSIPProfileServerCore& aCore,

    						CSIPProfileState* aUnregistered)

	{

	CSIPProfileCacheItem* self =

		new (ELeave) CSIPProfileCacheItem(aCore, aUnregistered);

    CleanupStack::PushL(self);

	self->ConstructL();

    return self;

	}

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

// CSIPProfileCacheItem::CSIPProfileCacheItem

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

//

CSIPProfileCacheItem::CSIPProfileCacheItem(CSIPProfileServerCore& aCore,

									  	   CSIPProfileState* aUnregistered) :

	iCacheState(ENormal),

	iCurrentState(aUnregistered),

	iServerCore(aCore),

	iMigrationDisallowed(EFalse),

	iDeltaTimer(0),

	iDeltaTimerCallBack(DoNewIapFailed, this),

	iSnapRetryCounter(0)

#ifdef CPPUNIT_TEST

    // Use array granularity 1, so each append allocates memory

    , iObservers(1),

    iUsers(1),

    iObserversWaitedForPermission(1)

#endif

	{

	iIsRfsInprogress = EFalse;

	iIsVpnInUse = EFalse;

	iInitialApnSelected = EFalse;

	iApnSwitchEnabled = EFalse;

	iDeltaTimerEntry.Set(iDeltaTimerCallBack);

	}

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

// CSIPProfileCacheItem::ConstructL

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

//

void CSIPProfileCacheItem::ConstructL()

	{

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

	}

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

// CSIPProfileCacheItem::~CSIPProfileCacheItem

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

//

CSIPProfileCacheItem::~CSIPProfileCacheItem()

	{

	if (iDeltaTimer)

		{

		iDeltaTimer->Cancel();

		}

	delete iDeltaTimer;

	StopSnapMonitoring();

	iObservers.Reset();

	iObserversWaitedForPermission.Reset();

	iUsers.Reset();

	delete iQueuedProfile;

	delete iProfile;

	delete iOldProfile;

	delete iProfileWithNewIAP;

	delete iProfileWithOldIAP;

	}

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

// CSIPProfileCacheItem::IapAvailable

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

//

void CSIPProfileCacheItem::IapAvailable(TUint32 aSnapId, TUint32 aNewIapId)

	{

	iDeltaTimer->Cancel();

	TRAPD(err, iCurrentState->IapAvailableL(*this, aSnapId, aNewIapId));

	if (err != KErrNone)

		{

		iServerCore.HandleProfileError(*this, err);

		}

	}

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

// CSIPProfileCacheItem::MigrationIsAllowedL

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

//

void CSIPProfileCacheItem::MigrationIsAllowedL(TUint32 aIapId)

	{

	iCurrentState->MigrationIsAllowedL(*this, aIapId);

	}

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

// CSIPProfileCacheItem::MigrationIsDisallowedL

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

//

void CSIPProfileCacheItem::MigrationIsDisallowedL(TUint32 aIapId)

	{

	iCurrentState->MigrationIsDisallowedL(*this, aIapId);

	}

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

// CSIPProfileCacheItem::ErrorOccurred

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

//

void CSIPProfileCacheItem::ErrorOccurred(TInt aError)

	{

	HandleError(aError);

	}

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

// CSIPProfileCacheItem::NoNewIapAvailable

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

//

void CSIPProfileCacheItem::NoNewIapAvailable()

	{

	iCurrentState->NoNewIapAvailable(*this);

	}

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

// CSIPProfileCacheItem::RefreshIAPsFailed

// This is a fatal error, as profile no longer gets information of new IAPs.

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

//

void CSIPProfileCacheItem::RefreshIAPsFailed()

	{

	iProfile->SetLastRegistrationError(KErrNoMemory);

	iCurrentState->RefreshIAPsFailed(*this);

	PassAlrErrorToClient(KErrNoMemory, Profile().IapId());

	}

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

// CSIPProfileCacheItem::SetProfile

// Set iProfileId only once, then it never changes.

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

//

void CSIPProfileCacheItem::SetProfile(CSIPConcreteProfile* aProfile)

	{

	__ASSERT_ALWAYS(aProfile, User::Panic(_L("ProfileCacheItem:SetProfile"),

										  KErrArgument));

	delete iProfile;

	iProfile = aProfile;

	if (iProfileId == 0)

		{

		iProfileId = iProfile->Id();

		}

	CheckProfileEnabledState();

	}

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

// CSIPProfileCacheItem::SetProfileId

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

//

void CSIPProfileCacheItem::SetProfileId(TUint aProfileId)

	{

	iProfileId = aProfileId;

	}

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

// CSIPProfileCacheItem::ProfileId

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

//

TUint CSIPProfileCacheItem::ProfileId() const

	{

	return iProfileId;

	}

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

// CSIPProfileCacheItem::Profile

// Return the CSIPConcreteProfile that is most recently registered.

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

//

CSIPConcreteProfile& CSIPProfileCacheItem::Profile()

	{

	__ASSERT_ALWAYS(iProfile,

					User::Panic(_L("ProfileCacheItem:Profile"), KErrNotFound));

	return *iProfile;

	}

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

// CSIPProfileCacheItem::Profile

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

//

const CSIPConcreteProfile& CSIPProfileCacheItem::Profile() const

	{

	__ASSERT_ALWAYS(iProfile,

					User::Panic(_L("ProfileCacheItem:ProfileC"), KErrNotFound));

	return *iProfile;

	}

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

// CSIPProfileCacheItem::LatestProfile

// Return the CSIPConcreteProfile that includes the most recent updates.

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

//

CSIPConcreteProfile& CSIPProfileCacheItem::LatestProfile()

	{

	return iQueuedProfile ? *iQueuedProfile : Profile();

	}

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

// CSIPProfileCacheItem::ReferenceCount

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

//

TUint CSIPProfileCacheItem::ReferenceCount() const

	{

	return iUsers.Count();

	}

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

// CSIPProfileCacheItem::CacheOldProfile

// If update is done before a previous update completed, it contains also the

// earlier update's changes. Some states queue the update. If a new update

// comes, it is stored and the previous discarded.

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

//

TBool CSIPProfileCacheItem::CacheOldProfile(CSIPConcreteProfile* aNewProfile,

	const MSIPExtendedConcreteProfileObserver& aObserver)

	{

	__ASSERT_ALWAYS(aNewProfile && aNewProfile->Id() == ProfileId(),

					User::Panic(_L("ProfileCacheItem:CacheOld"), KErrArgument));

	if (iCurrentState->CanProfileBeUpdated(*this))

		{

		StoreProfileToUpdate(aNewProfile);

		return ETrue;

		}

	delete iQueuedProfile;

	iQueuedProfile = aNewProfile;

	iQueuedObserver = &aObserver;

	return EFalse;

	}

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

// CSIPProfileCacheItem::ClearOldProfile

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

//

void CSIPProfileCacheItem::ClearOldProfile()

	{

	delete iOldProfile;

	iOldProfile = NULL;

	}

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

// CSIPProfileCacheItem::HasProfileUpdate

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

//

TBool CSIPProfileCacheItem::HasProfileUpdate() const

	{

	return iOldProfile != NULL;

	}

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

// CSIPProfileCacheItem::UsedProfile

// Return the CSIPConcreteProfile that most recently used profile agent to

// register, deregister or update.

//

// iProfileWithNewIAP and iProfileWithOldIAP exist only during ALR migration,

// and they never exist both at the same time.

// iProfileWithNewIAP exists only in state CSIPProfileStateMigratingToNewIAP and

// iProfileWithOldIAP exists only in state CSIPProfileStateUnregisteringOldIAP.

//

// iOldProfile exists during an update.

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

//

CSIPConcreteProfile& CSIPProfileCacheItem::UsedProfile()

	{

	return iProfileWithNewIAP ? *iProfileWithNewIAP :

		   iProfileWithOldIAP ? *iProfileWithOldIAP :

		   iOldProfile ? *iOldProfile : Profile();

	}

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

// CSIPProfileCacheItem::UsedProfile

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

//

const CSIPConcreteProfile& CSIPProfileCacheItem::UsedProfile() const

	{

	return iProfileWithNewIAP ? *iProfileWithNewIAP :

		   iProfileWithOldIAP ? *iProfileWithOldIAP :

		   iOldProfile ? *iOldProfile : Profile();

	}

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

// CSIPProfileCacheItem::AddObserverL

// Don't add observer to iObserversWaitedForPermission. It has only observers

// that were notified of a new IAP.

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

//

void CSIPProfileCacheItem::AddObserverL(

	const MSIPExtendedConcreteProfileObserver& aObserver)

	{

	iObservers.AppendL(&aObserver);

	}

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

// CSIPProfileCacheItem::RemoveObserver

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

//

void CSIPProfileCacheItem::RemoveObserver(

	const MSIPExtendedConcreteProfileObserver& aObserver)

	{

	TInt index = iObservers.Find(&aObserver);

	if (index != KErrNotFound)

		{

		iObservers.Remove(index);

		}

	RemoveFromPendingObservers(aObserver);

	}

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

// CSIPProfileCacheItem::Observers

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

//

const RPointerArray<MSIPExtendedConcreteProfileObserver>&

CSIPProfileCacheItem::Observers() const

	{

	return iObservers;

	}

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

// CSIPProfileCacheItem::IsObserverOrUser

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

//

TBool CSIPProfileCacheItem::IsObserverOrUser(

	const MSIPExtendedConcreteProfileObserver& aObserver) const

	{

	return (iObservers.Find(&aObserver) != KErrNotFound) || IsUser(aObserver);

	}

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

// CSIPProfileCacheItem::RemoveUser

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

//

void CSIPProfileCacheItem::RemoveUser(

	const MSIPExtendedConcreteProfileObserver& aObserver)

	{

	TInt index = iUsers.Find(&aObserver);

	if (index != KErrNotFound)

		{

		iUsers.Remove(index);

		CheckProfileEnabledState();

		}

	}

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

// CSIPProfileCacheItem::RemoveAllUsers

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

//

void CSIPProfileCacheItem::RemoveAllUsers()

	{

	iUsers.Reset();

    CheckProfileEnabledState();

	}

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

// CSIPProfileCacheItem::IsUser

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

//

TBool CSIPProfileCacheItem::IsUser(

	const MSIPExtendedConcreteProfileObserver& aObserver) const

	{

	return iUsers.Find(&aObserver) != KErrNotFound;

	}

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

// CSIPProfileCacheItem::MoveToUserL

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

//

void CSIPProfileCacheItem::MoveToUserL(

	const MSIPExtendedConcreteProfileObserver& aObserver)

	{

	iUsers.AppendL(&aObserver);

	CheckProfileEnabledState();

	}

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

// CSIPProfileCacheItem::IsActiveState

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

//

TBool CSIPProfileCacheItem::IsActiveState() const

	{

	return iCacheState == ENormal;

	}

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

// CSIPProfileCacheItem::HasAorL

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

//

TBool CSIPProfileCacheItem::HasAorL(const TDesC8& aAOR) const

	{

    TUriParser8 otherUriparser;

    User::LeaveIfError(otherUriparser.Parse(aAOR));

    TInt err = otherUriparser.Equivalent(iProfile->AORUri8());

    if (err == KErrNoMemory)

        {

        User::Leave(err);

        }

    return err == KErrNone;

	}

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

// CSIPProfileCacheItem::StartRegisterL

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

//

void CSIPProfileCacheItem::StartRegisterL(CSIPProfileState& aWaitForIAP,

										  CSIPProfileState& aRegInProg,

										  TBool aGetIap)

	{

	TUint32 snapId(0);

		PROFILE_DEBUG3("ProfileCacheItem::StartRegisterL - SNAP ID", snapId)

	if (aGetIap && IsSNAPConfigured(snapId))

		{

		PROFILE_DEBUG3("ProfileCacheItem::StartRegisterL - MONITOR SNAP", snapId)

		MonitorSnapL(snapId, aWaitForIAP, aRegInProg);

		}

	else

		{

		PROFILE_DEBUG3("ProfileCacheItem::StartRegisterL - REGISTER", snapId)

		iCurrentState->RegisterL(*this);

		}

	}

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

// CSIPProfileCacheItem::EnableL

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

//

void CSIPProfileCacheItem::EnableL(

	const MSIPExtendedConcreteProfileObserver& aObserver)

	{

	iCurrentState->EnableL(*this, aObserver);

	}

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

// CSIPProfileCacheItem::EnableSnapInUseL

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

//

void CSIPProfileCacheItem::EnableSnapInUseL(

	const MSIPExtendedConcreteProfileObserver& aObserver,

	TUint32 aSnapId)

	{

	iCurrentState->EnableSnapInUseL(*this, aObserver, aSnapId);

	}

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

// CSIPProfileCacheItem::DisableL

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

//

void CSIPProfileCacheItem::DisableL(

	const MSIPExtendedConcreteProfileObserver& aObserver)

	{

	iCurrentState->DisableL(*this, aObserver);

	}

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

// CSIPProfileCacheItem::RemoveL

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

//

void CSIPProfileCacheItem::RemoveL()

	{

	iCacheState = EToBeRemoved;

	iCurrentState->RemoveL(*this);

	}