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

// Part of       : SIPAPI

// Version       : SIP/5.0 

//

#include <uri8.h>

#include "sip.h"

#include "siperr.h"

#include "sipinvitedialogassoc.h"

#include "SipDialogImplementation.h"

#include "SipDialogAssocImplementation.h"

#include "SipConnectionImplementation.h"

#include "sipinviteclienttransaction.h"

#include "sipservertransaction.h"

#include "sipclientconnection.h"

#include "sipregistrationcontext.h"

#include "sipmessageelements.h"

#include "siptoheader.h"

#include "sipfromheader.h"

#include "sipcontactheader.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "MessageHeaderCleanup.h"

#ifdef CPPUNIT_TEST

#include "TestCleanupStack.h"

#undef EXPORT_C

#define EXPORT_C

#endif

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

// CSIPInviteDialogAssoc::NewL

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewL(CSIPDialog& aDialog)

    {

    CSIPInviteDialogAssoc* self = CSIPInviteDialogAssoc::NewLC(aDialog);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewLC

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewLC(CSIPDialog& aDialog)

    {

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

    CleanupStack::PushL(self);

    self->CSIPDialogAssocBase::ConstructL(

    	SIPStrings::StringF(SipStrConsts::EInvite), aDialog);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewL

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewL(CSIPServerTransaction& aTransaction)

    {    

    CSIPInviteDialogAssoc* self = CSIPInviteDialogAssoc::NewLC(aTransaction);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewLC

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewLC(CSIPServerTransaction& aTransaction)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aTransaction,NULL);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewL

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewL(CSIPServerTransaction& aTransaction,

                            const MSIPRegistrationContext& aContext)

    {    

    CSIPInviteDialogAssoc* self = 

        CSIPInviteDialogAssoc::NewLC(aTransaction,aContext);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewLC

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewLC(CSIPServerTransaction& aTransaction,

                             const MSIPRegistrationContext& aContext)

    {    

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

    CleanupStack::PushL(self);

    self->ConstructL(aTransaction,&aContext);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewL

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewL(CSIPConnection& aConnection,

                            CSIPFromHeader* aFrom,

                            CUri8* aRemoteUri,

                            CSIPToHeader* aTo,                            

                            CSIPContactHeader* aContact)                            

    {

    CSIPInviteDialogAssoc* self = CSIPInviteDialogAssoc::NewLC(aConnection,

                                                               aFrom,

                                                               aRemoteUri,

                                                               aTo,                                                               

                                                               aContact);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewLC

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewLC(CSIPConnection& aConnection,

                             CSIPFromHeader* aFrom,

                             CUri8* aRemoteUri,

                             CSIPToHeader* aTo,                             

                             CSIPContactHeader* aContact)

    {

    __ASSERT_ALWAYS(aFrom, User::Leave(KErrArgument));

	return CSIPInviteDialogAssoc::NewLC(aConnection,

										aRemoteUri,

										aFrom,

										aTo,

										aContact,

										NULL);

    }

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

// CSIPInviteDialogAssoc::NewL

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewL(CSIPConnection& aConnection,                                            

                            CUri8* aRemoteUri,

                            const MSIPRegistrationContext& aContext,

                            CSIPFromHeader* aFrom,

                            CSIPToHeader* aTo,	                        

	                        CSIPContactHeader* aContact)

    {

    CSIPInviteDialogAssoc* self = CSIPInviteDialogAssoc::NewLC(aConnection,

    														   aRemoteUri,                                                               

                                                               aContext,

                                                               aFrom,

                                                               aTo,

                                                               aContact);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPInviteDialogAssoc::NewLC

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

//

EXPORT_C CSIPInviteDialogAssoc*

CSIPInviteDialogAssoc::NewLC(CSIPConnection& aConnection,

							 CUri8* aRemoteUri,

                             const MSIPRegistrationContext& aContext,

                             CSIPFromHeader* aFrom,

                             CSIPToHeader* aTo,	                        

	                         CSIPContactHeader* aContact)

    {    

    __ASSERT_ALWAYS(aContext.IsContextActive(),

                    User::Leave(KErrSIPInvalidRegistrationState));

	return CSIPInviteDialogAssoc::NewLC(aConnection,

										aRemoteUri,

										aFrom,

										aTo,

										aContact,

										&aContext);

    }

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

// CSIPInviteDialogAssoc::NewLC

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

//

CSIPInviteDialogAssoc* CSIPInviteDialogAssoc::NewLC(CSIPConnection& aConnection,

								 CUri8* aRemoteUri,

	                             CSIPFromHeader* aFrom,

	                             CSIPToHeader* aTo,

		                         CSIPContactHeader* aContact,

		                         const MSIPRegistrationContext* aContext)

	{

	__ASSERT_ALWAYS(aRemoteUri, User::Leave(KErrArgument));

	CSIPDialogImplementation* dialogImpl =

			CSIPDialogImplementation::NewLC(aConnection.Implementation(),

											aContext);

	//Associates dialogImpl with CSIPInviteDialogAssoc

    CSIPInviteDialogAssoc* self =

    	CSIPInviteDialogAssoc::NewL(dialogImpl->Dialog());

	CleanupStack::Pop(dialogImpl);

    CleanupStack::PushL(self);

    //Ownership of headers is passed when leave can't occur

    dialogImpl->SetHeadersL(aFrom, aTo, aRemoteUri, aContact);

    return self;

	}

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

// CSIPInviteDialogAssoc::CSIPInviteDialogAssoc

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

//

CSIPInviteDialogAssoc::CSIPInviteDialogAssoc()

    {

    }

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

// CSIPInviteDialogAssoc::~CSIPInviteDialogAssoc

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

//

EXPORT_C CSIPInviteDialogAssoc::~CSIPInviteDialogAssoc()

    {    

    }

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

// CSIPInviteDialogAssoc::SendInviteL

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

//

EXPORT_C CSIPClientTransaction*

CSIPInviteDialogAssoc::SendInviteL(CSIPMessageElements* aElements)

    {    

    return Dialog().Implementation().SendInviteL(*this, aElements);

    }

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

// CSIPInviteDialogAssoc::SendPrackL

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

//

EXPORT_C CSIPClientTransaction*

CSIPInviteDialogAssoc::SendPrackL(CSIPMessageElements* aElements)

    {    

    return Dialog().Implementation().SendPrackL(*this, aElements);

    }

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

// CSIPInviteDialogAssoc::SendUpdateL

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

//

EXPORT_C CSIPClientTransaction*

CSIPInviteDialogAssoc::SendUpdateL(CSIPMessageElements* aElements)

    {

    return Dialog().Implementation().SendUpdateL(*this, aElements);    

    }

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

// CSIPInviteDialogAssoc::SendAckL

// aTransaction must be INVITE transaction

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

//

EXPORT_C void CSIPInviteDialogAssoc::SendAckL(

                           const CSIPClientTransaction& aTransaction,

                           CSIPMessageElements* aElements)

    {

    __ASSERT_ALWAYS(aTransaction.Type() == Type(), User::Leave(KErrArgument));

    Dialog().Implementation().SendAckL(*this, aTransaction, aElements);

    }

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

// CSIPInviteDialogAssoc::SendByeL

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

//

EXPORT_C CSIPClientTransaction*

CSIPInviteDialogAssoc::SendByeL(CSIPMessageElements* aElements)

    {

    return Dialog().Implementation().SendByeL(*this, aElements);

    }

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

// CSIPInviteDialogAssoc::DoSendInviteL

// CSIPClientConnection checks connection state is active.

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

//

CSIPClientTransaction*

CSIPInviteDialogAssoc::DoSendInviteL(CSIPMessageElements* aElements)

    {

	CSIPMessageElements* elem = aElements;

    if (!aElements)

    	{

    	elem = CSIPMessageElements::NewLC();

    	}

    TMessageHeaderCleanup headerCleanup(*elem);

    TCleanupItem cleanupItem(TMessageHeaderCleanup::Cleanup, &headerCleanup);

    if (aElements)

    	{

    	CleanupStack::PushL(cleanupItem);

    	}

   	const CSIPContactHeader* contact =

   		Dialog().Implementation().ContactHeader();

	if (contact)

		{

		CSIPDialogAssocImplementation::CopyHeaderL(*contact,

												   *elem,

												   headerCleanup);

		}

	CSIPClientTransaction* ta =

		Dialog().Implementation().SendDialogCreatingRequestL(Implementation(),

															 elem);

    CleanupStack::Pop(); //TCleanupItem or elem

    return ta;

    }

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

// CSIPInviteDialogAssoc::DoSendAckL

// Ownership of aElements is taken when leave can't occur.

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

//

void

CSIPInviteDialogAssoc::DoSendAckL(const CSIPClientTransaction& aTransaction,

                                  CSIPMessageElements* aElements)

    {

    Implementation().ClientConnectionL().SendAckL(

    							Dialog().Implementation().DialogId(),

                                aTransaction.RequestId(),

                                aElements);

    delete aElements;

    }

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

// CSIPInviteDialogAssoc::DoSendRequestWithinDialogL

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

//

CSIPClientTransaction*

CSIPInviteDialogAssoc::DoSendRequestWithinDialogL(RStringF aMethod,

											CSIPMessageElements* aElements)

    {

    return Dialog().Implementation().SendRequestInDialogL(Implementation(),

					                                      aMethod,

					                                      aElements);

    }

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

// CSIPInviteDialogAssoc::DoSendCancelL

// CANCEL is a request outside dialog, so associate the transaction with

// CSIPConnection.

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

//

CSIPClientTransaction* CSIPInviteDialogAssoc::DoSendCancelL(TUint32 aRequestId)

    {

    CSIPClientTransaction* ta = CSIPClientTransaction::NewLC(

						SIPStrings::StringF(SipStrConsts::ECancel),                        

                        Implementation().SIPConnectionL().Implementation());

    TUint32 cancelRequestId(0);

    Implementation().ClientConnectionL().SendCancelL(aRequestId,

    												 cancelRequestId);

	CleanupStack::Pop(ta);

	ta->SetRequestId(cancelRequestId);

    return ta;

    }

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

// CSIPInviteDialogAssoc::ConstructL

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

//    

void CSIPInviteDialogAssoc::ConstructL(CSIPServerTransaction& aTransaction,

                                       const MSIPRegistrationContext* aContext)

    {

    __ASSERT_ALWAYS(

    	aTransaction.Type() == SIPStrings::StringF(SipStrConsts::EInvite),

    	User::Leave(KErrArgument));

    __ASSERT_ALWAYS(aTransaction.StateL() == CSIPTransactionBase::EProceeding,

        User::Leave(KErrSIPInvalidTransactionState));

	CSIPDialogImplementation* dialogImpl = aTransaction.Dialog();

	TBool createNewDialog = (dialogImpl == NULL);

	if (createNewDialog)

		{

		//Push dialogImpl to CleanupStack until it is associated with

		//CSIPInviteDialogAssoc. Once associated, it is deleted if

		//CSIPInviteDialogAssoc is deleted.

		dialogImpl = CSIPDialogImplementation::NewLC(

			aTransaction.SIPConnectionL().Implementation(),aContext);

		}

    //Associates dialogImpl with CSIPInviteDialogAssoc

    CSIPDialogAssocBase::ConstructL(SIPStrings::StringF(SipStrConsts::EInvite),

						    	    dialogImpl->Dialog(),aTransaction);

	if (createNewDialog)

    	{

    	CleanupStack::Pop(dialogImpl);

    	dialogImpl->InitialTransactionReceivedL(aTransaction);

    	}    

    }