// Copyright (c) 2006-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          : TransactionTimer.cpp
// Part of       : Transaction
// Version       : SIP/5.0
//



#include "SipAssert.h"
#include "sipstrings.h"
#include "sipresponse.h"
#include "TransactionTimer.h"
#include "ServerTransaction.h"

// -----------------------------------------------------------------------------
// CTransactionTimer::CTransactionTimer
// -----------------------------------------------------------------------------
//
CTransactionTimer::CTransactionTimer(MTimerManager& aTimerMgr,
									 MExpirationHandler* aObserver,
									 TUint32 aDuration) :
	CTimerBase(aTimerMgr, aObserver, aDuration)
	{
    __ASSERT_DEBUG(aObserver,
		User::Panic(_L("CTransactionTimer::CTransactionTimer() aObserver = 0"),
		KErrArgument));
	}

// -----------------------------------------------------------------------------
// CTimerRetransmit::NewL
// -----------------------------------------------------------------------------
//
CTimerRetransmit* CTimerRetransmit::NewL(MTimerManager& aTimerMgr,
										 MExpirationHandler* aObserver,
										 TUint32 aDuration)
	{
	CTimerRetransmit* self = new (ELeave) CTimerRetransmit(aTimerMgr,
														   aObserver,
														   aDuration);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CTimerRetransmit::CTimerRetransmit
// -----------------------------------------------------------------------------
//
CTimerRetransmit::CTimerRetransmit(MTimerManager& aTimerMgr,
								   MExpirationHandler* aObserver,
								   TUint32 aDuration) :
	CTransactionTimer(aTimerMgr, aObserver, aDuration)	
	{
	}

// -----------------------------------------------------------------------------
// CTimerRetransmit::ExpiredL
// Retransmit a SIP message, unless CTransmitter is sending. That happen only if
// InviteServerTransaction receives INVITE, sends response and timer G expires
// before CTransmitter has finished sending.
// -----------------------------------------------------------------------------
//
void CTimerRetransmit::ExpiredL(CTransaction& aTransaction, TTimerId aTimerId)
	{
    __SIP_ASSERT_LEAVE(aTimerId == iId, KErrArgument);

	if (!aTransaction.IsTransmitterSending())
		{
		aTransaction.SendToTransmitterL();
		}
	}

// -----------------------------------------------------------------------------
// CTimerTerminateTa::NewL
// -----------------------------------------------------------------------------
//
CTimerTerminateTa* CTimerTerminateTa::NewL(MTimerManager& aTimerMgr,
										   MExpirationHandler* aObserver,
										   TUint32 aDuration,
										   TInt aReason)
	{
	CTimerTerminateTa* self = new (ELeave) CTimerTerminateTa(aTimerMgr,
															 aObserver,
															 aDuration,
															 aReason);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CTimerTerminateTa::CTimerTerminateTa
// -----------------------------------------------------------------------------
//
CTimerTerminateTa::CTimerTerminateTa(MTimerManager& aTimerMgr,
									 MExpirationHandler* aObserver,
									 TUint32 aDuration,
									 TInt aReason) :
	CTransactionTimer(aTimerMgr, aObserver, aDuration),
	iReason(aReason)
	{
	}

// -----------------------------------------------------------------------------
// CTimerTerminateTa::ExpiredL
// -----------------------------------------------------------------------------
//
void CTimerTerminateTa::ExpiredL(CTransaction& aTransaction, TTimerId aTimerId)
	{
    __SIP_ASSERT_LEAVE(aTimerId == iId, KErrArgument);

	aTransaction.TerminatedL(iReason);
	}

// -----------------------------------------------------------------------------
// CTimerSend100::NewL
// -----------------------------------------------------------------------------
//
CTimerSend100* CTimerSend100::NewL(MTimerManager& aTimerMgr,
								   MExpirationHandler* aObserver,
								   TUint32 aDuration,
								   CSIPResponse* aResponse,
								   RStringF aTransportProtocol,
								   TSIPTransportParams& aTransportParams)
	{
	CTimerSend100* self = new (ELeave) CTimerSend100(aTimerMgr,
													 aObserver,
													 aDuration,													 
								   					 aTransportProtocol,
								   					 aTransportParams);
	CleanupStack::PushL(self);
	self->ConstructL();
	self->iResponse = aResponse;
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CTimerSend100::CTimerSend100
// -----------------------------------------------------------------------------
//
CTimerSend100::CTimerSend100(MTimerManager& aTimerMgr,
						     MExpirationHandler* aObserver,
						     TUint32 aDuration,						     
						     RStringF aTransportProtocol,
							 TSIPTransportParams& aTransportParams) :
	CTransactionTimer(aTimerMgr, aObserver, aDuration),	
	iTransportParams(aTransportParams)
	{
	iTransportProtocol = aTransportProtocol.Copy();
	}

// -----------------------------------------------------------------------------
// CTimerSend100::~CTimerSend100
// -----------------------------------------------------------------------------
//
CTimerSend100::~CTimerSend100()
	{
	delete iResponse;
	iTransportProtocol.Close();
	}

// -----------------------------------------------------------------------------
// CTimerSend100::ExpiredL
// -----------------------------------------------------------------------------
//
void CTimerSend100::ExpiredL(CTransaction& aTransaction, TTimerId aTimerId)
	{
    __SIP_ASSERT_LEAVE(aTimerId == iId, KErrArgument);

	CSIPResponse* resp = iResponse;
	iResponse = NULL;
	CleanupStack::PushL(resp);

	//Causes transaction to delete this timer, so don't refer it afterwards.
	aTransaction.SendResponseL(resp, iTransportProtocol, iTransportParams);
	CleanupStack::Pop(resp);
	}