diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/inc/ss_connstates.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/inc/ss_connstates.h Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,695 @@ +// Copyright (c) 1997-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: +// + +#ifndef SYMBIAN_SS_CONNSTATES_H +#define SYMBIAN_SS_CONNSTATES_H + +#define SYMBIAN_NETWORKING_UPS + +#include +#include +#include +#include "SS_conn.H" +#include +#include "ss_internal_activities.h" + +#include // for TSelectionPrefs + +namespace ConnStates +{ +typedef MeshMachine::TNodeContext TContext; + + +// +//Mutex checking the progress queue +class TEmptyProgressQueueMutex + { +public: + static TBool IsBlocked(TContext& aContext) + { + return aContext.Node().iProgressQueue.IsEmpty(); + } + }; + +typedef MeshMachine::TActivitiesIdMutex TStartAttachMutex; + +// +//Start + + +DECLARE_SMELEMENT_HEADER( TErrorIfAlreadyStartedAttached, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TErrorIfAlreadyStartedAttached ) + +DECLARE_SMELEMENT_HEADER( TClearProgressQueue, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TClearProgressQueue ) + +DECLARE_SMELEMENT_HEADER( TParseECNStart, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TParseECNStart ) + +DECLARE_SMELEMENT_HEADER( TSendStartingSelectionStateChange, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TSendStartingSelectionStateChange ) + +DECLARE_SMELEMENT_HEADER( TRequestCSRCreation, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TRequestCSRCreation ) + +DECLARE_SMELEMENT_HEADER( TProcessCSRCreation, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TProcessCSRCreation ) + + +DECLARE_SERIALIZABLE_TRANSITION( + TProcessStartBlockedByStop, + MeshMachine::TActivityIdMutex, + ConnStates::TParseECNStart + ) + +DECLARE_SMELEMENT_HEADER( TSelectMetaPlane, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TSelectMetaPlane ) + +DECLARE_SMELEMENT_HEADER( TJoinReceivedCpr, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TJoinReceivedCpr ) + +DECLARE_SMELEMENT_HEADER( TSendFinishedSelectionStateChange, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TSendFinishedSelectionStateChange ) + + +DECLARE_SMELEMENT_HEADER( TJoinReceivedSCpr, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TJoinReceivedSCpr ) + +DECLARE_SMELEMENT_HEADER( TJoinReceivedMcpr, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TJoinReceivedMcpr ) + + +DECLARE_SMELEMENT_HEADER( TRequestCommsBinder, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TRequestCommsBinder ) + +DECLARE_SMELEMENT_HEADER( TRequestCommsBinderFromMcpr, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TRequestCommsBinderFromMcpr ) + +DECLARE_SMELEMENT_HEADER( TProcessBinderResponseForCpr, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TProcessBinderResponseForCpr ) + +DECLARE_SMELEMENT_HEADER( TStartConnection, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TStartConnection ) + +DECLARE_AGGREGATED_TRANSITION2( + TSendFinishedSelectionAndJoinReceivedCpr, + ConnStates::TSendFinishedSelectionStateChange, + ConnStates::TJoinReceivedCpr + ) + +DECLARE_SMELEMENT_HEADER( TErrorOrCancel, MeshMachine::TStateFork, NetStateMachine::MStateFork, ConnStates::TContext ) + virtual TInt TransitionTag(); +DECLARE_SMELEMENT_FOOTER( TErrorOrCancel ) + +// +//Attach +DECLARE_SMELEMENT_HEADER( TParseECNAttach, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TParseECNAttach ) + +DECLARE_AGGREGATED_TRANSITION4( + TProcessAttach, + ConnStates::TErrorIfAlreadyStartedAttached, + ConnStates::TParseECNAttach, + ConnStates::TClearProgressQueue, + ConnStates::TRequestCSRCreation + ) + +DECLARE_SERIALIZABLE_TRANSITION( + TProcessAttachBlockedByStop, + MeshMachine::TActivityIdMutex, + ConnStates::TProcessAttach + ) + +DECLARE_SMELEMENT_HEADER( TCompleteLegacyAttach, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TCompleteLegacyAttach ) + +// +//WaitForIncoming +DECLARE_SMELEMENT_HEADER( TRequestIncomingConnection, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TRequestIncomingConnection ) + +DECLARE_SMELEMENT_HEADER( TProcessIncomingConnection, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TProcessIncomingConnection ) + +DECLARE_SERIALIZABLE_TRANSITION( + TRequestIncomingConnectionBlockedByStartAttach, + TStartAttachMutex, + ConnStates::TRequestIncomingConnection + ) + +// +//Stop +DECLARE_SMELEMENT_HEADER( TSendStopConnection, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TSendStopConnection ) + +DECLARE_SMELEMENT_HEADER( TCancelStartOrAttachConnection, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TCancelStartOrAttachConnection ) + +DECLARE_SMELEMENT_HEADER( TConnectionSendStopSCPR, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TConnectionSendStopSCPR ) + +DECLARE_SMELEMENT_HEADER( TAwaitingGoneDown, CoreNetStates::TAwaitingGoneDown, NetStateMachine::MState, TContext ) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER( TAwaitingGoneDown ) + +typedef MeshMachine::TActivitiesIdMutex TStartAttachMutex; + +DECLARE_SERIALIZABLE_STATE( + TNoTagOrNoBearerBlockedByStartOrAttach, + TStartAttachMutex, + CoreNetStates::TNoTagOrNoBearer + ) + +// +//Close + +const TInt KCancelAllInterfaceWorker = 10000; + +DECLARE_SMELEMENT_HEADER(TDetachDataClients, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TDetachDataClients) + +DECLARE_SMELEMENT_HEADER( TStartOrAttachActive, MeshMachine::TStateFork, NetStateMachine::MStateFork, ConnStates::TContext ) + virtual TInt TransitionTag(); +DECLARE_SMELEMENT_FOOTER( TStartOrAttachActive ) + +DECLARE_SMELEMENT_HEADER( TNoTagOrCancelAllInterfaceWorker, MeshMachine::TStateFork, NetStateMachine::MStateFork, ConnStates::TContext ) + virtual TInt TransitionTag(); +DECLARE_SMELEMENT_FOOTER( TNoTagOrCancelAllInterfaceWorker ) + +DECLARE_SMELEMENT_HEADER( TCancelAllInterfaceNotificationWorker, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TCancelAllInterfaceNotificationWorker ) + +DECLARE_SERIALIZABLE_STATE( + TActiveOrNoTagBlockedByStopOrGoneDown, + CoreNetStates::TActivityStopAndGoneDownMutex, + TStartOrAttachActive + ) + +DECLARE_SERIALIZABLE_STATE( + TNoTagBlockedByStartOrAttach, + TStartAttachMutex, + MeshMachine::TNoTag + ) + +DECLARE_AGGREGATED_TRANSITION2( + TProcessClose, + SubSessStates::TProcessClose, + TDetachDataClients + ) + +// +//Progress & Progress Request +DECLARE_SMELEMENT_HEADER( TProcessStateChange, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) //From the framework + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TProcessStateChange ) + +DECLARE_SMELEMENT_HEADER( TProcessProgressRequest, SubSessStates::TECABStateTransitionBase, NetStateMachine::MStateTransition, TContext ) //From the client + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TProcessProgressRequest ) + +DECLARE_SERIALIZABLE_TRANSITION( + ProcessProgressRequestBlockedByEmptyProgressQueue, + TEmptyProgressQueueMutex, + ConnStates::TProcessProgressRequest + ) + + +DECLARE_SMELEMENT_HEADER( TGenerateConnectionUpProgress, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) //From the framework + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TGenerateConnectionUpProgress ) + +DECLARE_SMELEMENT_HEADER( TGenerateConnectionDownProgress, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) //From the framework + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TGenerateConnectionDownProgress ) + + + + + +// +// Legacy enumeration support +DECLARE_SMELEMENT_HEADER( TAwaitingEnumResponse, MeshMachine::TState, NetStateMachine::MState, TContext ) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER( TAwaitingEnumResponse ) + +DECLARE_SMELEMENT_HEADER( TProcessEnumResponse, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TProcessEnumResponse ) + +// +// Legacy RMessage2 handling + +DECLARE_SMELEMENT_HEADER( TProcessLegacyRMessage2, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TProcessLegacyRMessage2 ) + +DECLARE_SMELEMENT_HEADER( TCompleteRMessage2, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TCompleteRMessage2 ) + +DECLARE_SMELEMENT_HEADER( THandleRMessage2Error, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( THandleRMessage2Error ) + +DECLARE_SMELEMENT_HEADER( TCancelAllLegacyRMessage2Activities, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TCancelAllLegacyRMessage2Activities ) + +typedef MeshMachine::TActivityIdMutex TLegacyRMessage2ActivitiesMutex; + +DECLARE_SERIALIZABLE_STATE( + TNoTagBlockedByLegacyRMessage2Activities, + TLegacyRMessage2ActivitiesMutex, + MeshMachine::TNoTag + ) + +} // namespace ConnStates + + +namespace AllInterfaceNotificationActivity +{ +class TAddClient; +class TFindTierManager; +class TAwaitingTierManager; +class TJoinTierManager; +class TStartLinkNotification; +class TAwaitingLinkNotification; +class TAwaitingLinkNotificationError; +class TEnqueueNotification; +class TCancelLinkNotification; +class TLeaveTierManager; +} + +namespace EnumerateConnectionsActivity +{ +class TAwaitingTierStatus; +class TQueryTierStatus; +} + +namespace ConnActivities +{ + +// +//CStartAttachActivity +class CStartAttachActivity : public SubSessActivities::CESockClientActivityBase, public CoreActivities::ABindingActivity, + public ITFHIERARCHY_LINK_1(CStartAttachActivity, SubSessActivities::CESockClientActivityBase, CoreActivities::ABindingActivity) + { + friend class ConnStates::TParseECNStart; + +public: + typedef ITFHIERARCHY_LINK_1(CStartAttachActivity, SubSessActivities::CESockClientActivityBase, CoreActivities::ABindingActivity) TIfStaticFetcherNearestInHierarchy; + +public: + //Transition Tags + static const TInt KExecuteLegacyAttach = 1; + static const TInt KWaitAvailable = 2; + static const TInt KCancelTag = 3; + static const TInt KStartPrefsSetTag = 4; + + static const TInt KUpsErrorTag = 10011; + + +public: + void SetSelectionScope(TUint aSelectionScope) { iConnPrefs.SetScope(aSelectionScope); } + void SetSelectionFlags(TUint aSelectionScope) { iConnPrefs.SetFlags(aSelectionScope); } + ESock::TSelectionPrefs& SelectionPrefs() { return iConnPrefs; } + + void SetCSRPreferences(TConnCSRPref* aCustomPrefs) { iCSRPreferences = aCustomPrefs; } + TConnCSRPref* CSRPreferences() { return iCSRPreferences; } + + TConnPrefList* ConnPrefList() { return iConnPrefList; } + void SetConnPrefList(TConnPrefList* aConnPrefList){ iConnPrefList = aConnPrefList; } + void SetCSR(const Messages::TNodeId& aCSR) { iCSR = aCSR; } + const Messages::TNodeId& CSR() const { return iCSR; } + static MeshMachine::CNodeActivityBase* NewStartConnectionActivityL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode); + static MeshMachine::CNodeActivityBase* NewWaitForIncomingConnectionActivityL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode); + + virtual ~CStartAttachActivity(); + + virtual TBool Next(MeshMachine::TNodeContextBase& aContext); + + void ReturnInterfacePtrL(CoreActivities::ABindingActivity*& aInterface) + { + aInterface = this; + } + TBool& AutoStartPresent() + { + return iIsAutoStartPresent; + } + +protected: + CStartAttachActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode) + : CESockClientActivityBase(aActivitySig, aNode), + CoreActivities::ABindingActivity(aNode.Id()), + TIfStaticFetcherNearestInHierarchy(this), + iConnPrefs() + { + } + +private: + ESock::TSelectionPrefs iConnPrefs; + Messages::TNodeId iCSR; + TConnPrefList* iConnPrefList; + TConnCSRPref* iCSRPreferences; + TBool iIsAutoStartPresent; + +protected: + typedef MeshMachine::TNodeContext TContext; + +//States, StateForks & StateTransitions +public: + DECLARE_SMELEMENT_HEADER( TNoTagOrStartPrefsSetTag, MeshMachine::TStateFork, NetStateMachine::MStateFork, TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrStartPrefsSetTag ) + + typedef MeshMachine::TTag TStartPrefsSetTag; + + //Not the first state fork on the ECAB, so just normal state fork + DECLARE_SMELEMENT_HEADER( TNoTagOrLegacyAttach, MeshMachine::TStateFork, NetStateMachine::MStateFork, ConnStates::TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrLegacyAttach ) + + DECLARE_SMELEMENT_HEADER( TNoTagOrWaitAvailable, MeshMachine::TStateFork, NetStateMachine::MStateFork, ConnStates::TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrWaitAvailable ) + + DECLARE_SMELEMENT_HEADER( TErrorTagOrWaitAvailableBackward, MeshMachine::TStateFork, NetStateMachine::MStateFork, ConnStates::TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TErrorTagOrWaitAvailableBackward ) + + DECLARE_SMELEMENT_HEADER( TAwaitingAvailableOrError, MeshMachine::TState, NetStateMachine::MState, TContext ) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingAvailableOrError ) + + DECLARE_SMELEMENT_HEADER( TSubscribeForAvailability, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSubscribeForAvailability ) + + DECLARE_SMELEMENT_HEADER(TAwaitingSelectCompleteOrError, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER(TAwaitingSelectCompleteOrError) + + + DECLARE_AGGREGATED_TRANSITION2( + TSendBindToCompleteAndCompleteLegacyAttach, + TSendBindToComplete, + ConnStates::TCompleteLegacyAttach + ) + +#ifdef SYMBIAN_NETWORKING_UPS + DECLARE_SMELEMENT_HEADER(TSendPolicyCheckRequestToServiceProvider, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, ConnStates::TContext) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER(TSendPolicyCheckRequestToServiceProvider) + + DECLARE_SMELEMENT_HEADER(TNoTagOrUpsErrorTag, MeshMachine::TStateFork, NetStateMachine::MStateFork, ConnStates::TContext) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER(TNoTagOrUpsErrorTag) +#endif + + }; + +/** + A base activity for activities wishing to interact with a tier manager. +*/ +class CTierManagerActivity : public SubSessActivities::CESockClientActivityBase + { +public: + typedef MeshMachine::TNodeContext TContext; + +public: + static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode); + + // States + DECLARE_SMELEMENT_HEADER(TAwaitingTierManager, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER(TAwaitingTierManager) + + DECLARE_SMELEMENT_HEADER(TAwaitingJoinComplete, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER(TAwaitingJoinComplete) + + // Transitions + DECLARE_SMELEMENT_HEADER(TFindTierManager, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER(TFindTierManager) + + DECLARE_SMELEMENT_HEADER(TJoinTierManager, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER(TJoinTierManager) + + DECLARE_SMELEMENT_HEADER(TLeaveTierManager, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER(TLeaveTierManager) + +protected: + CTierManagerActivity (const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode) : + CESockClientActivityBase(aActivitySig, aNode) + { + iTierUid = TUid::Null(); + } + +protected: + TUid iTierUid; + Messages::TNodeId iTierManager; + }; + +const TInt KIPProtoTierId = 0x10281DF0; + +/** + An activity supporting the legacy RConnection::AllInterfaceNotification method. +*/ +NONSHARABLE_CLASS(CAllInterfaceNotificationActivity) : public MeshMachine::CNodeActivityBase + { +friend class AllInterfaceNotificationActivity::TAddClient; +friend class AllInterfaceNotificationActivity::TFindTierManager; +friend class AllInterfaceNotificationActivity::TAwaitingTierManager; +friend class AllInterfaceNotificationActivity::TJoinTierManager; +friend class AllInterfaceNotificationActivity::TStartLinkNotification; +friend class AllInterfaceNotificationActivity::TAwaitingLinkNotification; +friend class AllInterfaceNotificationActivity::TAwaitingLinkNotificationError; +friend class AllInterfaceNotificationActivity::TEnqueueNotification; +friend class AllInterfaceNotificationActivity::TCancelLinkNotification; +friend class AllInterfaceNotificationActivity::TLeaveTierManager; + +public: + static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode); + +private: + CAllInterfaceNotificationActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode) : + MeshMachine::CNodeActivityBase(aActivitySig, aNode) + { + iTierUid = TUid::Uid(KIPProtoTierId); // IPProto tier + iAllInterfaceNotificationWorker = static_cast(&aNode); + } + + virtual ~CAllInterfaceNotificationActivity(); + +private: + TUid iTierUid; + Messages::TNodeId iTierManager; + const CAllInterfaceNotificationWorker* iAllInterfaceNotificationWorker; + }; + +/** + An activity supporting the legacy RConnection::EnumerateConnections method. +*/ +class CEnumerateConnectionsActivity : public CTierManagerActivity + { +friend class EnumerateConnectionsActivity::TAwaitingTierStatus; +friend class EnumerateConnectionsActivity::TQueryTierStatus; + +public: + static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode); + +private: + CEnumerateConnectionsActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode) : + CTierManagerActivity(aActivitySig, aNode) + { + iTierUid = TUid::Uid(KIPProtoTierId); // Link tier + } + }; + +/** + An activity for handling legacy RMessage2 requests +*/ +class CConnLegacyRMessage2Activity : public MeshMachine::CNodeParallelMessageStoreActivityBase + { +public: + static CNodeActivityBase* NewL( const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode ); + ~CConnLegacyRMessage2Activity(); + + void PanicClient(const TDesC& aCatagory, TInt aCode); + void Complete(TInt aCode); + + void SetCancelRequest(const Den::RSafeMessage& aMessage); + +private: + CConnLegacyRMessage2Activity( const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aNextActivityCount); + +public: + Den::RSafeMessage iSafeMessage; + Den::RSafeMessage iCancelMessage; + }; + +} //namespace ConnActivities + + +/** + Container for activity entities common to CConnection cleanup. +*/ +namespace ConnectionCleanupActivities +{ +typedef MeshMachine::TNodeContext TContext; + +DECLARE_SMELEMENT_HEADER(TNoTagOrNoTagBackwards, MeshMachine::TStateFork, NetStateMachine::MStateFork, TContext) + virtual TInt TransitionTag(); +DECLARE_SMELEMENT_FOOTER(TNoTagOrNoTagBackwards) +} + +namespace AllInterfaceNotificationActivity +{ +typedef MeshMachine::TNodeContext TContext; + +// States +DECLARE_SMELEMENT_HEADER(TAwaitingTierManager, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER(TAwaitingTierManager) + +DECLARE_SMELEMENT_HEADER(TAwaitingJoinComplete, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER(TAwaitingJoinComplete) + +DECLARE_SMELEMENT_HEADER(TAwaitingStart, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER(TAwaitingStart) + +DECLARE_SMELEMENT_HEADER(TAwaitingLinkNotification, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); + virtual void Cancel(); +DECLARE_SMELEMENT_FOOTER(TAwaitingLinkNotification) + +DECLARE_SMELEMENT_HEADER(TAwaitingLinkNotificationError, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER(TAwaitingLinkNotificationError) + +// Transitions +DECLARE_SMELEMENT_HEADER(TAddClient, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TAddClient) + +DECLARE_SMELEMENT_HEADER(TFindTierManager, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TFindTierManager) + +DECLARE_SMELEMENT_HEADER(TJoinTierManager, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TJoinTierManager) + +DECLARE_SMELEMENT_HEADER(TStartLinkNotification, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TStartLinkNotification) + +DECLARE_SMELEMENT_HEADER(TEnqueueNotification, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TEnqueueNotification) + +DECLARE_SMELEMENT_HEADER(TCancelLinkNotification, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TCancelLinkNotification) + +DECLARE_SMELEMENT_HEADER(TLeaveTierManager, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TLeaveTierManager) + +DECLARE_SMELEMENT_HEADER( TSendErrorToConnection, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER( TSendErrorToConnection ) +} + +namespace ConnectionGoingDownActivity +{ +typedef MeshMachine::TNodeContext TContext; + +DECLARE_SMELEMENT_HEADER(TStoreGoneDownError, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TStoreGoneDownError) +} + +namespace EnumerateConnectionsActivity +{ +typedef MeshMachine::TNodeContext TContext; + +// States +DECLARE_SMELEMENT_HEADER(TAwaitingTierStatus, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER(TAwaitingTierStatus) + +// Transitions +DECLARE_SMELEMENT_HEADER(TQueryTierStatus, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TQueryTierStatus) + +DECLARE_SMELEMENT_HEADER(TCacheConnectionInfo, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TCacheConnectionInfo) + +DECLARE_SMELEMENT_HEADER(TCompleteClient, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TCompleteClient) +} + + +namespace ConnSubConnEventsActivity +{ +typedef MeshMachine::TNodeContext TContext; + +// States +DECLARE_SMELEMENT_HEADER(TAwaitingSubConnEvent, MeshMachine::TState, NetStateMachine::MState, TContext) + virtual TBool Accept(); +DECLARE_SMELEMENT_FOOTER(TAwaitingSubConnEvent) + +// Transitions +DECLARE_SMELEMENT_HEADER(TProcessSubConnEvent, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext) + virtual void DoL(); +DECLARE_SMELEMENT_FOOTER(TProcessSubConnEvent) +} + +#endif +// SYMBIAN_SS_CONNSTATES_H +