/*

* 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 <comms-infras/mobilitymcpractivities.h>

#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<CS60MetaConnectionProvider, MobilityMCprStates::TContext> TContext;

    /**

     * STATE: Waits for valid select message.

     * @return ETrue if message is accepted.

     */

    DECLARE_SMELEMENT_HEADER( TAwaitingSelectNextLayer, 

                              MeshMachine::TState<TContext>, 

                              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<TContext>, 

                              NetStateMachine::MStateTransition, 

                              TContext )

    virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSelectNextLayer )

    /**

     * TRANSITION/ACTION: Requests PolicyServer for Best IAP.  

     */

    DECLARE_SMELEMENT_HEADER( TSimpleSelect, 

                              MeshMachine::TStateTransition<TContext>, 

                              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<TContext>, 

                              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<CS60MetaConnectionProvider, MobilityMCprStates::TContext> TContext;

    /**

     * STATE: Waits for valid select message.

     * @return ETrue if message is accepted.

     */

    DECLARE_SMELEMENT_HEADER( TAwaitingSelectNextLayer, 

                              MeshMachine::TState<TContext>, 

                              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<TContext>, 

                              NetStateMachine::MStateTransition, 

                              TContext )

    virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSelectNextLayer )

    /**

     * TRANSITION/ACTION: Requests PolicyServer for Best IAP.  

     */

    DECLARE_SMELEMENT_HEADER( TChooseBestIAP, 

                              MeshMachine::TStateTransition<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              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<CS60MetaConnectionProvider, MCprStates::TContext> 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<S60MCprStates::KProcessError> )

    /**

     * 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<CMobilityMetaConnectionProvider, MCprStates::TContext> TContext;

        public:

            /**

             * STATE: Waits for reconnect activity to complete.

             */

            DECLARE_SMELEMENT_HEADER( TAwaitingReConnectComplete, 

                                      MeshMachine::TState<TContext>, 

                                      NetStateMachine::MState, 

                                      TContext )

            virtual TBool Accept();

            DECLARE_SMELEMENT_FOOTER( TAwaitingReConnectComplete )

            /**

             * TTransitionBase from Symbian error recovery

             */

            class TTransitionBase : public MeshMachine::TStateTransition<TContext>

                {

                public:

                    TTransitionBase( TContext& aContext )

                    :   MeshMachine::TStateTransition<TContext>(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<TContext>, 

                              NetStateMachine::MStateTransition, 

                              TContext )

    virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSendIgnoreRecoveryResponse )

    /**

     * STATE: Wait for valid error recovery request.

     */

    DECLARE_SMELEMENT_HEADER( TAwaitingNotGoneDownErrorRecoveryRequest, 

                              MeshMachine::TState<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              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<CS60MetaConnectionProvider, MCprStates::TContext> TContext;

    /**

     * TRANSITION/ACTION: Does nothing or resends the earlier received notification.

     */

    DECLARE_SMELEMENT_HEADER( TDoNothingOrReSendPendingNotification, 

                              MeshMachine::TStateTransition<TContext>, 

                              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<TContext>, 

                              NetStateMachine::MStateTransition, 

                              TContext )

    virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TReplyMobilityStarted )

    /**

     * TRANSITION/ACTION: Registers to preferred carrier notifications.

     */

    DECLARE_SMELEMENT_HEADER( TSendAvailabilityRequest, 

                              MeshMachine::TStateTransition<TContext>, 

                              NetStateMachine::MStateTransition, 

                              TContext )

    virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSendAvailabilityRequest )

    /**

     * TRANSITION/ACTION: Application rejects active carrier.

     */

    DECLARE_SMELEMENT_HEADER( TSendInitialApplicationReject, 

                              MeshMachine::TStateTransition<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              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<TContext>, 

                              NetStateMachine::MState, 

                              TContext )

    virtual TBool Accept();