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

// Part of       : SIPAPI

// Version       : SIP/5.0

//

#include "sip.h"

#include "siperr.h"

#include "SipAssert.h"

#include "SipDialogImplementation.h"

#include "sipclienttransaction.h"

#include "SipConnectionImplementation.h"

#include "siprefresh.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#ifdef CPPUNIT_TEST

#include "TestCleanupStack.h"

#undef EXPORT_C

#define EXPORT_C

#endif

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

// CSIPClientTransaction::NewL

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

//

CSIPClientTransaction*

CSIPClientTransaction::NewL(RStringF aType,

                            MTransactionAssociation& aAssociation,

                            CSIPRefresh* aRefresh)

    {

    CSIPClientTransaction* self = CSIPClientTransaction::NewLC(aType,

                                                               aAssociation,

                                                               aRefresh);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPClientTransaction::NewLC

// For INVITE client transaction, CSIPInviteClientTransaction must be used.

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

//

CSIPClientTransaction*

CSIPClientTransaction::NewLC(RStringF aType,

                             MTransactionAssociation& aAssociation,

                             CSIPRefresh* aRefresh)

    {

    __ASSERT_ALWAYS(aType != SIPStrings::StringF(SipStrConsts::EInvite),

                    User::Leave(KErrArgument));

    CSIPClientTransaction* self =

        new (ELeave) CSIPClientTransaction(aAssociation, aRefresh);

    CleanupStack::PushL(self);

    self->CSIPTransactionBase::ConstructL(aType);

    return self;

    }

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

// CSIPClientTransaction::CSIPClientTransaction

// RequestId is not yet known.

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

//

CSIPClientTransaction::CSIPClientTransaction(

	MTransactionAssociation& aAssociation,

	CSIPRefresh* aRefresh) :

    CSIPTransactionBase(ETrue, 0, aAssociation),

    iRefresh(aRefresh)

    {

    if (iRefresh)

        {

        iRefresh->AddTransaction(*this);

        }

    }

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

// CSIPClientTransaction::~CSIPClientTransaction

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

//

EXPORT_C CSIPClientTransaction::~CSIPClientTransaction()

    {

    if (iRefresh)

        {

        iRefresh->RemoveTransaction();

        }

    }

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

// CSIPClientTransaction::ResponseElements

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

//

EXPORT_C const CSIPResponseElements*

CSIPClientTransaction::ResponseElements() const

    {

    return CSIPTransactionBase::ResponseElements();

    }

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

// CSIPClientTransaction::CancelL

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

//

EXPORT_C CSIPClientTransaction* CSIPClientTransaction::CancelL()

    {

    __ASSERT_ALWAYS(CancelAllowed(),

        User::Leave(KErrSIPInvalidTransactionState));

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

        User::Leave(KErrSIPInvalidTransactionState));

    CheckAssociationL();

    CSIPDialogImplementation* dialog = iAssociation->SIPConnectionL().

    	Implementation().FindDialogByRequestId(iRequestId);

    if (!dialog)

        {

        User::Leave(KErrSIPInvalidTransactionState);

        }

    //Don't pass iAssociation to SendCancelL as user may have deleted the dialog

    //association used by this transaction. In that case iAssociation is NULL.

    //Dialog searches the dialog association with requestId. If it can't find

    //it, something is wrong and CANCEL can't be sent.

    return dialog->SendCancelL(iRequestId);

    }

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

// CSIPClientTransaction::Refresh

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

//

EXPORT_C const CSIPRefresh* CSIPClientTransaction::Refresh() const

    {

    return iRefresh;

    }

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

// CSIPClientTransaction::CancelAllowed

// Only INVITE client transaction can be canceled

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

//

EXPORT_C TBool CSIPClientTransaction::CancelAllowed() const

    {

    return EFalse;

    }

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

// CSIPClientTransaction::SetRequestId

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

//

void CSIPClientTransaction::SetRequestId(TUint32 aRequestId)

	{

	__SIP_ASSERT_RETURN(!iRequestId, KErrAlreadyExists);

	__SIP_ASSERT_RETURN(aRequestId, KErrArgument);

	iRequestId = aRequestId;

	}

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

// CSIPClientTransaction::Refresh

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

//

CSIPRefresh* CSIPClientTransaction::Refresh()

    {

    return iRefresh;

    }

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

// CSIPClientTransaction::RemoveRefresh

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

//

void CSIPClientTransaction::RemoveRefresh()

    {

    __SIP_ASSERT_RETURN(iRefresh, KErrNotFound);

    iRefresh = NULL;

    }