// 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          : InviteUAS.cpp
// Part of       : TransactionUser
// Version       : SIP/6.0
//



#include "siperr.h"
#include "sipinternalerr.h"
#include "SipAssert.h"
#include "sipresponse.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "MSipDialogs.h"
#include "TransactionMgr.h"
#include "Transmitter.h"

#include "MTransactionOwner.h"
#include "InviteUAS.h"
#include "InviteServerTa.h"     // Leave2xxForUAS
#include "SIPMessageUtility.h"
#include "CTransactionStore.h"
#include "UserAgentState.h"
#include "UserAgentTimer.h"
#include "TimerValues.h"


// -----------------------------------------------------------------------------
// CInviteUAS::NewL
// -----------------------------------------------------------------------------
//
CInviteUAS* CInviteUAS::NewL(CUserAgentCreateParams& aParams,							
							 MSipConnectionMgr& aConnectionMgr,
							 MSIPRequestRouter& aRouter,
                             MSipDialogs& aDialogs)
	{
	CInviteUAS* self = new (ELeave) CInviteUAS(aParams, aDialogs, aRouter);
	CleanupStack::PushL(self);
	self->ConstructL(aConnectionMgr);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::CInviteUAS
// -----------------------------------------------------------------------------
//
CInviteUAS::CInviteUAS(CUserAgentCreateParams& aParams,					   
                       MSipDialogs& aDialogs,
                       MSIPRequestRouter& aRouter) :
	CUserAgentServer(aParams, aDialogs, aRouter)
	{
	}

// -----------------------------------------------------------------------------
// CInviteUAS::ConstructL
// -----------------------------------------------------------------------------
//
void CInviteUAS::ConstructL(MSipConnectionMgr& aConnectionMgr)
	{
	CUserAgent::ConstructL(aConnectionMgr);
	CreateTransactionL();
	}

// -----------------------------------------------------------------------------
// CInviteUAS::~CInviteUAS
// Transaction must clear pointers to the 2xx, as UAS will delete the 2xx.
// -----------------------------------------------------------------------------
//
CInviteUAS::~CInviteUAS()
	{
	CancelAllTimers();

    if (IsSending2xx() && iTransaction && !iTransaction->HasTerminated())
        {
		CInviteServerTransaction::Ptr(*iTransaction).Leave2xxForUAS();	
		}
	}

// -----------------------------------------------------------------------------
// CInviteUAS::CreateTransactionL
// -----------------------------------------------------------------------------
//
void CInviteUAS::CreateTransactionL()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(!iTransaction && iTransmitter, KErrAlreadyExists);

	iTransaction = iTransactionMgr.CreateTransactionL(
									CTransactionBase::KServerInviteTransaction,
									*this,
									*iTransmitter,
									iTimerValues);
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::DoesDialogExistForAckL
// -----------------------------------------------------------------------------
//
TBool CInviteUAS::DoesDialogExistForAckL(CSIPRequest& aAck)
	{
	__TEST_INVARIANT;

	CSIPResponse* resp(NULL);
    MTransactionOwner* taOwner = iDialogs.TransactionOwnerL(aAck, &resp);
	if (taOwner)
		{
        iObserver = taOwner;
		return ETrue;
		}

    // Nothing is sent after ACK
	delete resp;

    __TEST_INVARIANT;
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::SendFirst2xxL
// Clear transaction from CTransactionStore, so further INVITEs/ACKs are passed
// to UAS, and not to transaction. INVITE UAS owns the 2xx.
// -----------------------------------------------------------------------------
//
void CInviteUAS::SendFirst2xxL(CSIPResponse* aResp)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(aResp, KErrArgument);
	__SIP_ASSERT_LEAVE(aResp->Type() == CSIPResponse::E2XX, KErrArgument);

	iTransactionStore.ClearTransaction(TransactionId());
	StartTimerWaitAckL();
	SendResponseToTransactionL(aResp);
	iOutgoingMsg = aResp;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::Retransmit2xxL
// -----------------------------------------------------------------------------
//
void CInviteUAS::Retransmit2xxL()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iOutgoingMsg && iTransmitter, KErrGeneral);
    __SIP_ASSERT_LEAVE(
        static_cast<CSIPResponse*>(iOutgoingMsg)->Type() == CSIPResponse::E2XX,
        KErrSIPMalformedMessage);

	iTransmitter->SendResponseL(static_cast<CSIPResponse&>(*iOutgoingMsg),
								TransportParams(),
							    this,
								TransactionId());
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::CancelInviteL
// -----------------------------------------------------------------------------
//
void CInviteUAS::CancelInviteL()
	{
	__TEST_INVARIANT;

	if (!iCanceled)
		{
		iCanceled = State().CancelL(*this);
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::HandleCancelInviteL
// -----------------------------------------------------------------------------
//
void CInviteUAS::HandleCancelInviteL(const CUserAgentState& aRejected)
	{
	__TEST_INVARIANT;

	if (iTransaction)
		{
		SendErrorResponseL(487,
	    	SIPStrings::StringF(SipStrConsts::EPhraseRequestTerminated),
	    	aRejected);
		}

	if (!InformObserverAboutCancel())
		{
		// Waiting to get MTransactionOwner. End silently.
		CancelGetOwnerRequest();
        StopTimerOwnerResolver();
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::InformObserverAboutCancel
// -----------------------------------------------------------------------------
//
TBool CInviteUAS::InformObserverAboutCancel()
	{
	if (iObserver)
		{
		// INVITE was passed to iObserver, run transaction silently to end
		iObserver->TransactionEnded(iTransportParams.IapId(),
		                            TransactionId(),
									KInviteTransactionCancelled);
		iObserver = NULL;
		return ETrue;
		}
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::IsSending2xx
// -----------------------------------------------------------------------------
//
TBool CInviteUAS::IsSending2xx() const
    {
    __TEST_INVARIANT;
    return iOutgoingMsg && CSIPMessageUtility::Is2xxResponse(*iOutgoingMsg);
    }

// -----------------------------------------------------------------------------
// CInviteUAS::StartTimerRetransmit2xxL
// -----------------------------------------------------------------------------
//
void CInviteUAS::StartTimerRetransmit2xxL()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(!iTimerRetransmit2xx, KErrAlreadyExists);

	iTimerValues.DoubleUptoT2(iTimerRetransmit2xxDuration);
	iTimerRetransmit2xx =
        CTimerRetransmit2xx::NewL(iTimers,
								  this,				
								  iTimerRetransmit2xxDuration);
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::StopTimerRetransmit2xx
// -----------------------------------------------------------------------------
//
void CInviteUAS::StopTimerRetransmit2xx()
	{
	__TEST_INVARIANT;

	delete iTimerRetransmit2xx;
	iTimerRetransmit2xx = NULL;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::StartTimerWaitAckL
// -----------------------------------------------------------------------------
//
void CInviteUAS::StartTimerWaitAckL()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(!iTimerWaitAck, KErrAlreadyExists);
	
	iTimerWaitAck = CTimerStopUA::NewL(iTimers,
									   this,
									   iTimerValues.Duration64xT1(),
                                       KErrSIPNoAckReceived);
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::StopTimerWaitAck
// -----------------------------------------------------------------------------
//
void CInviteUAS::StopTimerWaitAck()
	{
	__TEST_INVARIANT;

	delete iTimerWaitAck;
	iTimerWaitAck = NULL;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::DeleteTimer
// -----------------------------------------------------------------------------
//
void CInviteUAS::DeleteTimer(const CUserAgentTimer& aTimer)
	{
	__TEST_INVARIANT;

	if (&aTimer == iTimerRetransmit2xx)
		{
		StopTimerRetransmit2xx();		
		}

	if (&aTimer == iTimerWaitAck)
		{
		StopTimerWaitAck();		
		}

    if (&aTimer == iTimerOwnerResolver)
        {
        StopTimerOwnerResolver();
        }

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::CancelAllTimers
// -----------------------------------------------------------------------------
//
void CInviteUAS::CancelAllTimers()
	{
	__TEST_INVARIANT;

	StopTimerRetransmit2xx();
	StopTimerWaitAck();
    StopTimerOwnerResolver();

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CInviteUAS::Ptr
// -----------------------------------------------------------------------------
//
CInviteUAS& CInviteUAS::Ptr(CUserAgent& aUserAgent)
	{
	return static_cast<CInviteUAS&>(aUserAgent);
	}

// -----------------------------------------------------------------------------
// CInviteUAS::__DbgTestInvariant
// -----------------------------------------------------------------------------
//

void CInviteUAS::__DbgTestInvariant() const
	{
	if (iTimerRetransmit2xxDuration > iTimerValues.T2())
		{	
		User::Invariant();
		}
	}