// Copyright (c) 2003-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          : sipdialogconfirmed.cpp
// Part of       : SIPAPI
// Version       : SIP/4.0 
//



#include "sip.h"
#include "SipAssert.h"
#include "sipdialogconfirmed.h"
#include "SipDialogImplementation.h"
#include "sipclienttransaction.h"
#include "sipservertransaction.h"
#include "sipresponseelements.h"
#include "siprefresh.h"
#include "sipinvitedialogassoc.h"
#include "sipsubscribedialogassoc.h"
#include "sipnotifydialogassoc.h"
#include "sipreferdialogassoc.h"
#include "sipconnectioncallback.h"
#include "sipstrings.h"
#include "sipstrconsts.h"


// -----------------------------------------------------------------------------
// CDialogConfirmed::NewL
// -----------------------------------------------------------------------------
//
CDialogConfirmed* CDialogConfirmed::NewL()
    {
    return new (ELeave) CDialogConfirmed();
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::CDialogConfirmed
// -----------------------------------------------------------------------------
//
CDialogConfirmed::CDialogConfirmed()
	{
	}

// -----------------------------------------------------------------------------
// CDialogConfirmed::~CDialogConfirmed
// -----------------------------------------------------------------------------
//
CDialogConfirmed::~CDialogConfirmed()
	{
	}

// -----------------------------------------------------------------------------
// CDialogConfirmed::State
// -----------------------------------------------------------------------------
//
CSIPDialog::TState CDialogConfirmed::State() const
    {
    return CSIPDialog::EConfirmed;
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void CDialogConfirmed::SetNeighbourStates(CDialogState& aTerminated)
    {    
    iTerminated = &aTerminated;
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendInviteL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::SendInviteL(const CSIPDialogImplementation& /*aDialog*/,
                              CSIPInviteDialogAssoc& aAssoc,
                              CSIPMessageElements* aElements) const
    {
    return aAssoc.DoSendRequestWithinDialogL(
    							SIPStrings::StringF(SipStrConsts::EInvite),
								aElements);
	}

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendSubscribeL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction* 
CDialogConfirmed::SendSubscribeL(const CSIPDialogImplementation& /*aDialog*/,
                                 CSIPSubscribeDialogAssoc& aAssoc,
                                 CSIPMessageElements* aElements,
                                 CSIPRefresh* aRefresh) const
    {
    return aAssoc.DoSendSubscribeL(aElements, aRefresh, ETrue);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::UpdateL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::UpdateL(const CSIPDialogImplementation& /*aDialog*/,
                	  	  CSIPSubscribeDialogAssoc& aAssoc,
                	  	  CSIPMessageElements* aElements) const
	{
	return aAssoc.DoSendSubscribeL(aElements, NULL, ETrue);
	}

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendNonTargetRefreshRequestL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction* CDialogConfirmed::SendNonTargetRefreshRequestL(
									const CSIPDialogImplementation& aDialog,
                                    CSIPDialogAssocImplementation& aAssoc,
                                    RStringF aMethod,
                                    CSIPMessageElements* aElements) const
    {
    return aDialog.SendRequestInDialogL(aAssoc, aMethod, aElements);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::IncomingResponseL
// "this" is passed instead of the real early-state, since early state is never
// entered from confirmed state.
// -----------------------------------------------------------------------------
//
TBool
CDialogConfirmed::IncomingResponseL(CSIPDialogImplementation& aDialog,
                                    CSIPResponseElements* aElements,
		                            TUint32 aRequestId,
                                    TUint32 aDialogId,
                                    CConnectionCallback& aCallback) const
    {
    return IncomingResponseWithinDialogL(aDialog,
                                         aElements,
		                                 aRequestId,
                                         aDialogId,
                                         aCallback,
                                         *this,
                                         *this,
                                         *iTerminated);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::IncomingResponseL
// "this" is passed instead of the real early-state, since early state is never
// entered from confirmed state.
// -----------------------------------------------------------------------------
//
TBool CDialogConfirmed::IncomingResponseL(CSIPDialogImplementation& aDialog,
                                          CSIPResponseElements* aElements,
		                                  TUint32 aRequestId,
                                          TUint32 aRefreshId,
                                          TUint32 /*aDialogId*/,
                                          CConnectionCallback& aCallback) const
    {    
    return ResponseToRefreshL(aDialog,
                              aElements,
		                      aRequestId,
                              aRefreshId,
                              aCallback,                              
                              *this,
                              *this,                               
                              *iTerminated);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::IncomingRequestL
// -----------------------------------------------------------------------------
//
TBool CDialogConfirmed::IncomingRequestL(CSIPDialogImplementation& aDialog,
                                         CSIPServerTransaction* aTransaction,
                                         CConnectionCallback& aCallback) const
    {
    __SIP_ASSERT_LEAVE(aTransaction, KErrArgument);
    return RequestReceivedL(aDialog, aTransaction, aCallback);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendAckL
// -----------------------------------------------------------------------------
//
void CDialogConfirmed::SendAckL(CSIPInviteDialogAssoc& aAssoc,
                                const CSIPClientTransaction& aTransaction,
			                    CSIPMessageElements* aElements) const
    {
    aAssoc.DoSendAckL(aTransaction, aElements);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendResponseL
// Even when sending an error response to the initial request, dialog doesn't
// enter terminated state, if it currently is in confirmed state.
// -----------------------------------------------------------------------------
//
void CDialogConfirmed::SendResponseL(CSIPDialogImplementation& aDialog,
                                     const CSIPResponseElements& aElements,
						             TUint32 aRequestId,
                                     TBool /*aAffectsDialogState*/,
                                     TBool aTargetRefresh) const
    {
    SendResponseWithinDialogL(aDialog, aElements, aRequestId, aTargetRefresh);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendPrackL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::SendPrackL(CSIPInviteDialogAssoc& aAssoc,
                             CSIPMessageElements* aElements) const
    {
    return aAssoc.DoSendRequestWithinDialogL(
    							SIPStrings::StringF(SipStrConsts::EPrack),
								aElements);    
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendUpdateL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::SendUpdateL(CSIPInviteDialogAssoc& aAssoc,
                              CSIPMessageElements* aElements) const
    {
    return aAssoc.DoSendRequestWithinDialogL(
    							SIPStrings::StringF(SipStrConsts::EUpdate),
								aElements);    
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendByeL
// Either caller or callee can send BYE in Confirmed state.
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::SendByeL(CSIPInviteDialogAssoc& aAssoc,
                           CSIPMessageElements* aElements) const
    { 
    return aAssoc.DoSendRequestWithinDialogL(
	    							SIPStrings::StringF(SipStrConsts::EBye),
									aElements);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendUnsubscribeL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::SendUnsubscribeL(CSIPSubscribeDialogAssoc& aAssoc,
                                   CSIPMessageElements* aElements) const
    {
    return aAssoc.DoSendUnsubscribeL(aElements);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendNotifyL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::SendNotifyL(CSIPNotifyDialogAssoc& aAssoc,
                    		  CSIPMessageElements* aElements) const
	{	
	return aAssoc.DoSendNotifyWithinDialogL(aElements);
	}

// -----------------------------------------------------------------------------
// CDialogConfirmed::SendReferL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogConfirmed::SendReferL(const CSIPDialogImplementation& /*aDialog*/,
							 CSIPReferDialogAssoc& aAssoc,
                   		     CSIPMessageElements* aElements) const
  	{
	return aAssoc.DoSendReferL(aElements, ETrue);
  	}

// -----------------------------------------------------------------------------
// CDialogConfirmed::ErrorOccured
// -----------------------------------------------------------------------------
//
TBool CDialogConfirmed::ErrorOccured(CSIPDialogImplementation& aDialog,
                                     TInt aError,
                                     TUint32 aRequestId,
                                     CConnectionCallback& aCallback) const
    {    
    return HandleErrorOccurred(aDialog,
                               aError,
                               aRequestId,
                               aCallback,
                               *iTerminated);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::ErrorOccured
// -----------------------------------------------------------------------------
//
TBool CDialogConfirmed::ErrorOccured(CSIPDialogImplementation& aDialog,
                                     TInt aError,
                                     TUint32 aRefreshId,
                                     TUint32 /*aRequestId*/,
                                     CConnectionCallback& aCallback) const
    {    
    return HandleRefreshErrorOccurred(aDialog,
                               		  aError,
                               		  aRefreshId,
                               		  aCallback,
                               		  *iTerminated);
    }

// -----------------------------------------------------------------------------
// CDialogConfirmed::ConnectionLost
// This is the only case where dialog goes from confirmed to terminated state.
// -----------------------------------------------------------------------------
//
void CDialogConfirmed::ConnectionLost(CSIPDialogImplementation& aDialog) const
    {
    aDialog.ChangeState(iTerminated);
    }