// 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 : sipdialogearly.cpp
// Part of : SIPAPI
// Version : SIP/4.0
//
#include "sip.h"
#include "siperr.h"
#include "SipAssert.h"
#include "sipdialogearly.h"
#include "SipDialogImplementation.h"
#include "SipDialogAssocImplementation.h"
#include "sipinvitedialogassoc.h"
#include "sipsubscribedialogassoc.h"
#include "sipservertransaction.h"
#include "sipmessageelements.h"
#include "sipresponseelements.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
// -----------------------------------------------------------------------------
// CDialogEarly::NewL
// -----------------------------------------------------------------------------
//
CDialogEarly* CDialogEarly::NewL()
{
return new (ELeave) CDialogEarly();
}
// -----------------------------------------------------------------------------
// CDialogEarly::CDialogEarly
// -----------------------------------------------------------------------------
//
CDialogEarly::CDialogEarly()
{
}
// -----------------------------------------------------------------------------
// CDialogEarly::~CDialogEarly
// -----------------------------------------------------------------------------
//
CDialogEarly::~CDialogEarly()
{
}
// -----------------------------------------------------------------------------
// CDialogEarly::State
// -----------------------------------------------------------------------------
//
CSIPDialog::TState CDialogEarly::State() const
{
return CSIPDialog::EEarly;
}
// -----------------------------------------------------------------------------
// CDialogEarly::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void CDialogEarly::SetNeighbourStates(CDialogState& aConfirmed,
CDialogState& aTerminated)
{
iConfirmed = &aConfirmed;
iTerminated = &aTerminated;
}
// -----------------------------------------------------------------------------
// CDialogEarly::SendSubscribeL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogEarly::SendSubscribeL(const CSIPDialogImplementation& /*aDialog*/,
CSIPSubscribeDialogAssoc& aAssoc,
CSIPMessageElements* aElements,
CSIPRefresh* aRefresh) const
{
return aAssoc.DoSendSubscribeL(aElements, aRefresh, ETrue);
}
// -----------------------------------------------------------------------------
// CDialogEarly::SendNonTargetRefreshRequestL
// Dialog has to be at least in "early" state, before a non target refresh
// request can be sent.
// -----------------------------------------------------------------------------
//
CSIPClientTransaction* CDialogEarly::SendNonTargetRefreshRequestL(
const CSIPDialogImplementation& aDialog,
CSIPDialogAssocImplementation& aAssoc,
RStringF aMethod,
CSIPMessageElements* aElements) const
{
return aDialog.SendRequestInDialogL(aAssoc, aMethod, aElements);
}
// -----------------------------------------------------------------------------
// CDialogEarly::IncomingResponseL
// -----------------------------------------------------------------------------
//
TBool CDialogEarly::IncomingResponseL(CSIPDialogImplementation& aDialog,
CSIPResponseElements* aElements,
TUint32 aRequestId,
TUint32 aDialogId,
CConnectionCallback& aCallback) const
{
return IncomingResponseWithinDialogL(aDialog,
aElements,
aRequestId,
aDialogId,
aCallback,
*this,
*iConfirmed,
*iTerminated);
}
// -----------------------------------------------------------------------------
// CDialogEarly::IncomingResponseL
// -----------------------------------------------------------------------------
//
TBool CDialogEarly::IncomingResponseL(CSIPDialogImplementation& aDialog,
CSIPResponseElements* aElements,
TUint32 aRequestId,
TUint32 aRefreshId,
TUint32 /*aDialogId*/,
CConnectionCallback& aCallback) const
{
return ResponseToRefreshL(aDialog,
aElements,
aRequestId,
aRefreshId,
aCallback,
*this,
*iConfirmed,
*iTerminated);
}
// -----------------------------------------------------------------------------
// CDialogEarly::IncomingRequestL
// Enter next state before passing request to application, because application
// may delete the last dialog association, causing CSIPDialog to be deleted and
// CSIPDialog shouldn't be accessed after the callback.
// -----------------------------------------------------------------------------
//
TBool CDialogEarly::IncomingRequestL(CSIPDialogImplementation& aDialog,
CSIPServerTransaction* aTransaction,
CConnectionCallback& aCallback) const
{
__SIP_ASSERT_LEAVE(aTransaction, KErrArgument);
if (aTransaction->Type() == SIPStrings::StringF(SipStrConsts::ENotify) &&
aDialog.DoesNotifyConfirmDialog())
{
aDialog.ChangeState(iConfirmed);
}
return RequestReceivedL(aDialog, aTransaction, aCallback);
}
// -----------------------------------------------------------------------------
// CDialogEarly::SendResponseL
// Since at least one response has already been sent (it caused the dialog to
// enter Early state), this response doesn't create dialog anymore.
// -----------------------------------------------------------------------------
//
void CDialogEarly::SendResponseL(CSIPDialogImplementation& aDialog,
const CSIPResponseElements& aElements,
TUint32 aRequestId,
TBool aAffectsDialogState,
TBool aTargetRefresh) const
{
SendResponseWithinDialogL(aDialog, aElements, aRequestId, aTargetRefresh);
if (aAffectsDialogState)
{
if (aElements.StatusCode() >= 300)
{
aDialog.ChangeState(iTerminated);
}
else
{
if (aElements.StatusCode() >= 200)
{
aDialog.ChangeState(iConfirmed);
}
}
}
}
// -----------------------------------------------------------------------------
// CDialogEarly::SendUpdateL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogEarly::SendPrackL(CSIPInviteDialogAssoc& aAssoc,
CSIPMessageElements* aElements) const
{
return aAssoc.DoSendRequestWithinDialogL(
SIPStrings::StringF(SipStrConsts::EPrack),
aElements);
}
// -----------------------------------------------------------------------------
// CDialogEarly::SendUpdateL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogEarly::SendUpdateL(CSIPInviteDialogAssoc& aAssoc,
CSIPMessageElements* aElements) const
{
return aAssoc.DoSendRequestWithinDialogL(
SIPStrings::StringF(SipStrConsts::EUpdate),
aElements);
}
// -----------------------------------------------------------------------------
// CDialogEarly::SendByeL
// Caller can send BYE in Early state, but callee can't.
// If aAssoc has an INVITE client transaction, it means our endpoint has sent
// an INVITE since dialog state is Early.
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CDialogEarly::SendByeL(CSIPInviteDialogAssoc& aAssoc,
CSIPMessageElements* aElements) const
{
if (!aAssoc.Implementation().HasTransaction(aAssoc.Type(), ETrue))
{
User::Leave(KErrSIPInvalidDialogState);
}
return aAssoc.DoSendRequestWithinDialogL(
SIPStrings::StringF(SipStrConsts::EBye),
aElements);
}
// -----------------------------------------------------------------------------
// CDialogEarly::ErrorOccured
// -----------------------------------------------------------------------------
//
TBool CDialogEarly::ErrorOccured(CSIPDialogImplementation& aDialog,
TInt aError,
TUint32 aRequestId,
CConnectionCallback& aCallback) const
{
return HandleErrorOccurred(aDialog,
aError,
aRequestId,
aCallback,
*iTerminated);
}
// -----------------------------------------------------------------------------
// CDialogEarly::ErrorOccured
// -----------------------------------------------------------------------------
//
TBool CDialogEarly::ErrorOccured(CSIPDialogImplementation& aDialog,
TInt aError,
TUint32 aRefreshId,
TUint32 /*aRequestId*/,
CConnectionCallback& aCallback) const
{
return HandleRefreshErrorOccurred(aDialog,
aError,
aRefreshId,
aCallback,
*iTerminated);
}
// -----------------------------------------------------------------------------
// CDialogEarly::ConnectionLost
// -----------------------------------------------------------------------------
//
void CDialogEarly::ConnectionLost(CSIPDialogImplementation& aDialog) const
{
aDialog.ChangeState(iTerminated);
}