datacommsserver/esockserver/CoreProviders/inc/corecpractivities.h
changeset 0 dfb7c4ff071f
child 18 9644881fedd0
equal deleted inserted replaced
-1:000000000000 0:dfb7c4ff071f
       
     1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 // Core CPR Activities
       
    15 // 
       
    16 //
       
    17 
       
    18 /**
       
    19  @file
       
    20  @internalComponent
       
    21 */
       
    22 
       
    23 #ifndef SYMBIAN_CORECPRACTIVITIES_H
       
    24 #define SYMBIAN_CORECPRACTIVITIES_H
       
    25 
       
    26 #include <elements/sm_core.h>
       
    27 #include <comms-infras/ss_corepractivities.h>
       
    28 #include <comms-infras/corecprstates.h>
       
    29 
       
    30 
       
    31 
       
    32 namespace CprActivities
       
    33 {
       
    34 
       
    35 DECLARE_EXPORT_ACTIVITY_MAP(coreCprActivities)
       
    36 
       
    37 
       
    38 } //namespace CprActivities
       
    39 
       
    40 namespace CprDataClientStartActivity
       
    41 {
       
    42 typedef MeshMachine::TNodeContext<CCoreConnectionProvider, PRStates::TContext> TContext;
       
    43 
       
    44 EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrNoTagBackward, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )
       
    45 	IMPORT_C virtual TInt TransitionTag();
       
    46 DECLARE_SMELEMENT_FOOTER( TNoTagOrNoTagBackward )
       
    47 
       
    48 EXPORT_DECLARE_SMELEMENT_HEADER( TStartDataClient, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
       
    49 	IMPORT_C virtual void DoL();
       
    50 DECLARE_SMELEMENT_FOOTER( TStartDataClient )
       
    51 
       
    52 class CDataClientStartActivity : public MeshMachine::CNodeActivityBase
       
    53 	{
       
    54 public:
       
    55     static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)
       
    56 			{ return new(ELeave) CDataClientStartActivity(aActivitySig, aNode); }
       
    57 
       
    58 	virtual ~CDataClientStartActivity() {}
       
    59 
       
    60 public:
       
    61 	Messages::TClientIter<Messages::TDefaultClientMatchPolicy> iClientIter;
       
    62 
       
    63 protected:
       
    64 	IMPORT_C CDataClientStartActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);
       
    65 	};
       
    66 
       
    67 }
       
    68 
       
    69 namespace CprPriorityUpdateActivity
       
    70 {
       
    71 class CPriorityUpdateActivity : public MeshMachine::CNodeParallelActivityBase
       
    72 	{
       
    73 public:
       
    74 	TUint Priority() const
       
    75 		{
       
    76 		return iLastPriority;
       
    77 		}
       
    78 	void SetPriority(TUint aPriority)
       
    79 		{
       
    80 		iLastPriority = aPriority;
       
    81 		}
       
    82 	TBool UpdatePriority() const
       
    83 		{
       
    84 		return iUpdatePriority;
       
    85 		}
       
    86 public:
       
    87 	EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrSendPriorityToCtrlProvider, MeshMachine::TStateFork<CprStates::TContext>, NetStateMachine::MStateFork, CprStates::TContext )
       
    88 		IMPORT_C virtual TInt TransitionTag();
       
    89 	DECLARE_SMELEMENT_FOOTER( TNoTagOrSendPriorityToCtrlProvider )
       
    90 
       
    91 	EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrSendPriorityToServProvider, MeshMachine::TStateFork<CprStates::TContext>, NetStateMachine::MStateFork, CprStates::TContext )
       
    92 		IMPORT_C virtual TInt TransitionTag();
       
    93 	DECLARE_SMELEMENT_FOOTER( TNoTagOrSendPriorityToServProvider )
       
    94 
       
    95 	EXPORT_DECLARE_SMELEMENT_HEADER( TUpdatePriorityForServiceProviders, MeshMachine::TStateTransition<CprStates::TContext>, NetStateMachine::MStateTransition, CprStates::TContext )
       
    96 		IMPORT_C virtual void DoL();
       
    97 	DECLARE_SMELEMENT_FOOTER( TUpdatePriorityForServiceProvider )
       
    98 
       
    99 	EXPORT_DECLARE_SMELEMENT_HEADER( TUpdatePriorityForControlProvider, MeshMachine::TStateTransition<CprStates::TContext>, NetStateMachine::MStateTransition, CprStates::TContext )
       
   100 		IMPORT_C virtual void DoL();
       
   101 	DECLARE_SMELEMENT_FOOTER( TUpdatePriorityForControlProvider )
       
   102 
       
   103 protected:
       
   104 	CPriorityUpdateActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aActivitiesCount);
       
   105 	
       
   106 protected:
       
   107 	TBool iUpdatePriority;
       
   108 
       
   109 private:
       
   110 	TUint iLastPriority;
       
   111 	};
       
   112 }
       
   113 
       
   114 namespace CprControlClientJoinActivity
       
   115 {
       
   116 class CControlClientJoinActivity : public CprPriorityUpdateActivity::CPriorityUpdateActivity
       
   117 	{
       
   118 public:
       
   119 	IMPORT_C static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);
       
   120 	IMPORT_C virtual ~CControlClientJoinActivity();
       
   121 
       
   122 public:
       
   123 
       
   124 	void SaveJoinMessageData(CprStates::TContext& aContext)
       
   125 		{
       
   126 		if (aContext.iMessage.IsMessage<ESock::TCFPeer::TJoinRequest>())
       
   127 			{
       
   128 			iSendJoinComplete = ETrue;
       
   129 			}
       
   130 		if (aContext.Node().FindClient(aContext.iSender))
       
   131 			{
       
   132 			iUpdatePriority = ETrue;
       
   133 			}
       
   134 		}
       
   135 
       
   136 	TBool NeedToSendJoinComplete() const
       
   137 		{
       
   138 		return iSendJoinComplete;
       
   139 		}
       
   140 
       
   141 public:
       
   142 
       
   143 	EXPORT_DECLARE_SMELEMENT_HEADER( TAddClientOrUpdatePriority, MeshMachine::TStateFork<CprStates::TContext>, NetStateMachine::MStateFork, CprStates::TContext )
       
   144 		IMPORT_C virtual TInt TransitionTag();
       
   145 	DECLARE_SMELEMENT_FOOTER( TAddClientOrUpdatePriority )
       
   146 
       
   147 	EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrSendActive, MeshMachine::TStateFork<CprStates::TContext>, NetStateMachine::MStateFork, CprStates::TContext )
       
   148 		IMPORT_C virtual TInt TransitionTag();
       
   149 	DECLARE_SMELEMENT_FOOTER( TNoTagOrSendActive )
       
   150 
       
   151 	EXPORT_DECLARE_SMELEMENT_HEADER( TSendJoinCompleteIfRequest,  MeshMachine::TStateTransition<CprStates::TContext>, NetStateMachine::MStateTransition, CprStates::TContext )
       
   152 		IMPORT_C virtual void DoL();
       
   153 	DECLARE_SMELEMENT_FOOTER( TSendJoinCompleteIfRequest )
       
   154 
       
   155 private:
       
   156 	TBool iSendJoinComplete;
       
   157 
       
   158 protected:
       
   159 	CControlClientJoinActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aActivitiesCount);
       
   160 	};
       
   161 }
       
   162 
       
   163 namespace CprClientLeaveActivity
       
   164 {
       
   165 class CClientLeaveActivity : public CprPriorityUpdateActivity::CPriorityUpdateActivity
       
   166 	{
       
   167 public:
       
   168 	IMPORT_C static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);
       
   169 	IMPORT_C virtual ~CClientLeaveActivity();
       
   170 
       
   171 public:
       
   172 	typedef MeshMachine::TNodeContext<CCoreConnectionProvider, CprStates::TContext> TContext;
       
   173 
       
   174 	void SaveLeaveMessageData(const TContext& aContext)
       
   175 		{
       
   176 		iSendLeaveComplete = aContext.iMessage.IsMessage<ESock::TCFPeer::TLeaveRequest>() ? ETrue: EFalse;
       
   177 		}
       
   178 	
       
   179 	TBool NeedToSendLeaveComplete() const
       
   180 		{
       
   181 		return iSendLeaveComplete;
       
   182 
       
   183 		}
       
   184 public:
       
   185 	EXPORT_DECLARE_SMELEMENT_HEADER( TSendLeaveCompleteIfRequest, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
       
   186 		IMPORT_C virtual void DoL();
       
   187 	DECLARE_SMELEMENT_FOOTER( TSendLeaveCompleteIfRequest )
       
   188 
       
   189 	EXPORT_DECLARE_SMELEMENT_HEADER( TSaveLeaveMessageData, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
       
   190 		IMPORT_C virtual void DoL();
       
   191 	DECLARE_SMELEMENT_FOOTER( TSaveLeaveMessageData )
       
   192 
       
   193 	DECLARE_AGGREGATED_TRANSITION2(
       
   194 		TSendLeaveCompleteAndSendDataClientIdleIfNeeded,
       
   195 		TSendLeaveCompleteIfRequest,
       
   196 		CoreNetStates::TSendDataClientIdleIfNoClients
       
   197 		)
       
   198 	DECLARE_AGGREGATED_TRANSITION3(
       
   199 		TRemoveClientAndDestroyOrphanedDataClients,
       
   200 		TSaveLeaveMessageData,
       
   201 		MeshMachine::TRemoveClient,
       
   202 		PRStates::TDestroyOrphanedDataClients
       
   203 		)
       
   204 
       
   205 private:
       
   206 	TBool iSendLeaveComplete;
       
   207 
       
   208 protected:
       
   209 	CClientLeaveActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aActivitiesCount);
       
   210 	};
       
   211 }
       
   212 
       
   213 namespace CprBindToActivity
       
   214 {
       
   215 class CCprBindToActivity : public PRActivities::CBindToActivity
       
   216 	{
       
   217 protected:
       
   218 	typedef MeshMachine::TNodeContext<CCoreConnectionProvider, CoreNetStates::TContext> TContext;
       
   219 public:
       
   220 	EXPORT_DECLARE_SMELEMENT_HEADER( TSendControlClientJoinRequestWithPriority, MeshMachine::TStateTransition<CCprBindToActivity::TContext>, NetStateMachine::MStateTransition, CCprBindToActivity::TContext )
       
   221    		virtual void DoL();
       
   222 	DECLARE_SMELEMENT_FOOTER( TSendControlClientJoinRequestWithPriority )
       
   223 
       
   224 protected:
       
   225 	CCprBindToActivity(const MeshMachine::TNodeActivity& aActivitySig,  MeshMachine::AMMNodeBase& aNode, TInt aNextActivityCount);
       
   226 
       
   227 // private:
       
   228 // if you are adding any data here don't forget to override NewL.
       
   229 	};
       
   230 }
       
   231 
       
   232 #endif //SYMBIAN_CORECPRACTIVITIES_H
       
   233