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

// Part of       : Registration

// Version       : SIP/4.0 

//

#include "CSIPRegistrar.h"

#include "CSIPRegistrarStore.h"

#include "TSIPRegistrationUtility.h"

#include "uricontainer.h"

#include "siprequest.h"

#include "sipcallidheader.h"

#include "sipcseqheader.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

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

// CSIPRegistrar::NewLC

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

//

CSIPRegistrar* CSIPRegistrar::NewLC(const CURIContainer&  aRegistrar,

									const TDesC8&         aCallId,

									TUint                 aCSeqNumber, 

									const TRegistrationId aRegistrationId,

									CSIPRegistrarStore&   aRegistrarStore)

	{

    CSIPRegistrar* self = 

		new (ELeave) CSIPRegistrar(aCSeqNumber, aRegistrarStore);

	CleanupStack::PushL(self);

	self->ConstructL(aRegistrar, aCallId, aRegistrationId);

	return self;

	}

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

// CSIPRegistrar::CSIPRegistrar

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

//

CSIPRegistrar::CSIPRegistrar(TUint               aCSeqNumber, 

							 CSIPRegistrarStore& aRegistrarStore) 

 : iCSeqNumber     (aCSeqNumber),

   iRegistrarStore (aRegistrarStore)

	{

	}

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

// CSIPRegistrar::ConstructL

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

//

void CSIPRegistrar::ConstructL(const CURIContainer&  aRegistrar,

		                       const TDesC8&         aCallId,

							   const TRegistrationId aRegistrationId)

	{

	iRegistrar = CURIContainer::NewL(aRegistrar);

	iCallId    = aCallId.AllocL();

	User::LeaveIfError(iRegistrationIds.Append(aRegistrationId));

	}

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

// CSIPRegistrar::~CSIPRegistrar

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

//

CSIPRegistrar::~CSIPRegistrar()

	{

	delete iCallId;

	delete iRegistrar;

	iRegistrationIds.Reset();

	}

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

// CSIPRegistrar::Registrar

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

//

const CURIContainer& CSIPRegistrar::Registrar() const

	{

	return *iRegistrar;

	}

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

// CSIPRegistrar::IncreaseCSeqNumber

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

//

void CSIPRegistrar::IncreaseCSeqNumber()

	{

	iCSeqNumber++;

	}

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

// CSIPRegistrar::FillCallIdAndCSeqL

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

//

void CSIPRegistrar::FillCallIdAndCSeqL(CSIPRequest& aSIPRequest)

	{

	CSIPCallIDHeader* callId = CSIPCallIDHeader::DecodeL(*iCallId);

	CleanupStack::PushL(callId);

	// fill in callid header, and add it to request

	CSIPCallIDHeader* oldCallId = aSIPRequest.CallID();

	if (oldCallId)

		{

		aSIPRequest.ReplaceHeaderL(oldCallId, callId);

		}

	else // there are callId header in request

		{

		aSIPRequest.AddHeaderL(callId);

		}

	CleanupStack::Pop(callId);

	// increase the CSeqNumber by one

	IncreaseCSeqNumber();

    CSIPCSeqHeader* oldCSeqHeader = aSIPRequest.CSeq();

	if (oldCSeqHeader)

		{

		oldCSeqHeader->SetSeq(iCSeqNumber);

		}

	else

		{	

		// create a CSIPCSeqHeader header, and add it to request

		CSIPCSeqHeader* cseqHeader = CSIPCSeqHeader::NewLC(

			iCSeqNumber, SIPStrings::StringF(SipStrConsts::ERegister));

		aSIPRequest.AddHeaderL(cseqHeader);

		CleanupStack::Pop(cseqHeader);

		}

	}

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

// CSIPRegistrar::AddRegistrationIdL

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

//

void CSIPRegistrar::AddRegistrationIdL(const TRegistrationId aRegistrationId)

	{

	User::LeaveIfError(iRegistrationIds.Append(aRegistrationId));

	}

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

// CSIPRegistrar::BindingRemoved

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

//

TBool CSIPRegistrar::BindingRemoved(const TRegistrationId aRegistrationId)  

	{

	TInt idFound = FindRegistrationId(aRegistrationId);

	// there is no registration binding relate to this registrar,

	// remove the registrar

	if (idFound != KErrNotFound)

		{

		if (iRegistrationIds.Count() == 1)

			{

			// if registration is added to delete mgr succeed,

			// remove registration id

			TInt res = iRegistrarStore.RemoveRegistrar(this);

			if (res == KErrNone)

				{

				iRegistrationIds.Remove(idFound);

				return ETrue; 

				}

			else

				{

				return EFalse;

				}

			}

		else

			{

			iRegistrationIds.Remove(idFound);

			return ETrue;

			}

		}

	return EFalse;

	}  

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

// CSIPRegistrar::FindRegistrationId

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

//

TInt CSIPRegistrar::FindRegistrationId (const TRegistrationId aRegistrationId)

	{

	TInt idFound = KErrNotFound;

	for (TInt i=iRegistrationIds.Count()-1; (i>=0 && idFound==KErrNotFound); i--)

		{

		if (iRegistrationIds[i] == aRegistrationId)

			{

			return i;

			}

		}

	return idFound;

	}

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

// CSIPRegistrar::CSeqNumber

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

//

TUint CSIPRegistrar::CSeqNumber() const

	{

	return iCSeqNumber;

	}