diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmcesrv/mmceevent/src/mceeventcontext.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/mmcesrv/mmceevent/src/mceeventcontext.cpp Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,467 @@ +/* +* 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: Class for event context. Contains methods for +* creating the state array and controlling current state. +* +*/ + + + + +#include "mcecomevent.h" +#include "mceeventcontext.h" +#include "mceeventstatebase.h" +#include "mceeventsubscribemoestablishedstate.h" +#include "mceeventsubscribemtestablishedstate.h" +#include "mceeventsubscribeterminatingstate.h" +#include "mceeventsubscribeterminatedstate.h" +#include "mceeventrefermoestablishedstate.h" +#include "mceeventrefermtestablishedstate.h" +#include "mceeventreferterminatingstate.h" +#include "mceeventreferterminatedstate.h" +#include "mceeventsubscribemoidlestate.h" +#include "mceeventsubscribemoestablishingstate.h" +#include "mceeventrefermoidlestate.h" +#include "mceeventrefermoestablishingstate.h" +#include "mceeventsubscribemtidlestate.h" +#include "mceeventsubscribemtestablishingstate.h" +#include "mceeventrefermtidlestate.h" +#include "mceeventrefermtestablishingstate.h" + +// ----------------------------------------------------------------------------- +// CMCEMoEventSubscribeContext::NewL +// ----------------------------------------------------------------------------- +// +CMceEventContext* CMceEventContext::NewL( CMceComEvent& aEvent ) + { + CMceEventContext* self = new( ELeave ) CMceEventContext; + CleanupStack::PushL( self ); + self->ConstructL( aEvent ); + CleanupStack::Pop(self); + return self; + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::CMceEventContext +// ----------------------------------------------------------------------------- +// +CMceEventContext::CMceEventContext() + { + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::ConstructL +// ----------------------------------------------------------------------------- +// +void CMceEventContext::ConstructL( CMceComEvent& aEvent ) + { + InitializeStateArrayL(aEvent); + SetCurrentStateL( aEvent, KMceIdleEventStateIndex ); + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::~CMceEventContext +// ----------------------------------------------------------------------------- +// +CMceEventContext::~CMceEventContext() + { + if ( iStates ) + { + iStates->ResetAndDestroy(); + iStates->Close(); + delete iStates; + iStates = NULL; + } + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::SetCurrentState +// ----------------------------------------------------------------------------- +// +void CMceEventContext::SetCurrentStateL( CMceComEvent& aEvent, + TMceEventStateIndex aNewEventState ) + { + TInt leave = KErrNone; + if (aNewEventState > KMceSrvEventStateArraySize-1) + { + leave = KMceEventStateError; + } + // Check, if the transition is valid + if(aEvent.SIPEvent().EventStateType()==EMoSubscribe || + aEvent.SIPEvent().EventStateType()==EMoRefer) + { + if ( !IsMoStateTransitionAccepted( aNewEventState ) ) + { + leave = KMceEventStateError; + } + else + { + iCurrentState = ( *iStates )[ aNewEventState ]; + } + } + else //MT + { + if ( !IsMtStateTransitionAccepted( aNewEventState ) ) + { + leave = KMceEventStateError; + } + else + { + iCurrentState = ( *iStates )[ aNewEventState ]; + } + } + User::LeaveIfError( leave ); + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::CurrentState() +// ----------------------------------------------------------------------------- +// +TMceEventStateIndex CMceEventContext::CurrentState() + { + return iStates->Find( iCurrentState ); + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::ProcessSubscribeEventL +// ----------------------------------------------------------------------------- +// +void CMceEventContext::ProcessEventL( CMceComEvent& aEvent ) + { + iCurrentState->ProcessStateL( aEvent ); + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::ProcessRequestReceivedEventL +// ----------------------------------------------------------------------------- +// +void CMceEventContext::ProcessRequestReceivedEventL( CMceComEvent& aEvent ) + { + iCurrentState->ProcessReqRecvStateL( aEvent ); + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::ProcessIncomingResponseEventL +// ----------------------------------------------------------------------------- +// +void CMceEventContext::ProcessIncomingResponseEventL( CMceComEvent& aEvent ) + { + iCurrentState->ProcessRespRecvStateL( aEvent ); + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::InitializeStateArrayL +// ----------------------------------------------------------------------------- +// +void CMceEventContext::InitializeStateArrayL( CMceComEvent& aEvent ) + { + // Create state array + iStates = new ( ELeave ) RPointerArray< CMceEventStateBase >( + KMceSrvEventStateArraySize ); + + // States common for MO and MT are created here. + // Established event state + if (aEvent.SIPEvent().EventStateType()==EMoSubscribe) + { + InitialSubscribeCommonStatesL(); + //moSubscirbe State + // MO Idle state + CMceEventSubscribeMoIdleState* idleEvent = + new( ELeave ) CMceEventSubscribeMoIdleState(); + CleanupStack::PushL( idleEvent ); + User::LeaveIfError( iStates->Insert( + idleEvent, KMceIdleEventStateIndex ) ); + CleanupStack::Pop( idleEvent ); + + // MO Establishing state + + CMceEventSubscribeMoEstablishingState* establishingEvent = + new( ELeave ) CMceEventSubscribeMoEstablishingState(); + CleanupStack::PushL( establishingEvent ); + User::LeaveIfError( iStates->Insert( + establishingEvent, KMceEstablishingEventStateIndex ) ); + CleanupStack::Pop( establishingEvent ); + + CMceEventSubscribeMoEstablishedState* established = + new( ELeave ) CMceEventSubscribeMoEstablishedState(); + CleanupStack::PushL( established ); + User::LeaveIfError( iStates->Insert( + established, KMceEstablishedEventStateIndex ) ); + CleanupStack::Pop( established ); + } + else if(aEvent.SIPEvent().EventStateType()==EMtSubscribe) + { + InitialSubscribeCommonStatesL(); + //mtSubscribe State + // MT Idle state + CMceEventSubscribeMtIdleState* idleEvent = + new( ELeave ) CMceEventSubscribeMtIdleState(); + CleanupStack::PushL( idleEvent ); + User::LeaveIfError( iStates->Insert( + idleEvent, KMceIdleEventStateIndex ) ); + CleanupStack::Pop( idleEvent ); + + // Mt establishing state + CMceEventSubscribeMtEstablishingState* establishing = + new ( ELeave ) CMceEventSubscribeMtEstablishingState(); + CleanupStack::PushL( establishing ); + User::LeaveIfError( iStates->Insert( + establishing, KMceEstablishingEventStateIndex ) ); + CleanupStack::Pop( establishing ); + + //Mt established + CMceEventSubscribeMtEstablishedState* established = + new( ELeave ) CMceEventSubscribeMtEstablishedState(); + CleanupStack::PushL( established ); + User::LeaveIfError( iStates->Insert( + established, KMceEstablishedEventStateIndex ) ); + CleanupStack::Pop( established ); + } + else if(aEvent.SIPEvent().EventStateType()==EMoRefer) + { + InitialReferCommonStatesL(); + //moReferState + // MO Idle state + CMceEventReferMoIdleState* idleEvent = + new( ELeave )CMceEventReferMoIdleState(); + CleanupStack::PushL( idleEvent ); + User::LeaveIfError( iStates->Insert( + idleEvent, KMceIdleEventStateIndex ) ); + CleanupStack::Pop( idleEvent ); + + // MO Establishing state + CMceEventReferMoEstablishingState* establishingEvent = + new( ELeave )CMceEventReferMoEstablishingState; + CleanupStack::PushL( establishingEvent ); + User::LeaveIfError( iStates->Insert( + establishingEvent, KMceEstablishingEventStateIndex ) ); + CleanupStack::Pop( establishingEvent ); + //Mo Established + CMceEventReferMoEstablishedState* established = + new( ELeave ) CMceEventReferMoEstablishedState(); + CleanupStack::PushL( established ); + User::LeaveIfError( iStates->Insert( + established, KMceEstablishedEventStateIndex ) ); + CleanupStack::Pop( established ); + } + else + { + InitialReferCommonStatesL(); + //mtReferState + // MT Idle state + CMceEventReferMtIdleState* idleEvent = + new( ELeave ) CMceEventReferMtIdleState(); + CleanupStack::PushL( idleEvent ); + User::LeaveIfError( iStates->Insert( + idleEvent, KMceIdleEventStateIndex ) ); + CleanupStack::Pop( idleEvent ); + + // Server establishing state + CMceEventReferMtEstablishingState* establishing = + new( ELeave ) CMceEventReferMtEstablishingState(); + CleanupStack::PushL( establishing ); + User::LeaveIfError( iStates->Insert( + establishing, KMceEstablishingEventStateIndex ) ); + CleanupStack::Pop( establishing ); + //Mt established + CMceEventReferMtEstablishedState* established = + new( ELeave )CMceEventReferMtEstablishedState(); + CleanupStack::PushL( established ); + User::LeaveIfError( iStates->Insert( + established, KMceEstablishedEventStateIndex ) ); + CleanupStack::Pop( established ); + } + + } +// ----------------------------------------------------------------------------- +// CMceEventContext::InitialSubscribeCommonStates +// ----------------------------------------------------------------------------- +// +void CMceEventContext::InitialSubscribeCommonStatesL() + { + // Terminating event state + CMceEventSubscribeTerminatingState* terminating = + new( ELeave )CMceEventSubscribeTerminatingState(); + CleanupStack::PushL( terminating ); + User::LeaveIfError( iStates->Insert( + terminating, KMceTerminatingEventStateIndex ) ); + CleanupStack::Pop( terminating ); + + // Terminated event state + CMceEventSubscribeTerminatedState* terminated = + new( ELeave ) CMceEventSubscribeTerminatedState(); + CleanupStack::PushL( terminated ); + User::LeaveIfError( iStates->Insert( + terminated, KMceTerminatedEventStateIndex ) ); + CleanupStack::Pop( terminated ); + } + +// ----------------------------------------------------------------------------- +// CMceEventContext::InitialReferCommonStates +// ----------------------------------------------------------------------------- +// +void CMceEventContext::InitialReferCommonStatesL() + { + // Terminating event state + CMceEventReferTerminatingState* terminating = + new( ELeave ) CMceEventReferTerminatingState(); + CleanupStack::PushL( terminating ); + User::LeaveIfError( iStates->Insert( + terminating, KMceTerminatingEventStateIndex ) ); + CleanupStack::Pop( terminating ); + + // Terminated event state + CMceEventReferTerminatedState* terminated = + new( ELeave ) CMceEventReferTerminatedState(); + CleanupStack::PushL( terminated ); + User::LeaveIfError( iStates->Insert( + terminated, KMceTerminatedEventStateIndex ) ); + CleanupStack::Pop( terminated ); + } + +// ----------------------------------------------------------------------------- +// CMCEMoEventSubscribeContext::IsMoStateTransitionAccepted +// ----------------------------------------------------------------------------- +// +TBool CMceEventContext::IsMoStateTransitionAccepted( + TMceEventStateIndex aNewState ) + { + // Call the parent function. + return IsStateTransitionAccepted( aNewState ); + } + +// ----------------------------------------------------------------------------- +// CMceSrvMoEventContext::IsMtStateTransitionAccepted +// ----------------------------------------------------------------------------- +// +TBool CMceEventContext::IsMtStateTransitionAccepted( + TMceEventStateIndex aNewState ) + { + TMceEventStateIndex currentState = CurrentState(); + TBool ret = IsStateTransitionAccepted( aNewState ); + if ( !ret ) + { + switch ( currentState ) + { + case KMceIdleEventStateIndex: + { + // From MT event idle state, transition to client establishing + // state is allowed. + if (KMceEstablishedEventStateIndex == aNewState || + KMceTerminatedEventStateIndex == aNewState ) + { + ret = ETrue; + } + break; + } + + default: + { + ret = EFalse; + break; + } + } + } + return ret; + } + + +// ----------------------------------------------------------------------------- +// CMceEventContext::IsStateTransitionAccepted +// ----------------------------------------------------------------------------- +// +TMceEventStateIndex CMceEventContext::IsStateTransitionAccepted( + TMceEventStateIndex aNewState ) + { + TMceEventStateIndex current = CurrentState(); + switch( current ) + { + case KErrNotFound: + { + // Only idle state can be the first one. + if ( KMceIdleEventStateIndex == aNewState ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + case KMceIdleEventStateIndex: + { + if ( KMceEstablishingEventStateIndex == aNewState ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + case KMceEstablishingEventStateIndex: + { + if ( KMceEstablishedEventStateIndex == aNewState || + KMceTerminatedEventStateIndex == aNewState ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + case KMceEstablishedEventStateIndex: + { + if ( KMceEstablishingEventStateIndex == aNewState || + KMceEstablishedEventStateIndex == aNewState || + KMceTerminatingEventStateIndex == aNewState || + KMceTerminatedEventStateIndex == aNewState ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + case KMceTerminatingEventStateIndex: + { + // From terminating state, transition to terminated is accepted. + if ( KMceTerminatedEventStateIndex == aNewState ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + default: + { + // From terminated state no transition is allowed. + // All the states are handled either here or in separate methods + // for MO or MT events. + return EFalse; + } + + } + + } +