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

// Part of       : SIPAPI

// Version       : SIP/6.0

//

#include <uri8.h>

#include "siperr.h"

#include "SipAssert.h"

#include "SipDialogImplementation.h"

#include "SipDialogAssocImplementation.h"

#include "sipinvitedialogassoc.h"

#include "sipsubscribedialogassoc.h"

#include "sipdialogstate.h"

#include "sipmessageelements.h"

#include "siprequestelements.h"

#include "sipresponseelements.h"

#include "SipConnectionImplementation.h"

#include "sipclientconnection.h"

#include "sipinviteclienttransaction.h"

#include "sipservertransaction.h"

#include "sipregistrationcontext.h"

#include "siprefresh.h"

#include "sipaddress.h"

#include "sipfromheader.h"

#include "siptoheader.h"

#include "sipcontactheader.h"

#include "sipcallidheader.h"

#include "sip.h"

#include "SipImplementation.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#ifdef CPPUNIT_TEST

#include "TestCleanupStack.h"

#endif

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

// CSIPDialogImplementation::NewLC

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

//

CSIPDialogImplementation* CSIPDialogImplementation::NewLC(

						CSIPConnectionImplementation& aConnImplementation,

						const MSIPRegistrationContext* aContext)

	{

	CSIPDialog* dialog = aContext ?

		CSIPDialog::NewL(aConnImplementation, *aContext) :

		CSIPDialog::NewL(aConnImplementation);	

    CSIPDialogImplementation* self = &dialog->Implementation();

    CleanupStack::PushL(self);

    return self;

	}

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

// CSIPDialogImplementation::NewL

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

//

CSIPDialogImplementation* CSIPDialogImplementation::NewL(

						CSIPDialog* aDialog,

						CSIPConnectionImplementation& aConnImplementation)

    {

    CSIPDialogImplementation* self =

    	new (ELeave) CSIPDialogImplementation(aConnImplementation);

    CleanupStack::PushL(self);

    self->ConstructL(aDialog);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPDialogImplementation::NewL

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

//

CSIPDialogImplementation* CSIPDialogImplementation::NewL(

							CSIPDialog* aDialog,

							CSIPConnectionImplementation& aConnImplementation,

                            const MSIPRegistrationContext& aContext)

    {

    CSIPDialogImplementation* self =

    	new (ELeave) CSIPDialogImplementation(aConnImplementation, aContext);

    CleanupStack::PushL(self);

    self->ConstructL(aDialog);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPDialogImplementation::CSIPDialogImplementation

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

//

CSIPDialogImplementation::CSIPDialogImplementation(

						CSIPConnectionImplementation& aConnImplementation) :

    iConnection(&aConnImplementation)

#ifdef CPPUNIT_TEST

    , iDialogAssocs(1)

#endif	

    {

    }

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

// CSIPDialogImplementation::CSIPDialogImplementation

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

//

CSIPDialogImplementation::CSIPDialogImplementation(

						CSIPConnectionImplementation& aConnImplementation,

                       	const MSIPRegistrationContext& aContext) :

    iConnection(&aConnImplementation),

    iRegistration(&aContext)

#ifdef CPPUNIT_TEST

    , iDialogAssocs(1)

#endif

	, iStringPoolOpened(EFalse)

    {

    }

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

// CSIPDialogImplementation::ConstructL

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

//

void CSIPDialogImplementation::ConstructL(CSIPDialog* aDialog)

    {

    CheckConnectionL();

    iConnection->AddDialogL(*this);

    iState = iConnection->InitialDialogStateL();

    iDialog = aDialog;

    SIPStrings::OpenL();

    iStringPoolOpened = ETrue;

    }

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

// CSIPDialogImplementation::~CSIPDialogImplementation

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

//

CSIPDialogImplementation::~CSIPDialogImplementation()

    {

    if (iConnection)

        {        

        iConnection->RemoveDialog(*this);

        }

    iDialogAssocs.Reset();

	delete iDialog;

    delete iFrom;

    delete iTo;

    delete iRemoteUri;

    delete iContact;

    delete iCallID;

	if (iStringPoolOpened)

		{

    	SIPStrings::Close();

		}

    }

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

// CSIPDialogImplementation::State

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

//

CSIPDialog::TState CSIPDialogImplementation::State() const

    {

    __TEST_INVARIANT;

    return iState ? iState->State() : CSIPDialog::ETerminated;

    }

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

// CSIPDialogImplementation::ChangeState

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

//

void CSIPDialogImplementation::ChangeState(const CDialogState* aNewState)

	{

    __TEST_INVARIANT;

	iState = aNewState;

    __TEST_INVARIANT;

	}

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

// CSIPDialogImplementation::ConnectionLost

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

//

void CSIPDialogImplementation::ConnectionLost()

    {

    __TEST_INVARIANT;

    if (iState)

        {        

        iState->ConnectionLost(*this);

        }

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

        {

        iDialogAssocs[i]->Implementation().ConnectionLost();

        }

    __TEST_INVARIANT;

    }

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

// CSIPDialogImplementation::SIPDialogAssociations

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

//

const RPointerArray<CSIPDialogAssocBase>&

CSIPDialogImplementation::SIPDialogAssociations() const

    {

    __TEST_INVARIANT;

    return iDialogAssocs;

    }

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

// CSIPDialogImplementation::RegistrationContext

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

//

const MSIPRegistrationContext*

CSIPDialogImplementation::RegistrationContext() const

    {

    __TEST_INVARIANT;

    return iRegistration;

    }

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

// CSIPDialogImplementation::IsAssociated

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

//

TBool

CSIPDialogImplementation::IsAssociated(const CSIPDialogAssocBase& aAssoc) const

    {

    __TEST_INVARIANT;

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

        {

        if (iDialogAssocs[i] == &aAssoc)

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CSIPDialogImplementation::Connection

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

//

CSIPConnection* CSIPDialogImplementation::Connection()

    {    

    return GetConnection();

    }

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

// CSIPDialogImplementation::Connection

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

//

const CSIPConnection* CSIPDialogImplementation::Connection() const

    {

    return GetConnection();

    }

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

// CSIPDialogImplementation::GetConnection

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

//

CSIPConnection* CSIPDialogImplementation::GetConnection() const

	{

	__TEST_INVARIANT;

	CSIPConnection* conn = NULL;

    if (iConnection)

    	{

    	TRAP_IGNORE((conn = &iConnection->SIPConnectionL()))

    	}

    return conn;

	}

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

// CSIPDialogImplementation::FromHeader

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

//

const CSIPFromHeader& CSIPDialogImplementation::FromHeader() const

    {

    __TEST_INVARIANT;

    return *iFrom;

    }

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

// CSIPDialogImplementation::ToHeader

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

//

const CSIPToHeader& CSIPDialogImplementation::ToHeader() const

    {

    __TEST_INVARIANT;

    return *iTo;

    }

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

// CSIPDialogImplementation::RemoteURI

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

//

const CUri8& CSIPDialogImplementation::RemoteURI() const

    {

    __ASSERT_DEBUG(iRemoteUri,

    	User::Panic(_L("CSIPDlgImp:RemoteURI"), KErrNotFound));

    return *iRemoteUri;

    }

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

// CSIPDialogImplementation::CallIdL

// If Call-ID doesn't exist yet, application has asked it too early.

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

//

const CSIPCallIDHeader& CSIPDialogImplementation::CallIdL() const

	{

	__ASSERT_ALWAYS(iCallID, User::Leave(KErrSIPInvalidDialogState));

	return *iCallID;

	}

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

// CSIPDialogImplementation::StoreCallIdL

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

//

void CSIPDialogImplementation::StoreCallIdL()

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(iDialogId != 0, KErrNotFound);	

	CheckConnectionL();

    CSIPCallIDHeader* tmp = iConnection->ClientConnectionL().CallIDL(iDialogId);

	delete iCallID;

	iCallID = tmp;

	}

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

// CSIPDialogImplementation::CopyCallIdL

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

//

void CSIPDialogImplementation::CopyCallIdL(

    const CSIPDialogImplementation& aDialog)

	{

	__TEST_INVARIANT;	

	CSIPCallIDHeader* tmp = 

	    static_cast<CSIPCallIDHeader*>(aDialog.CallIdL().CloneL());

	delete iCallID;

	iCallID = tmp;

	}

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

// CSIPDialogImplementation::operator==

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

//

TBool CSIPDialogImplementation::operator==(

						const CSIPDialogImplementation& aDialog) const

    {

    __TEST_INVARIANT;

    return this == &aDialog ||

    	   (iDialogId && aDialog.iDialogId && (iDialogId == aDialog.iDialogId));

    }

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

// CSIPDialogImplementation::ReuseInitialRequestData

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

//

TInt CSIPDialogImplementation::ReuseInitialRequestData()

    {

    TInt err = KErrSIPInvalidDialogState;

    if (iState && iState->State() == CSIPDialog::ETerminated &&

        iConnection && iConnection->SIP() && iConnection->ClientConnection())

        {

        TUint32 originalRequestId = iInitialRequestId;

        iInitialRequestId = 0;

        const CDialogState* originalState = iState;

        iState = iConnection->SIP()->Implementation().InitialDialogState();

        err = iConnection->ClientConnection()->ResetDialogState(iDialogId);

        if (err != KErrNone)

            {

            // Rollback to the original state

            iInitialRequestId = originalRequestId;

            iState = originalState;

            }

        else

            {

            iTo->DeleteParam(SIPStrings::StringF(SipStrConsts::ETag));

            }

        }       

    return err;

    }

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

// CSIPDialogImplementation::Dialog

// Don't use invariant here.

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

//

CSIPDialog& CSIPDialogImplementation::Dialog()

	{

	__ASSERT_DEBUG(iDialog, User::Panic(_L("CSIPDlgImp:Dialog"), KErrNotFound));

	return *iDialog;

	}

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

// CSIPDialogImplementation::IncomingResponseL

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

//

TBool

CSIPDialogImplementation::IncomingResponseL(CSIPResponseElements* aElements,

				                            TUint32 aRequestId,

		                                    TUint32 aDialogId,

		                                    CConnectionCallback& aCallback)

    {

    __TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aElements != NULL, KErrArgument);

    if (iState)

        {

        return iState->IncomingResponseL(*this,

                                         aElements,

		                                 aRequestId,

                                         aDialogId,

                                         aCallback);

        }

    delete aElements;

    return EFalse;    

    }

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

// CSIPDialogImplementation::IncomingResponseL

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

//

TBool

CSIPDialogImplementation::IncomingResponseL(CSIPResponseElements* aElements,

				                            TUint32 aRequestId,

		                                    TUint32 aRefreshId,

							                TUint32 aDialogId,

		                                    CConnectionCallback& aCallback)                                   

    {

    __TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aElements != NULL, KErrArgument);

    if (iState)

        {

        return iState->IncomingResponseL(*this,

                                         aElements,

		                                 aRequestId,

                                         aRefreshId,

                                         aDialogId,

                                         aCallback);

        }

    delete aElements;

    return EFalse;

    }

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

// CSIPDialogImplementation::IncomingRequest

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

//

TBool CSIPDialogImplementation::IncomingRequestL(

									CSIPServerTransaction* aTransaction,

                                   	CConnectionCallback& aCallback)                                  

    {

    __TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aTransaction != NULL, KErrArgument);

    if (iState)

        {

        return iState->IncomingRequestL(*this, aTransaction, aCallback);

        }

    delete aTransaction;

    return EFalse;

    }

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

// CSIPDialogImplementation::ErrorOccured

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

//

TBool CSIPDialogImplementation::ErrorOccured(TInt aError,

				                             TUint32 aRequestId,

				                             CConnectionCallback& aCallback)

    {

    __TEST_INVARIANT;

    return iState &&

    	   iState->ErrorOccured(*this, aError, aRequestId, aCallback);

    }

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

// CSIPDialogImplementation::ErrorOccured

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

//

TBool CSIPDialogImplementation::ErrorOccured(TInt aError,             

				                             TUint32 aRefreshId,

				                             TUint32 aRequestId,

				                             CConnectionCallback& aCallback)

    {

    __TEST_INVARIANT;

    return iState &&

    	iState->ErrorOccured(*this, aError, aRefreshId, aRequestId, aCallback);        

    }

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

// CSIPDialogImplementation::DialogId

// Don't use invariant here.

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

//

TUint32 CSIPDialogImplementation::DialogId() const

    {    

    return iDialogId;

    }

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

// CSIPDialogImplementation::SetDialogId