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

// Part of     : sip ietf plugin

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include	"sipietfprofileagent.h"

#include    "sipconcreteprofile.h"

#include	"sipprofileagentobserver.h"

#include	"sipconnection.h"

#include	"sipprflinitstate.h"

#include	"sipprflresolvingproxiesstate.h"

#include	"sipprflregisterrequestedstate.h"

#include	"sipprflregisterdelayrequestedstate.h"

#include	"sipprflregistrationinprogressstate.h"

#include	"sipprflregisteredstate.h"

#include	"sipprflderegistrationinprogressstate.h"

#include	"sipprflderegisterrequestedstate.h"

#include	"sipprflstatebase.h"

#include	"sipietfprofilecontext.h"

#include	"sipgendefs.h"

#include	"SipProfileLog.h"

#include    "sipstrings.h"

#include    "sipstrconsts.h"

#include    "sipprofilequeuehandling.h"

#include    <sip.h>

#include    <siphttpdigest.h>

#include    <sipservertransaction.h>

#include    <sipprofile.h>

_LIT8(KSIPIETFProfileType, "IETF");

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

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

// CSIPIetfProfileAgent::NewL

// Two-phased constructor.

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

//

CSIPIetfProfileAgent* CSIPIetfProfileAgent::NewL(TAny* aInitParams)

	{

	CSIPIetfProfileAgent* self = new (ELeave) CSIPIetfProfileAgent(

		static_cast<TSIPProfileAgentInitParams*>(aInitParams));

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPIetfProfileAgent::CSIPIetfProfileAgent

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSIPIetfProfileAgent::CSIPIetfProfileAgent(

    TSIPProfileAgentInitParams* aInitParams)

    : iSIPProfileAgentObserver(aInitParams->iSIPProfileAgentObserver),

      iDeltaTimer(aInitParams->iDeltaTimer)

	{

	iType.iSIPProfileClass = TSIPProfileTypeInfo::EInternet;

	iType.iSIPProfileName = KSIPIetfType();

	}

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

// CSIPIetfProfileAgent::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSIPIetfProfileAgent::ConstructL()

    {

    SIPStrings::OpenL();

	iInit = CSIPPrflInitState::NewL(*this);

	iResolvingProxies = CSIPPrflResolvingProxiesState::NewL(*this);

	iRegRequested = CSIPPrflRegisterRequestedState::NewL(*this);

	iRegInProgress = CSIPPrflRegistrationInProgressState::NewL(*this);

	iRegistered = CSIPPrflRegisteredState::NewL(*this);

	iDeregRequested = CSIPPrflDeregisterRequestedState::NewL(*this);

	iDeregInProgress = CSIPPrflDeregistrationInProgressState::NewL(*this);

	iRegDelayRequested = CSIPPrflRegisterDelayRequestedState::NewL(*this);

	iInit->LinkStates(*iResolvingProxies, *iRegRequested, *iRegInProgress);

	iResolvingProxies->LinkStates(*iInit, *iRegRequested, *iRegInProgress);

	iRegRequested->LinkStates(*iInit, *iResolvingProxies, *iRegInProgress);

	iRegInProgress->LinkStates(*iRegRequested, *iInit, *iRegistered,

	                           *iRegDelayRequested);

	iRegistered->LinkStates(*iDeregRequested, *iDeregInProgress,

							 *iInit, *iRegRequested,*iRegDelayRequested);

	iDeregRequested->LinkStates(*iInit, *iRegistered, *iDeregInProgress);

	iDeregInProgress->LinkStates(*iInit);

	iRegDelayRequested->LinkStates(*iInit);

	iProfileQueueHandling = CSIPProfileQueueHandling::NewL(*this);

	iSIP = CSIP::NewL(TUid::Null(),*this);

	iHttpDigest = CSIPHttpDigest::NewL(*iSIP,*this);

	iConfigExtension = NULL;

    }

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

// CSIPIetfProfileAgent::~CSIPIetfProfileAgent

// Symbian 2nd phase constructor can leave.

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

//

CSIPIetfProfileAgent::~CSIPIetfProfileAgent()

	{

	delete iInit;

	delete iResolvingProxies;

	delete iRegRequested;

	delete iRegistered;

	delete iRegInProgress;

	delete iDeregRequested;

	delete iDeregInProgress;

	delete iRegDelayRequested;

	delete iProfileQueueHandling;

	iConnectionCtxArray.ResetAndDestroy();

	iConnectionCtxArray.Close();

	SIPStrings::Close();

	delete iHttpDigest;

	delete iSIP;

	}

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

// CSIPIetfProfileAgent::SIPProfileAgentType

// (other items were commented in a header).

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

//

const TSIPProfileTypeInfo& CSIPIetfProfileAgent::Type() const

	{

	return iType;

	}

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

// CSIPIetfProfileAgent::CreateL

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

//

CSIPConcreteProfile* CSIPIetfProfileAgent::CreateL()

	{

	TSIPProfileTypeInfo type;		

	type.iSIPProfileClass = TSIPProfileTypeInfo::EInternet;

	type.iSIPProfileName = KSIPIETFProfileType;

	CSIPConcreteProfile* profile = CSIPConcreteProfile::NewL();

	profile->SetProfileType(type);

	return profile;

	}

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

// CSIPIetfProfileAgent::RegisterL

// (other items were commented in a header).

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

//

void CSIPIetfProfileAgent::RegisterL(

	CSIPConcreteProfile& aSIPConcreteProfile)

	{

	__ASSERT_ALWAYS (aSIPConcreteProfile.AOR().Length() > 0, 

		User::Leave(KErrArgument));

	__ASSERT_ALWAYS (aSIPConcreteProfile.Server(KSIPRegistrar).Length(),

		User::Leave(KErrArgument));

	PROFILE_DEBUG3("CSIPIetfProfileAgent::RegisterL", aSIPConcreteProfile.Id())

	if (!iProfileQueueHandling->AddRegisterToQueueL( aSIPConcreteProfile, 

	                                                 EFalse ))

		{

        CSIPIetfProfileContext* context = FindProfileContext(aSIPConcreteProfile);

        if (!context)

	        {

	        context = &ProvideProfileContextL(aSIPConcreteProfile);

	        }		

        context->RegisterL();

		}

	}

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

// CSIPIetfProfileAgent::UpdateL

// (other items were commented in a header).

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

//

void CSIPIetfProfileAgent::UpdateL(

	CSIPConcreteProfile& aNewProfile, 

	CSIPConcreteProfile& aOldProfile)

	{

	PROFILE_DEBUG3("CSIPIetfProfileAgent::UpdateL", aOldProfile.Id())

	iProfileQueueHandling->Cleanup(aOldProfile,&aNewProfile);

	CSIPIetfProfileContext* context = FindProfileContext(aOldProfile);

	if (!context)

	    {

	    User::Leave(KErrNotFound);

	    }

	context->UpdateL(aNewProfile);

	}

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

// CSIPIetfProfileAgent::DeregisterL

// (other items were commented in a header).

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

//

void CSIPIetfProfileAgent::DeregisterL(

	CSIPConcreteProfile& aSIPConcreteProfile)

	{

	PROFILE_DEBUG3("CSIPIetfProfileAgent::DeregisterL", aSIPConcreteProfile.Id())

	CSIPIetfProfileContext* context = FindProfileContext(aSIPConcreteProfile);

	if ( context )

		{

		if ( !DeregisterToWaitingQueueL( context ))

			{

			context->DeregisterL();

			}

		}

	else

		{

		iProfileQueueHandling->RemoveProfileFromRegQueueL(aSIPConcreteProfile);

		}	 

	}

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

// CSIPIetfProfileAgent::GetProfileState

// (other items were commented in a header).

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

//

TInt CSIPIetfProfileAgent::GetProfileState(

	CSIPConcreteProfile::TStatus& aState, 

	CSIPConcreteProfile& aProfile) const

	{

	CSIPIetfProfileContext* context = FindProfileContext(aProfile);

	if (context)

		{

		aState = context->CurrentMappedState();

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}

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

// CSIPIetfProfileAgent::IsIdle

// (other items were commented in a header).

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

//

TBool CSIPIetfProfileAgent::IsIdle()

	{

	CleanIdleConnectionContexts();

	return (iConnectionCtxArray.Count()==0);

	}

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

// CSIPIetfProfileAgent::RegisterPending

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

//	

TBool CSIPIetfProfileAgent::RegisterPending(

    CSIPConcreteProfile& aSIPProfile) const

    {

    PROFILE_DEBUG3("CSIPIetfProfileAgent::IsRegisterPending", aSIPProfile.Id()) 

	CSIPIetfProfileContext* context = FindProfileContext(aSIPProfile);

	if (context)

		{

		return context->IsRegisterPending();

		}

	return EFalse;

    }

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

// CSIPIetfProfileAgent::TerminateHandling

// (other items were commented in a header).

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

//

TInt CSIPIetfProfileAgent::TerminateHandling(CSIPConcreteProfile& aProfile)

	{

	CSIPIetfProfileContext* context = FindProfileContext(aProfile);

	if (context)

		{

		PROFILE_DEBUG3("CSIPIetfProfileAgent::TerminateHandling", aProfile.Id())

		context->SetNextState(*iInit);

		context->TerminateHandling();

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}

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

// CSIPIetfProfileAgent::Extension

// (other items were commented in a header).

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

//

TInt CSIPIetfProfileAgent::Extension(TInt aOperationCode, TAny* aParams)

    {

    TInt err(KErrNone);

    if(aParams && aOperationCode == KSipProfileAgentConfigExtension)

    	iConfigExtension = static_cast<CSipProfileAgentConfigExtension*>(aParams);

    else

    	err = KErrNotSupported;

    return err;

    }

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

// CSIPIetfProfileAgent::SIPProfileStatusEvent

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

//

void CSIPIetfProfileAgent::SIPProfileStatusEvent(

	CSIPConcreteProfile& aProfile,

	TUint32 aContextId)

	{

	PROFILE_DEBUG4("CSIPIetfProfileAgent::SIPProfileStatusEvent",\

		aProfile.Id(), aContextId)

	RegisterQueue( aProfile, ETrue );

	iSIPProfileAgentObserver.SIPProfileStatusEvent( aProfile, aContextId );

	}

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

// CSIPIetfProfileAgent::SIPProfileErrorEvent

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

//

void CSIPIetfProfileAgent::SIPProfileErrorEvent(

    CSIPConcreteProfile& aProfile,

    TInt aError)

	{

	PROFILE_DEBUG4("CSIPIetfProfileAgent::ErrorEvent", aProfile.Id(), aError)

	CSIPIetfProfileContext* context = FindProfileContext(aProfile.Id());

	if (context && context->IgnoreErrorEvent())

		{

		PROFILE_DEBUG4("CSIPIetfProfileAgent::Error ignored",\

                       aProfile.Id(), aError)	

		}

	else

		{

		PROFILE_DEBUG4("CSIPIetfProfileAgent::Error sent", 

		               aProfile.Id(), aError)

		RegisterQueue( aProfile, EFalse );

		iSIPProfileAgentObserver.SIPProfileErrorEvent(aProfile,aError);

		}

	}

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

// CSIPIetfProfileAgent::ProceedRegistration

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

//

TBool CSIPIetfProfileAgent::ProceedRegistration(

	CSIPConcreteProfile& aProfile,

	TInt aError)

	{

	PROFILE_DEBUG3("CSIPIetfProfileAgent::ProceedRegistration", aProfile.Id())

	return iSIPProfileAgentObserver.ProceedRegistration(aProfile, aError);

	}

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

// CSIPIetfProfileAgent::GetFailedProfilesL

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

//

void CSIPIetfProfileAgent::GetFailedProfilesL(

    const TSIPProfileTypeInfo& /*aType*/,

    RPointerArray<CSIPConcreteProfile>& /*aFailedProfiles*/) const

	{

	}

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

// CSIPIetfProfileAgent::RegisterProfileL

// From MSIPProfileFSMUser

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

//	

void CSIPIetfProfileAgent::RegisterProfileL(

    CSIPConcreteProfile& aSIPProfile)

    {

    RegisterL(aSIPProfile);

    }

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

// CSIPIetfProfileAgent::DeregisterProfileL

// From MSIPProfileFSMUser

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

//

void CSIPIetfProfileAgent::DeregisterProfileL(

    CSIPConcreteProfile& aSIPProfile)

    {

    DeregisterL(aSIPProfile);

    }

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

// CSIPIetfProfileAgent::RetryProfileRegistrationL

// From MSIPProfileFSMUser

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

//

void CSIPIetfProfileAgent::RetryProfileRegistrationL( 

    CSIPConcreteProfile& aSIPProfile)

    {

	PROFILE_DEBUG3("CSIPIetfProfileAgent::RetryProfileRegistrationL", 

	               aSIPProfile.Id())

	if (!iProfileQueueHandling->AddRegisterToQueueL(aSIPProfile, ETrue))

		{

        CSIPIetfProfileContext* context = FindProfileContext(aSIPProfile);

        if (!context)

	        {

	        User::Leave(KErrNotFound);

	        }		

        context->RetryRegistration();

		}    

    }

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

// CSIPIetfProfileAgent::AddProfileIntoQueue

// From MSIPProfileFSMUser

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

//

TBool CSIPIetfProfileAgent::AddProfileIntoQueue(

    CSIPConcreteProfile& aSIPProfile) const

    {

    PROFILE_DEBUG3("CSIPIetfProfileAgent::AddProfileIntoQueue", 

                   aSIPProfile.Id())

	TBool found = EFalse;

	for (TInt i=0; i < iConnectionCtxArray.Count() && !found; i++)

		{

		found = iConnectionCtxArray[i]->AddIntoQueue(

		    aSIPProfile.Server(KSIPRegistrar));

		}

	return found;

    }

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

// CSIPIetfProfileAgent::RegisterProfileAfterQueueL

// From MSIPProfileFSMUser

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

//

void CSIPIetfProfileAgent::RegisterProfileAfterQueueL(

    CSIPConcreteProfile& aSIPProfile)

    {

	PROFILE_DEBUG3("CSIPIetfProfileAgent::RegisterProfileAfterQueueL", 

	               aSIPProfile.Id())    

    CSIPIetfProfileContext* context = FindProfileContext(aSIPProfile);

	if (!context)

	    {

	    context = &ProvideProfileContextL(aSIPProfile);

	    } 

	context->RegisterL();   

    }

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

// CSIPIetfProfileAgent::DeregisterProfileAfterQueueL

// From MSIPProfileFSMUser

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

//

void CSIPIetfProfileAgent::DeregisterProfileAfterQueueL(

    CSIPConcreteProfile& aSIPProfile)

    {

	PROFILE_DEBUG3("CSIPIetfProfileAgent::DeregisterProfileAfterQueueL", 

	               aSIPProfile.Id())    

    CSIPIetfProfileContext* context = FindProfileContext(aSIPProfile);

    __ASSERT_ALWAYS(context != NULL, User::Leave(KErrNotFound));

    context->DeregisterL();

    }

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

// CSIPIetfProfileAgent::RetryProfileRegistrationAfterQueueL

// From MSIPProfileFSMUser

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

//

void CSIPIetfProfileAgent::RetryProfileRegistrationAfterQueueL(

    CSIPConcreteProfile& aSIPProfile)

    {

	PROFILE_DEBUG3("CSIPIetfProfileAgent::RetryProfileRegistrationAfterQueueL", 

	               aSIPProfile.Id())    

    CSIPIetfProfileContext* context = FindProfileContext(aSIPProfile);

    __ASSERT_ALWAYS(context != NULL, User::Leave(KErrNotFound));

    context->RetryRegistration();   

    }

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

// CSIPIetfProfileAgent::IsInQueue

// From MSIPProfileFSMUser

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

//

TBool CSIPIetfProfileAgent::IsInQueue(

    CSIPConcreteProfile& aSIPProfile) const

    {

    PROFILE_DEBUG1("CSIPIetfProfileAgent::IsInQueue")

	PROFILE_DEBUG3("CSIPIetfProfileAgent::IsInQueue", 

	               aSIPProfile.Id())    

    return iProfileQueueHandling->IsInQueue(aSIPProfile);

    }

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

// CSIPIetfProfileAgent::SetInterimProfile

// (other items were commented in a header).

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

//

void CSIPIetfProfileAgent::SetInterimProfile( CSIPConcreteProfile* /*aSIPConcreteProfile*/ )

	{

	}

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

// CSIPIetfProfileAgent::IncomingRequest

// From MSIPObserver

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

//

void CSIPIetfProfileAgent::IncomingRequest(

    TUint32 /*aIapId*/,