// Copyright (c) 2006-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:

// Core PR Activities

//

//

/**

 @file

 @internalComponent

*/

#ifndef SYMBIAN_SS_COREPRACTIVITIES_H

#define SYMBIAN_SS_COREPRACTIVITIES_H

#include <comms-infras/ss_coreprstates.h>

#include <comms-infras/ss_mmnode.h>

#include <comms-infras/ss_nodemessages_internal.h>

#include <comms-infras/ss_nodemessages_legacy.h>

#include <elements/mm_states.h>

#include <comms-infras/ss_parameterfamilybundle.h>

#include <elements/nm_messages_internal.h>

namespace CoreErrorActivity

{ //If found in node activity map is ran by the MM whenewer an error is received

  //and not processed by its target activity

	DECLARE_EXPORT_NODEACTIVITY(CoreError)

}

namespace PRControlClientJoinActivity

{ //This activity needs the activity object (& it can fail on AddClientL)

	DECLARE_EXPORT_NODEACTIVITY(PRControlClientJoin)

}

namespace PRDataClientJoinActivity

{ //This activity needs the activity object (& it can fail on AddClientL)

	DECLARE_EXPORT_NODEACTIVITY(PRDataClientJoin)

}

namespace PRClientLeaveActivity

{ //This activity does not need the activity object

	DECLARE_EXPORT_NODEACTIVITY(PRClientLeave)

}

namespace PRDataClientIdleActivity

{ //TAwaitingDataClientIdle will only accept if no more clients joined to the node

	static const TInt KDataClientNotStarted = 1;		// idle data client is not started

	DECLARE_EXPORT_NODEACTIVITY(PRDataClientIdle)

}

namespace PRDataClientActiveActivity

{ //TAwaitingDataClientIdle will only accept if no more clients joined to the node

	static const TInt KDataClientNotStarted = 1;		// idle data client is not started

	DECLARE_EXPORT_NODEACTIVITY(PRDataClientActive)

}

namespace PRSetParamsRequest

{

DECLARE_EXPORT_NODEACTIVITY(PRSetParams)

}

namespace PRGetParamsRequest

{

DECLARE_EXPORT_NODEACTIVITY(PRGetParams)

}

namespace PRDataClientStopActivity

{

typedef MeshMachine::TNodeContext<ESock::CMMCommsProviderBase, CoreNetStates::TContext> TContext;

EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrProviderStopped, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

IMPORT_C virtual TInt TransitionTag();

DECLARE_SMELEMENT_FOOTER( TNoTagOrProviderStopped )

DECLARE_SERIALIZABLE_STATE(

	TNoTagOrProviderStoppedBlockedByStart,

	CoreNetStates::TActivityStartMutex,

	TNoTagOrProviderStopped

	)

}

namespace CoreActivities

{

//-=========================================================

//

//Error Recovery Activity

//

//-=========================================================

class CErrorActivity : public MeshMachine::CNodeParallelActivityBase

	{

public:

    static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

	virtual ~CErrorActivity();

protected:

	CErrorActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aActivitiesCount);

    virtual TBool IsIdle() const;

	virtual TBool Next(MeshMachine::TNodeContextBase& aContext);

	virtual void StartL(MeshMachine::TNodeContextBase& aContext, const Messages::XNodePeerId& aOriginator, const NetStateMachine::TStateTriple& aFirst);

protected:

    //save original error values

    Messages::TNodeSignal::TMessageId iMessageId;

	// We cannot simply store a pointer to the activity here, as the activity may

	// go away, and then any access to it would cause a KERN-EXEC: 3. So store the

	// id of the activity, and then when we want a pointer to the activity, call

	// FindActivityById on the node.

	TInt iErroredActivityId;

protected:

    typedef CoreStates::TContext TContext;

public:

	EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingError, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

		IMPORT_C virtual TBool Accept();

	DECLARE_SMELEMENT_FOOTER( TAwaitingError )

	DECLARE_SMELEMENT_HEADER( TCFAwaitingError, CoreActivities::CErrorActivity::TAwaitingError, NetStateMachine::MState, TContext )

		IMPORT_C virtual TBool Accept();

	DECLARE_SMELEMENT_FOOTER( TCFAwaitingError )

	EXPORT_DECLARE_SMELEMENT_HEADER( TSendErrorRecoveryReq, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

		IMPORT_C virtual void DoL();

	DECLARE_SMELEMENT_FOOTER( TSendErrorRecoveryReq )

	EXPORT_DECLARE_SMELEMENT_HEADER( TDoErrorRecovery, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

		IMPORT_C virtual void DoL();

	DECLARE_SMELEMENT_FOOTER( TDoErrorRecovery )

public:

    friend class TSendErrorRecoveryReq;

    friend class TDoErrorRecovery;

	};

//-=========================================================

//

//Destroy Activity - will delete the node when destructed

//

//-=========================================================

class CDestroyActivity : public MeshMachine::CNodeRetryActivity, protected MeshMachine::APreallocatedOriginators<1>

/*

Overlooks destruction of a mesh machine based node. Destruction is triggered either

by the (only) control provider or by the last client leaving (in the lack of the

control provider - mcprs). This logic guarantees there only is one CDestroyActivity

(against a node) at a time. CDestroyActivity is also an infallible activity hence

its execution (including all the allocations) must not fail. This is achieved by:

(1) CDestroyActivity constructs itself over the space preallocated

    by MeshMachine::AMMNodeBase::ConstructL(), see CDestroyActivity::New()

(2) CDestroyActivity preallocating the space for the only originator

    (see logic description above), see CDestroyActivity::iOriginator.

*/

	{

public:

    IMPORT_C static MeshMachine::CNodeActivityBase* New(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

protected:

	CDestroyActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

	virtual void Destroy();

//States, StateForks & StateTransitions

protected:

	typedef CoreStates::TContext TContext;

public:

	EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrNoTagBackwards, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

		IMPORT_C virtual TInt TransitionTag();

	DECLARE_SMELEMENT_FOOTER( TNoTagOrNoTagBackwards )

    EXPORT_DECLARE_SMELEMENT_HEADER( TMakeClientsLeaveOrProcessClientLeave, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

        void MakeClientsLeaveL();

        void ProcessClientLeaveL();

    	IMPORT_C virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TMakeClientsLeaveOrProcessClientLeave )

    DECLARE_AGGREGATED_TRANSITION2(

		TProcessClientLeave,

		MeshMachine::TRemoveClient,

		CoreNetStates::TSendLeaveCompleteIfRequest

		)

	typedef MeshMachine::TActivitiesIdMutex<ESock::ECFActivityStop, ESock::ECFActivityStopDataClient, ESock::ECFActivityDataClientGoneDown, ESock::ECFActivityGoneDown> TAllStopActivityMutex;

	typedef MeshMachine::TActivityIdMutex<ESock::ECFActivityClientLeave> TClientLeaveMutex;

    typedef MeshMachine::TClientMutex<Messages::TDefaultClientMatchPolicy, ESock::TCFClientType::EData, ESock::TCFClientType::ELeaving> TLeavingDataClientMutex;

	typedef MeshMachine::TAggregatedMutex_OR<TAllStopActivityMutex, TLeavingDataClientMutex> TAllStopActivityOrLeavingDataClientMutex;

	typedef MeshMachine::TAggregatedMutex_OR<TAllStopActivityOrLeavingDataClientMutex, TClientLeaveMutex> TAllStopActivityOrLeavingDataClientOrClientLeaveMutex;

    DECLARE_SERIALIZABLE_STATE(

    	TNoTagBlockedByActivitiesOrLeavingDataClient,

    	TAllStopActivityOrLeavingDataClientOrClientLeaveMutex,

    	MeshMachine::TNoTag

    	)

private:

	/*

	Private NewL with no implementation to hide the CNodeActivityBase::NewL

	Creation of preallocated activities doesn't fail and hence a non-leaving ::New should be used instead*/

    static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

	};

//-=========================================================

//

//Looping Activity

//

//-=========================================================

class ACountLoopActivity

/*

*/

	{

public:

    static const TInt KInterfaceId = 0x102864D9;

public:

	void SetCount(TInt aCount)

		{

		iCount = aCount;

		}

	TInt DecCount()

		{

		return --iCount;

		}

protected:

	ACountLoopActivity()

	:	iCount(0)

		{

		}

	IMPORT_C virtual ~ACountLoopActivity();

protected:

    TInt iCount;

protected:

    typedef CoreStates::TContext TContext;

public:

    EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrNoTagBackwards, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

    	IMPORT_C virtual TInt TransitionTag();

    DECLARE_SMELEMENT_FOOTER( TNoTagOrNoTagBackwards )

	};

class CCountLoopActivityBase : public MeshMachine::CNodeActivityBase, CoreActivities::ACountLoopActivity,

                               public ITFHIERARCHY_1(CCountLoopActivityBase, ACountLoopActivity)

/*

*/

	{

public:

	typedef ITFHIERARCHY_1(CCountLoopActivityBase, ACountLoopActivity) TIfStaticFetcherNearestInHierarchy;

public:

    IMPORT_C static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

	IMPORT_C virtual ~CCountLoopActivityBase();

    void ReturnInterfacePtrL(CoreActivities::ACountLoopActivity*& aInterface)

        {

        aInterface = this;

        }

protected:

	IMPORT_C CCountLoopActivityBase(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

	};

//-=========================================================

//

//Binding Activity

//

//-=========================================================

class ABindingActivity

/*

The interface must be implemented by activities featuring (using) PRStates::TSendBindToComplete.

ABindingActivity can store the activityId and the originator expecting intermediate

TBindToComplete. The originator might have sent either a TBindTo or TCommsBinderResponse.

*/

	{

public:

    static const TInt KInterfaceId = 0x102864DD;

    IMPORT_C void StoreOriginator(const Messages::TRuntimeCtxId& aNodeCtxId);

    //Will diagnostically panic if replying when !IsBinding()

    IMPORT_C void ReplyToOriginator(TInt aError = KErrNone);

    inline TBool IsBinding()

    	{

    	return !iOriginator.IsNull();

    	}

protected:

	ABindingActivity(const Messages::TNodeId& aOurNode)

	:	iOurNode(aOurNode)

		{

		}

	void FinalReplyToOriginator(TInt aError);

	IMPORT_C virtual ~ABindingActivity();

protected:

    Messages::TNodeCtxId iOriginator;

    Messages::TNodeId iOurNode;

protected:

    typedef CoreStates::TContext TContext;

public:

    EXPORT_DECLARE_SMELEMENT_HEADER( TSendBindToComplete, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	IMPORT_C virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSendBindToComplete )

    EXPORT_DECLARE_SMELEMENT_HEADER( TSendBindToCompleteIfExpected, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	IMPORT_C virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSendBindToCompleteIfExpected )

    DECLARE_AGGREGATED_TRANSITION2(

        TSendBindToCompleteAndRequestCommsBinder,

        TSendBindToComplete,

        CoreNetStates::TRequestCommsBinder

        )

	};

} //namespace CoreActivities

namespace PRActivities

{

	//Activity Map provided by CorePr to be used by SCprs.

	//(it is further extended in CoreSCpr).

	DECLARE_EXPORT_ACTIVITY_MAP(coreActivitiesSCpr)

	//Activity Map provided by CorePr to be used by Cprs.

	//(it is further extended in CoreCpr).

	DECLARE_EXPORT_ACTIVITY_MAP(coreActivitiesCpr)

	//Activity Map provided by CorePr to be used by MCprs.

	//(it is further extended in CoreMCpr).

	DECLARE_EXPORT_ACTIVITY_MAP(coreActivitiesMCpr)

	//Activity Map provided by CorePr to be used by TMs.

	//(it is further extended in CoreTM).

	DECLARE_EXPORT_ACTIVITY_MAP(coreActivitiesTM)

//-=========================================================

//

//CBindToActivity

//

//-=========================================================

class CBindToActivity : public MeshMachine::CNodeParallelActivityBase, CoreActivities::ABindingActivity,

                               public ITFHIERARCHY_1(CBindToActivity, CoreActivities::ABindingActivity)

/*

A readymade BindToRequest activity class implementing ABindingActivity (see ABindingActivity).

*/

	{

public:

	typedef ITFHIERARCHY_1(CBindToActivity, CoreActivities::ABindingActivity) TIfStaticFetcherNearestInHierarchy;

private:

	enum

		{

		EAutocommit = 0x01,

		EDontLeaveServiceProvider = 0x02,

		};

public:

    IMPORT_C static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

    IMPORT_C virtual ~CBindToActivity();

    void ReturnInterfacePtrL(CoreActivities::ABindingActivity*& aInterface)

        {

        aInterface = this;

        }

    Messages::RNodeInterface* NextDataClient();

    Messages::RNodeInterface* CurrentDataClient()

		{

		return iCurrentDataClient;

		}

    void ResetCurrentDataClient()

       	{

      	iCurrentDataClient = NULL;

       	}

    TBool IsAutocommit()

    	{

    	return (iFlags & EAutocommit);

    	}

    TBool DataClientsAutocommit();

    void SetAutocommit(TBool aValue)

    	{

    	iFlags = aValue ? (iFlags | EAutocommit) : (iFlags & ~EAutocommit);

    	}

    void SetDontLeaveServiceProvider()

    	{

    	iFlags = iFlags | EDontLeaveServiceProvider;

    	}

    TBool ShouldLeaveServiceProvider()

    	{

    	return !(iFlags & EDontLeaveServiceProvider);

    	}

    void AddClientAsSuccessfulL(Messages::RNodeInterface* aDataClient);

    void RemoveClientFromSuccessful(Messages::RNodeInterface* aDataClient);

protected:

	IMPORT_C CBindToActivity(const MeshMachine::TNodeActivity& aActivitySig,  MeshMachine::AMMNodeBase& aNode, TInt aNextActivityCount);

protected:

	Messages::RNodeInterface* iNewServiceProvider;

private:

	Messages::RNodeInterface* iCurrentDataClient;

	RPointerArray<Messages::RNodeInterface> iSuccessfulDataClients;

	TInt iFlags;

protected:

    typedef MeshMachine::TNodeContext<ESock::CMMCommsProviderBase, CoreNetStates::TContext> TContext;

public:

    EXPORT_DECLARE_SMELEMENT_HEADER( TSendControlClientJoinRequest, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSendControlClientJoinRequest )

    EXPORT_DECLARE_SMELEMENT_HEADER( TCommit, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TCommit )

    EXPORT_DECLARE_SMELEMENT_HEADER( TCancel, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TCancel )

    EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrDataClientReady, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

    	virtual TInt TransitionTag();

    DECLARE_SMELEMENT_FOOTER( TNoTagOrDataClientReady )

    EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingBindToCompleteOrError, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )

    	virtual TBool Accept();

    DECLARE_SMELEMENT_FOOTER( TAwaitingBindToCompleteOrError )

    EXPORT_DECLARE_SMELEMENT_HEADER( TCreateDataClient, PRStates::TCreateDataClient, NetStateMachine::MStateTransition, TContext )

    	virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TCreateDataClient )

    EXPORT_DECLARE_SMELEMENT_HEADER( TSendBindTo, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSendBindTo )

    EXPORT_DECLARE_SMELEMENT_HEADER( TSendBindToComplete, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TSendBindToComplete )

    EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrBindToComplete, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

    	IMPORT_C virtual TInt TransitionTag();

    DECLARE_SMELEMENT_FOOTER( TNoTagOrBindToComplete )

    EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrCommit, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

    	virtual TInt TransitionTag();

    DECLARE_SMELEMENT_FOOTER( TNoTagOrCommit )

    EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrBearerReady, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

    	virtual TInt TransitionTag();

    DECLARE_SMELEMENT_FOOTER( TNoTagOrBearerReady )

    EXPORT_DECLARE_SMELEMENT_HEADER( TNoTagOrBearerReadyOrBindToComplete, MeshMachine::TStateFork<TContext>, NetStateMachine::MStateFork, TContext )

    	virtual TInt TransitionTag();

    DECLARE_SMELEMENT_FOOTER( TNoTagOrBearerReadyOrBindToComplete )

    EXPORT_DECLARE_SMELEMENT_HEADER( TRequestCommsBinder, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )

    	virtual void DoL();

    DECLARE_SMELEMENT_FOOTER( TRequestCommsBinder )

	};

//-=========================================================

//

//Rejoin DataClient Activity

//

//-=========================================================

class CRejoinDataClientActivity : public MeshMachine::CNodeRetryParallelActivity

	{

/*

Used when migrating nodes from one control provider to another. The activity is

designed to run on the current owner of a group of migrated dataclients.

The activity can cache that group, overlook the migration and control error handling.

The activity comes with a set of states and transitions that use the features

provided by the activity class.

*/

public:

    IMPORT_C static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);

	virtual ~CRejoinDataClientActivity();

protected:

	CRejoinDataClientActivity(const MeshMachine::TNodeActivity& aActivitySig, TUint aNextActivityCount, MeshMachine::AMMNodeBase& aNode )

	    :MeshMachine::CNodeRetryParallelActivity(aActivitySig, aNode, aNextActivityCount)

		{

		}

public:

    struct TMigrationPairs

        {