diff -r 000000000000 -r 5a93021fdf25 bearermanagement/S60MCPR/inc/s60mcpractivities.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bearermanagement/S60MCPR/inc/s60mcpractivities.h Thu Dec 17 08:55:21 2009 +0200 @@ -0,0 +1,817 @@ +/* +* Copyright (c) 2008-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: S60 MCPR's activities. +* +*/ + +/** +@file s60mcpractivities.h +S60 MCPR's activities. +*/ + +#ifndef S60MCPR_ACTIVITIES_H +#define S60MCPR_ACTIVITIES_H + +#include + +#include "s60mcprstates.h" + +// Forward declarations +class CS60MetaConnectionProvider; + +enum TS60MCprActivities + { + ECFActivityS60McprServiceIdMessage2Handler = ESock::ECFActivityCustom + 10 + }; + +/** + * S60MCprActivities namespace contains the + * definition of S60MCPR's activity map. + */ +namespace S60MCprActivities + { + DECLARE_ACTIVITY_MAP(S60MCprActivityMap) + } // namespace S60MCprActivities + + +/** + * S60MCprSelectActivity namespace packages the + * S60 MCPR's connection selection activity related + * states, transitions and forks. + * + * The activity doesn't need activity class because it + * reuses the Symbian's core implementation for + * selection. + * + */ +namespace S60MCprSelectActivity + { + /** + * Execution context definition for meshmachine activities. + */ + typedef MeshMachine::TNodeContext TContext; + + /** + * STATE: Waits for valid select message. + * @return ETrue if message is accepted. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingSelectNextLayer, + MeshMachine::TState, + NetStateMachine::MState, + TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingSelectNextLayer ) + + /** + * TRANSITION/ACTION: Makes the selection for next layer based on policy or other obtained preferences. + */ + DECLARE_SMELEMENT_HEADER( TSelectNextLayer, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSelectNextLayer ) + + /** + * TRANSITION/ACTION: Requests PolicyServer for Best IAP. + */ + DECLARE_SMELEMENT_HEADER( TSimpleSelect, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSimpleSelect ) + + /** + * STATE: Waits for PolicyServer response + * @return ETrue if valid message policyresponse is received. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingSimpleSelectComplete, + MeshMachine::TState, + NetStateMachine::MState, + TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingSimpleSelectComplete ) + } + +/** + * S60MCprSimpleSelectActivity namespace packages the + * S60 MCPR's connection selection activity related + * states, transitions and forks. + * + * The activity doesn't need activity class because it + * reuses the Symbian's core implementation for + * selection. + * + */ +namespace S60MCprSimpleSelectActivity + { + /** + * Execution context definition for meshmachine activities. + */ + typedef MeshMachine::TNodeContext TContext; + /** + * STATE: Waits for valid select message. + * @return ETrue if message is accepted. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingSelectNextLayer, + MeshMachine::TState, + NetStateMachine::MState, + TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingSelectNextLayer ) + /** + * TRANSITION/ACTION: Makes the selection for next layer based on policy or other obtained preferences. + */ + DECLARE_SMELEMENT_HEADER( TSelectNextLayer, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSelectNextLayer ) + /** + * TRANSITION/ACTION: Requests PolicyServer for Best IAP. + */ + DECLARE_SMELEMENT_HEADER( TChooseBestIAP, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TChooseBestIAP ) + /** + * STATE: Waits for PolicyServer response + * @return ETrue if valid message policyresponse is received. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingChooseBestIAP, + MeshMachine::TState, + NetStateMachine::MState, + TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingChooseBestIAP ) + /** + * FORK/DECISION: Decides between three different activity execution paths: + * 1. Request PolicyServer for connection preferences. + * 2. Proceed and use existing connection preferences. + * 3. Bypass selection and just mark new AP active. + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TChooseBestIAPRequiredOrNoTagOrSetChosenApActive, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TChooseBestIAPRequiredOrNoTagOrSetChosenApActive ) + /** + * FORK/DECISION: Decides between two different activity execution path. + * 1. Mark new chose AP active. + * 2. Reverse back to next layer tiermanager selection. + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TSetChosenApActiveOrSelectedProviderBackward, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TSetChosenApActiveOrSelectedProviderBackward ) + /** + * TRANSITION/ACTION: Marks the chosen AP active. + * + * Transition assumes that the chose AP is already bound to the MCPR + * and will be found from the ServiceProvider -list. + */ + DECLARE_SMELEMENT_HEADER( TSetChosenApActive, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSetChosenApActive ) + /** + * CChooseBestIAPCb is a callback class that receives the policy server response + * and converts PolicyResponse -event into meshmachine compatible message. + * + * PolicyServer wrapper API takes pointer of the class implementing the + * MMPMPolicyRequestsUser -interface. The ownership is passed to the wrapper API + * because the answer may be delayed and live longer than the execution context + * of the MCPR. + */ + class CChooseBestIAPCb + : public CBase, + public MMPMPolicyRequestsUser + { + public: + /** + * C++ constructor. + * + * @param aNode reference to S60 MCPR running the Activity. + * @param aActivity pointer to the Activity that requests for PolicyResponse. + */ + CChooseBestIAPCb( CS60MetaConnectionProvider& aNode, + MeshMachine::CNodeActivityBase* aActivity ) + : iNode(aNode) + { + iLastRequestOriginator.Open( aNode.SelfInterface(), + Messages::TNodeCtxId( aActivity->ActivityId(), + aNode.Id() )); + } + public: // From MMPMPolicyRequestsUser + /** + * Called when Policy Server responds to the request. + * @param aCompletedRequest contains reference to answer from Policy Server. + */ + virtual void PolicyResponse( PolicyRequest& aCompletedRequest ); + /** + * Interface function that calls CBase-destructor + */ + virtual void Delete() { delete this; } + protected: // From CBase + /** + * C++ destructor. + */ + virtual ~CChooseBestIAPCb() {} + private: + /** + * Valid reference to CS60MetaConnectionProvider + */ + CS60MetaConnectionProvider& iNode; + /** + * Valid reference to request originator. + */ + Messages::RRequestOriginator iLastRequestOriginator; + }; + + } // namespace S60MCprSimpleSelectActivity + +/** + * S60MCprErrorRecoveryActivity namespace packages the + * S60 MCPR's error recovery activity related + * states, transitions and forks. + */ +namespace S60MCprErrorRecoveryActivity + { + /** + * Execution context definition for meshmachine activities. + */ + typedef MeshMachine::TNodeContext TContext; + /** + * Mutex that blocks the activity during the mobility handshake. + */ + class THandshakingMobilityMutex + { + public: + /** + * @param aContext execution context. + * @return ETrue if mobility handshake is in progress. + */ + static TBool IsBlocked(MeshMachine::TNodeContextBase& aContext); + }; + /** + * Serialized state. + * Idea is to wait in this state until the mobility handshake is done. + */ + DECLARE_SERIALIZABLE_STATE( TProcessErrorBlockedByMobilityHandshaking, + THandshakingMobilityMutex, + MeshMachine::TTag ) + + /** + * CS60ConnectionRecoveryActivity is the S60 version of the ErrorRecovery -activity + * that is responsible to process connection errors whenever it happens. + * + * -jl- TODO Either finalize or remove S60CConnectionRecoveryActivity after EC158(?) + */ + class CS60ConnectionRecoveryActivity : public S60MCprStates::CS60ErrorRecoveryActivity + { + public: + + /** + * Symbian two-phase constructor. + */ + static MeshMachine::CNodeActivityBase* NewL( const MeshMachine::TNodeActivity& aActivitySig, + MeshMachine::AMMNodeBase& aNode ); + /** + * Sends response to request originators. + */ + void ReplyToOriginators( Messages::TEErrorRecovery::TErrorRecoveryResponse& aCFMessageSig ); + + protected: + /** + * Context definition + */ + typedef MeshMachine::TNodeContext TContext; + + public: + /** + * STATE: Waits for reconnect activity to complete. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingReConnectComplete, + MeshMachine::TState, + NetStateMachine::MState, + TContext ) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingReConnectComplete ) + /** + * TTransitionBase from Symbian error recovery + */ + class TTransitionBase : public MeshMachine::TStateTransition + { + public: + TTransitionBase( TContext& aContext ) + : MeshMachine::TStateTransition(aContext) { /*EMPTY*/ } + virtual void Error(TInt aError); + }; + /** + * TRANSITION/ACTION: Stores error context. + */ + DECLARE_SMELEMENT_HEADER( TStoreErrorContext, + CS60ConnectionRecoveryActivity::TTransitionBase, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TStoreErrorContext ) + /** + * TRANSITION/ACTION: Sends RETRY as RecoveryResponse + */ + DECLARE_SMELEMENT_HEADER( TSendRetryRecoveryResponse, + CS60ConnectionRecoveryActivity::TTransitionBase, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendRetryRecoveryResponse ) + /** + * TRANSITION/ACTION: Sends PROPAGATE as RecoveryResponse + */ + + DECLARE_SMELEMENT_HEADER( TSendPropagateRecoveryResponse, + CS60ConnectionRecoveryActivity::TTransitionBase, + NetStateMachine::MStateTransition, + TContext) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendPropagateRecoveryResponse ) + + protected: + /** + * C++ constructor. + */ + CS60ConnectionRecoveryActivity( const MeshMachine::TNodeActivity& aActivitySig, + MeshMachine::AMMNodeBase& aNode ); + }; + + /** + * TRANSITION/ACTION: Sends IGNORE as RecoveryResponse + */ + DECLARE_SMELEMENT_HEADER( TSendIgnoreRecoveryResponse, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendIgnoreRecoveryResponse ) + + /** + * STATE: Wait for valid error recovery request. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingNotGoneDownErrorRecoveryRequest, + MeshMachine::TState, + NetStateMachine::MState, + TContext ) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingNotGoneDownErrorRecoveryRequest ) + + + /** + * FORK/DECISION: Decides between three different activity execution paths: + * 1. Continue to next transition. ( reselection of AP ) + * 2. Sendiong of IGNORE to originators. + * 3. Error handling. + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TNoTagOrIgnoreErrorOrErrorTag, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrIgnoreErrorOrErrorTag ) + + /** + * FORK/DECISION: Decides between three different activity execution paths: + * 1. Continue to next transition. ( selection of IAP ) + * 2. Retrying of currently bound MCPR + * 3. Error handling + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TNoTagOrRetryConnectionTagOrErrorTag, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrRetryConnectionTagOrErrorTag ) + + /** + * FORK/DECISION: Decides between two different activity execution paths: + * 1. Retrying of currently bound MCPR + * 2. Error handling through process error + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TRetryConnectionOrProcessErrorTagBackward, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TRetryConnectionOrProcessErrorTagBackward ) + + /** + * FORK/DECISION: Decides between two different activity execution paths: + * 1. Error handling through process error + * 2. Else continue + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TNoTagOrProcessErrorBackwardTag, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrProcessErrorBackwardTag ) + + } // namespace S60MCprErrorRecoveryActivity + +/** + * S60MCprMobilityActivity namespace packages the + * S60 MCPR's mobility activity related + * states, transitions and forks. + */ +namespace S60MCprMobilityActivity + { + /** + * Execution context definition for meshmachine activities. + */ + typedef MeshMachine::TNodeContext TContext; + + /** + * TRANSITION/ACTION: Does nothing or resends the earlier received notification. + */ + DECLARE_SMELEMENT_HEADER( TDoNothingOrReSendPendingNotification, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TDoNothingOrReSendPendingNotification ) + + /** + * TRANSITION/ACTION: Responds back to IPCPR that mobility session has been started. + */ + DECLARE_SMELEMENT_HEADER( TReplyMobilityStarted, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TReplyMobilityStarted ) + + /** + * TRANSITION/ACTION: Registers to preferred carrier notifications. + */ + DECLARE_SMELEMENT_HEADER( TSendAvailabilityRequest, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendAvailabilityRequest ) + + /** + * TRANSITION/ACTION: Application rejects active carrier. + */ + DECLARE_SMELEMENT_HEADER( TSendInitialApplicationReject, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendInitialApplicationReject ) + + /** + * STATE: Waits for TStartMobility message. + * @return ETrue if message is valid. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingStartMobility, + MeshMachine::TState, + NetStateMachine::MState, + TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingStartMobility ) + + /** + * STATE: Waits for TAwaitingMigrationRequestedOrRejectedOrCancel. + * @return ETrue if message is valid either of those or cancel. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingMigrationRequestedOrRejectedOrCancel, + MeshMachine::TState, + NetStateMachine::MState, + TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingMigrationRequestedOrRejectedOrCancel ) + + /** + * STATE: Watis for application response. + * @return ETrue if Migration Accepted or Rejected. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingMigrationAcceptedOrRejectedOrCancel, + MeshMachine::TState, + NetStateMachine::MState, + TContext ) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingMigrationAcceptedOrRejectedOrCancel ) + + /** + * FORK/DECISION: Returns the KStartMobilityHandshake backwards or error + * @return KStartMobilityHandshake backwards or error + */ + DECLARE_SMELEMENT_HEADER( TStartMobilityHandshakeBackwardsOrError, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TStartMobilityHandshakeBackwardsOrError ) + + /** + * FORK/DECISION: Decides if needs cancel or not. + */ + DECLARE_SMELEMENT_HEADER( TInformMigrationAvailableOrCancelTag, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TInformMigrationAvailableOrCancelTag ) + + /** + * FORK/DECISION: Decides what happens after IPCPR application completes the + * three way handshake. + * 1. Application accepted, continue to send accept to policy server. + * 2. Error + * 3. Application rejected, continue to send reject to policy server. + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TNoTagOrErrorTagOrApplicationRejected, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrErrorTagOrApplicationRejected ) + + /** + * FORK/DECISION: Decides whether to wait MPM actions or report an error. + * 1. Wait for further actions. ReSelect is NOT supported. + * 2. Error + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TWaitPolicyServerResponseBackwardOrErrorTag, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TWaitPolicyServerResponseBackwardOrErrorTag ) + + /** + * FORK/DECISION: + * 1. Continue with handshake to select new AP for MCPR. + * 2. Return back to migration-phase with new preferred IAP. + * 3. Close down the system in case of mobilityerror. + * @return //TODO Cancel from IPCPR. + */ + DECLARE_SMELEMENT_HEADER( TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel ) + + /** + * Class that is responsible for managing mobility on MCPR side. + * CS60MobilityActivity is the S60 version of the CMobilityActivity -class + */ + class CS60MobilityActivity : public S60MCprStates::CS60ErrorRecoveryActivity + { + public: + /** + * Symbian two-phase constructor + */ + static MeshMachine::CNodeActivityBase* NewL( const MeshMachine::TNodeActivity& aActivitySig, + MeshMachine::AMMNodeBase& aNode ); + + /** + * CS60MobilityActivity -context definition + */ + typedef MeshMachine::TNodeContext TContext; + + /** + * Inner mutex class. Takes care that mobility is not started while + * activity/node is doing something more important. + */ + class TConnectionRecoveryOrMobilityPreferenceOrErrorMutex + { + public: + /** + * @return ETrue if mobility activity can't run + */ + static TBool IsBlocked(MeshMachine::TNodeContextBase& aContext); + }; + + public: // Mesh Machine elements + + /** + * TRANSITION/ACTION: Sends migration rejected message + */ + DECLARE_SMELEMENT_HEADER( TSendMigrationRejected, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendMigrationRejected ) + + /** + * TRANSITION/ACTION: Sends migration rejected message + */ + DECLARE_SMELEMENT_HEADER( TSendMigrationAccepted, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendMigrationAccepted ) + + /** + * TRANSITION/ACTION: Clears the handshaking flag + */ + DECLARE_SMELEMENT_HEADER( TClearHandshakingFlag, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TClearHandshakingFlag ) + + // EMPTY + DECLARE_SMELEMENT_HEADER( TSendAvailabilityRequest, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendAvailabilityRequest ) + + /** + * TRANSITION/ACTION: Sends migration available notification to IPCPR. + */ + DECLARE_SMELEMENT_HEADER( TInformMigrationAvailableAndSetHandshakingFlag, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TInformMigrationAvailableAndSetHandshakingFlag ) + + // Symbian comment: For the moment it is sufficient to use the re-connect activity, in the future we may want to + // customise the behavior, for example start the new layer before rebinding it, etc. + // EMPTY + DECLARE_SMELEMENT_HEADER(TRequestReConnect, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER(TRequestReConnect) + + /** + * TRANSITION/ACTION: Informs IPCPR that MCPR has migrated. + */ + DECLARE_SMELEMENT_HEADER( TInformMigrationCompleted, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TInformMigrationCompleted ) + + /** + * TRANSITION/ACTION: Sends Application Accepted Connection + */ + DECLARE_SMELEMENT_HEADER( TSendApplicationAccept, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendApplicationAccept ) + + /** + * TRANSITION/ACTION: Sends Application Rejected Connection + */ + DECLARE_SMELEMENT_HEADER( TSendApplicationReject, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TSendApplicationReject ) + + /** + * TRANSITION/ACTION: Unregister preferred carrier notifications. + */ + DECLARE_SMELEMENT_HEADER( TCancelMobilityActivity, + MeshMachine::TStateTransition, + NetStateMachine::MStateTransition, + CS60MobilityActivity::TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TCancelMobilityActivity ) + + /** + * STATE: Waits for response to the MigrationAccepted message. + * @return ETrue if new PreferredCarrier arrives, new StartIAPNotification arrives or error arrives. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel, + MeshMachine::TState, + NetStateMachine::MState, + CS60MobilityActivity::TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel ) + + /** + * STATE: Waits for preferred carrier message. + * @return ETrue if preferred carrier notification is received. + */ + DECLARE_SMELEMENT_HEADER( TAwaitingPreferredCarrierOrCancelOrRejected, + MeshMachine::TState, + NetStateMachine::MState, + CS60MobilityActivity::TContext) + virtual TBool Accept(); + DECLARE_SMELEMENT_FOOTER( TAwaitingPreferredCarrierOrCancelOrRejected ) + + /** + * FORK/DECISION: Decides what happens after IPCPR responds to migration offer. + * 1. Proceed to migration if asked. + * 2. Proceed to cancel. + * 3. Go back to wait for new preferred connection. + * @return TransitionTag of the selected transition. + */ + DECLARE_SMELEMENT_HEADER( TNoTagOrApplicationRejectedMigrationOrCancel, + MeshMachine::TStateFork, + NetStateMachine::MStateFork, + CS60MobilityActivity::TContext ) + virtual TInt TransitionTag(); + DECLARE_SMELEMENT_FOOTER( TNoTagOrApplicationRejectedMigrationOrCancel ) + + /** + * Mutex protected TRANSITION. + * Mopility scenario should wait until the connection recovery finishes. + */ + DECLARE_SERIALIZABLE_TRANSITION( TInformMigrationAvailableAndSetHandshakingFlagBlockedByConnectionRecoveryOrNoMobilityPreferenceOrError, + CS60MobilityActivity::TConnectionRecoveryOrMobilityPreferenceOrErrorMutex, + CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlag ) + + protected: // Methods. + + /** + * C++ constructor + */ + CS60MobilityActivity( const MeshMachine::TNodeActivity& aActivitySig, + MeshMachine::AMMNodeBase& aNode ); + + //TBool Signal( MeshMachine::TNodeContextBase& aContext ); + + private: // Private methods. + + /** + * Sets on MCPR wide mobility handshaking flag. + */ + void SetHandshakingFlag(); + + /** + * Clears MCPR wide mobility handshaking flag. + */ + void ClearHandshakingFlag(); + + private: // Member variables. + + /** + * Pointer to IPProtocoMCPR which is currently active + */ + ESock::RMetaServiceProviderInterface* iCurrent; + + /** + * Pointer to IPProtocoMCPR which is about to become the active. + */ + ESock::RMetaServiceProviderInterface* iPreferred; + + TUint iCurrentAssumedAPId; // Current IAP Id + TUint iPreferredAPId; // New IAP Id system should roam to. + TBool iIsUpgrade; // If the active iPreferredAPId is upgrade to old one. + TBool iIsSeamless; // *not used* if the roaming is seamless from the IP point of view + + }; + + DECLARE_SMELEMENT_HEADER( TProcessSimpleSelectionPolicy, MeshMachine::TStateTransition, NetStateMachine::MStateTransition, TContext ) + virtual void DoL(); + DECLARE_SMELEMENT_FOOTER( TProcessSimpleSelectionPolicy ) + + } // namespace S60MCprMobilityActivity + +#endif // S60MCPR_ACTIVITIES_H +