multimediacommsengine/mmcesrv/mmceevent/src/mceeventsubscribemtestablishedstate.cpp
/*
* Copyright (c) 2005 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: MT event is established.
*
*/
// INCLUDE FILES
#include <sipsubscriptionstateheader.h>
#include <sipnotifydialogassoc.h>
#include <sipdialog.h>
#include "mcesipeventhelper.h"
#include "mceeventsubscribemtestablishedstate.h"
#include "mcesip.h"
#include "mceeventslogs.h"
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishedState::CMceEventSubscribeMtEstablishedState
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMceEventSubscribeMtEstablishedState::CMceEventSubscribeMtEstablishedState()
{
}
// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishedState::~CMceEventSubscribeMtEstablishedState
// Destructor
// -----------------------------------------------------------------------------
//
CMceEventSubscribeMtEstablishedState::~CMceEventSubscribeMtEstablishedState()
{
}
// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishedState::ProcessSubscribeStateL
// Ápply concrete state.
// Be noticed that it will be also update, unsubscribe
// -----------------------------------------------------------------------------
//
void CMceEventSubscribeMtEstablishedState::HandleL(CMceComEvent& aEvent )
{
MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleL, Entry");
User::LeaveIfError( aEvent.SIPEvent().Dialog() ?
KErrNone : KMceEventStateError );
User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type() ==
SIPStrings::StringF( SipStrConsts::ENotify ) ?
KErrNone : KMceEventStateError );
// Set subscription state and parameters
TInt nextState = KErrNotFound;
CSIPSubscriptionStateHeader& subStateHeader =
( static_cast< CSIPNotifyDialogAssoc* >
( aEvent.SIPEvent().Dialog() ) )->SubscriptionState();
switch ( aEvent.PreviousAction() )
{
case EMceItcNotify:
{
subStateHeader.SetSubStateValueL( KStateActive );
subStateHeader.SetExpiresParameterL( aEvent.RefreshInterval() );
nextState = KMceEstablishingEventStateIndex;
break;
}
case EMceItcTerminateEvent:
{
subStateHeader.SetSubStateValueL( KStateTerminated );
RStringF expires = SIPStrings::StringF( SipStrConsts::EExpires );
subStateHeader.DeleteParam( expires );
nextState = KMceTerminatingEventStateIndex;
break;
}
default:
{
// Other actions not supported
User::Leave( KMceEventStateError );
break;
}
}
CSIPMessageElements* message =
MCESIPEventHelper::CreateMessageElementsLC( aEvent,
SipStrConsts::ENotify );
CSIPClientTransaction* transaction =
( static_cast< CSIPNotifyDialogAssoc* >
( aEvent.SIPEvent().Dialog() ) )->SendNotifyL( message );
CleanupStack::Pop( message );
CleanupStack::PushL( transaction );
aEvent.SIPEvent().SetPendingTransactionL( transaction );
CleanupStack::Pop( transaction );
aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleL, Exit");
}
// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL
// Ápply concrete state.
// Be noticed that it will be also update, unsubscribe
// -----------------------------------------------------------------------------
//
void CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL(
CMceComEvent& aEvent )
{
MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL, Entry");
User::LeaveIfError( aEvent.SIPEvent().Dialog() ?
KErrNone : KMceEventStateError );
User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type()
== SIPStrings::StringF( SipStrConsts::ENotify ) ?
KErrNone : KMceEventStateError );
CSIPServerTransaction& serverTA = aEvent.SIPEvent().Request();
CSIPServerTransaction* serverTACheck = &serverTA;
User::LeaveIfError( serverTACheck ? KErrNone : KMceEventStateError );
//Received Subscribe from Mo there is noaction in the previous action
User::LeaveIfError( aEvent.PreviousAction() == KErrNotFound ?
KErrNone : KMceEventStateError );
User::LeaveIfError( CSIPDialog::EConfirmed ==
aEvent.SIPEvent().Dialog()->Dialog().State() ?
KErrNone : KMceEventStateError );
User::LeaveIfError( serverTA.RequestElements() ? KErrNone : KErrCorrupt );
const CSIPMessageElements& subscribeMsg =
serverTA.RequestElements()->MessageElements();
//receiveing MO Subscribe Update or Mo Subscribe Terminate
//Check the expire header so knows which state should go
//Observer inform the incomingsubscribe and send response and notify
TBool terminated = EFalse;
CSIPResponseElements* response =
MCESIPEventHelper::SubscribeRequestReceivedLC( aEvent, subscribeMsg );
if ( response->StatusCode() == KMceSipOK )
{
MCESIPEventHelper::HandleExpireHeaderL( subscribeMsg, terminated );
aEvent.SIPEvent().Request().SendResponseL( response );
CleanupStack::Pop( response );
// Send notify
TInt nextState = KErrNotFound;
CSIPNotifyDialogAssoc* dialogAssoc =
static_cast <CSIPNotifyDialogAssoc* >
( aEvent.SIPEvent().Dialog() );
CSIPSubscriptionStateHeader& subscrState =
dialogAssoc->SubscriptionState();
if ( terminated )
{
subscrState.SetSubStateValueL( KStateTerminated );
RStringF expires = SIPStrings::StringF( SipStrConsts::EExpires );
subscrState.DeleteParam( expires );
nextState = KMceTerminatingEventStateIndex;
}
else
{
//when subscription state is active
subscrState.SetSubStateValueL( KStateActive );
subscrState.SetExpiresParameterL( aEvent.RefreshInterval() );
nextState = KMceEstablishedEventStateIndex;
}
CSIPMessageElements* notifyMsg =
MCESIPEventHelper::CreateMessageElementsLC(
aEvent,
SipStrConsts::ENotify );
CSIPClientTransaction* tx = dialogAssoc->SendNotifyL( notifyMsg );
CleanupStack::Pop( notifyMsg );
CleanupStack::PushL( tx );
aEvent.SIPEvent().SetPendingTransactionL( tx );
CleanupStack::Pop( tx );
aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
}
else
{
aEvent.SIPEvent().Request().SendResponseL( response );
CleanupStack::Pop( response );
}
MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL, Exit");
}
// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL
// Ápply concrete state.
// Be noticed that it will be also update, unsubscribe
// -----------------------------------------------------------------------------
//
void CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL(
CMceComEvent& aEvent )
{
MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL, Entry");
//MT
//Getting subscribe->sendResponse->Send Notify and now getting response
//Checking if getting the error after sending the Subscribe
User::LeaveIfError( &aEvent.SIPEvent().Response() ?
KErrNone : KMceEventStateError );
User::LeaveIfError( aEvent.SIPEvent().Response().Type()==
SIPStrings::StringF( SipStrConsts::ENotify ) ?
KErrNone : KMceEventStateError );
//Get response from sending subscribe in Established state
aEvent.SetPreviousAction( KErrNotFound );
const CSIPResponseElements& response =
*aEvent.SIPEvent().Response().ResponseElements();
const CSIPResponseElements* responseCheck = &response;
User::LeaveIfError( responseCheck ? KErrNone : KErrCorrupt );
//Notify the subsession the response received
//From the MtIdle
//Getting subscribe->sendResponse->Send Notify and now getting response
TUint statusCode = response.StatusCode();
if (statusCode >= KMceSipOK)
{
CMceEvent::TState nextClientState = CMceEvent::EPending;
TMceEventStateIndex nextState = KErrNotFound;
if (statusCode < KMceSipMultipleChoices )
{
nextClientState = CMceEvent::EActive;
nextState = KMceEstablishedEventStateIndex;
}
else
{
nextClientState = CMceEvent::ETerminated;
nextState = KMceTerminatedEventStateIndex;
}
aEvent.SIPEvent().ClientStateChangedL( nextClientState, ETrue );
aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
}
MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL, Exit");
}
// End of File