// 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:

// COREPRACTIVITIES.CPP

// Core PR Activities

// THIS API IS INTERNAL TO NETWORKING AND IS SUBJECT TO CHANGE AND NOT FOR EXTERNAL USE

//

//

/**

 @file

 @internalComponent

*/

#define SYMBIAN_NETWORKING_UPS

#include "ss_corepractivities.h"

#include <comms-infras/ss_log.h>

#include "ss_internal_activities.h"

#include <comms-infras/ss_coreprstates.h>

#include <comms-infras/ss_subconnprov.h>

#include <comms-infras/ss_mcprnodemessages.h>

#include <comms-infras/ss_protocolparameterset.h>

#include <ss_glob.h>

#include <elements/nm_messages_child.h>

#include <elements/nm_messages_peer.h>

#include <elements/nm_messages_errorrecovery.h>

#include "ss_nodemessages_dataclient.h"

#include "ss_nodemessages_serviceprovider.h"

#include <comms-infras/ss_nodemessages_rejoiningprovider.h>

#include <comms-infras/ss_nodemessages_flow.h>

#include "ss_nodemessages_factory.h"

#include <comms-infras/ss_nodemessages_internal_esock.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockCrStaCPRAC, "ESockCrStaCPRAC");

#endif

#if defined __CFLOG_ACTIVE || defined ESOCK_EXTLOG_ACTIVE

	#define KCoreProviderStatesTag KESockCoreProviderTag

	_LIT8(KCoreProviderStatesSubTag, "coreprovstate");

#endif

using namespace NetStateMachine;

using namespace CoreStates;

using namespace CoreNetStates;

using namespace PRStates;

using namespace PRActivities;

using namespace CoreActivities;

using namespace ESock;

using namespace CorePanics;

using namespace Elements;

using namespace Messages;

using namespace MeshMachine;

using namespace Factories;

#ifdef _DEBUG

_LIT (KCorePrPanic,"CorePrPanic");

#endif

namespace CoreErrorActivity

{ //Special parallel activity, must be started as the last one

DEFINE_EXPORT_CUSTOM_NODEACTIVITY(ECFActivityError, CoreError, TEBase::TError, CErrorActivity::NewL)

	FIRST_NODEACTIVITY_ENTRY(CErrorActivity::TCFAwaitingError, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, CErrorActivity::TSendErrorRecoveryReq, MeshMachine::TAwaitingMessageState<TEErrorRecovery::TErrorRecoveryResponse>, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CErrorActivity::TDoErrorRecovery)

NODEACTIVITY_END()

}

namespace PRProvisionActivity

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityStoreProvision, PrProvision, TCFDataClient::TProvisionConfig)

	NODEACTIVITY_ENTRY(KNoTag, PRStates::TStoreProvision, CoreNetStates::TAwaitingProvision, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRControlClientJoinActivity

{

DEFINE_EXPORT_NODEACTIVITY(ECFActivityClientJoin, PRControlClientJoin, TNodeSignal::TNullMessageId) //May be waiting for both messages

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TAddControlClientAndSendJoinCompleteIfRequest, CoreNetStates::TAwaitingControlClientJoin, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRDataClientJoinActivity

{ //This activity needs the activity object (& it can fail on AddClientL, so no point converting)

DEFINE_EXPORT_NODEACTIVITY(ECFActivityDataClientJoin, PRDataClientJoin, TCFPeer::TJoinRequest)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientJoinRequest, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TAddDataClientAndRespond)

NODEACTIVITY_END()

}

namespace PRDestroyOrphansActivity

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityDestroyOrphans, PRDestroyOrphans, TCFMessage::TDestroyOrphans, CoreActivities::CDestroyOrphansActivity::New)

    // Destroy non-Default Data clients first (as there can be references from non-Default Data clients to the Default Data client)

    FIRST_NODEACTIVITY_ENTRY(MeshMachine::TAwaitingMessageState<TCFMessage::TDestroyOrphans>, PRStates::TOrphansOrNoTag)

    NODEACTIVITY_ENTRY(KOrphans, PRStates::TDestroyFirstOrphan, MeshMachine::TAwaitingMessageState<Messages::TEChild::TLeft>, MeshMachine::TTag<KContinue>)

    THROUGH_NODEACTIVITY_ENTRY(KContinue, PRStates::TProcessClientLeft, PRStates::TOrphansBackwardsOrNoTag)

    ROUTING_NODEACTIVITY_ENTRY(KNoTag, CDestroyOrphansActivity::TNoTagOrNoClients)

    LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)

    // At this point, there are no Data or Control clients, so leave the Service Providers (if any) and destroy the node.

    // (Can we just modify the above tuples so that they do not accept the very last TLeft, and thus leave it

    // to MCPrDestroyActivity or PRClientLeftActivity to accept and do the destruction for us?).

    // If Control Provider is present, send a TIdle message.

    THROUGH_NODEACTIVITY_ENTRY(KNoClients, CoreNetStates::TSendDataClientIdle, TNoTag)

    // If Control Provider is present, terminate the activity (KNoTag), as

    // Control Provider will send us a TDestroy in response to the TIdle message. 

    ROUTING_NODEACTIVITY_ENTRY(KNoTag, CDestroyOrphansActivity::TControlProviderNoTagOrNoClients)

    LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)

    // No Control Provider - leave Service Providers (if any) and destroy the node.

    ROUTING_NODEACTIVITY_ENTRY(KNoClients, CoreNetStates::TNoTagOrNoBearer)

    THROUGH_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingRequestToServiceProviders, TNoTag)

    NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, MeshMachine::TAwaitingLeaveComplete, CDestroyOrphansActivity::TNoTagOrNoTagBackwards)

    ROUTING_NODEACTIVITY_ENTRY(KNoBearer, TNoTag)

    LAST_NODEACTIVITY_ENTRY(KNoTag, CDestroyOrphansActivity::TMarkNodeForDestruction)

    // Node will be destroyed in CDestroyOrphansActivity::Destroy() 

NODEACTIVITY_END()

}

namespace PRClientLeaveActivity

{//This activity will wait for ECFActivityBinderRequest to complete

DEFINE_EXPORT_NODEACTIVITY(ECFActivityClientLeave, PRClientLeave, Messages::TEPeer::TLeaveRequest) 

    NODEACTIVITY_ENTRY(KNoTag, PRStates::TProcessClientLeave, MeshMachine::TAwaitingMessageState<TEPeer::TLeaveRequest>, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRClientLeftActivity

{

//This activity waits for TLeft which is a response to destroy, shouldn't really be needed

DEFINE_EXPORT_NODEACTIVITY(ECFActivityClientLeft, PRClientLeft, Messages::TEChild::TLeft)

    NODEACTIVITY_ENTRY(KNoTag, PRStates::TProcessClientLeft, MeshMachine::TAwaitingMessageState<Messages::TEChild::TLeft>, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRDataClientIdleActivity

{

DEFINE_EXPORT_NODEACTIVITY(ECFActivityDataClientIdle, PRDataClientIdle, TCFControlProvider::TIdle)

    NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::THandleDataClientIdle, CoreNetStates::TAwaitingDataClientIdle, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRDataClientActiveActivity

{

DEFINE_EXPORT_NODEACTIVITY(ECFActivityDataClientActive, PRDataClientActive, TCFControlProvider::TActive)

	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, CoreNetStates::TAwaitingDataClientActive, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRDestroyActivity

{

//The generic Destroy activity. Carries out the node's goodbye handshake.

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityDestroy, PRDestroy, TEChild::TDestroy, CoreActivities::CDestroyActivity::New)

	FIRST_NODEACTIVITY_ENTRY(MeshMachine::TAwaitingDestroy, CoreActivities::CDestroyActivity::TNoTagBlockedByActivitiesOrLeavingDataClient)

    ROUTING_NODEACTIVITY_ENTRY(KNoTag, PRStates::TNonLeavingNoTagOrNoClients)

    NODEACTIVITY_ENTRY(KNoTag, PRStates::TDestroyFirstClient, MeshMachine::TAwaitingMessageState<Messages::TEChild::TLeft>, MeshMachine::TTag<KContinue>)

    THROUGH_NODEACTIVITY_ENTRY(KContinue, PRStates::TProcessClientLeft, PRStates::TNoTagBackwardsOrNoClients)

 	THROUGH_NODEACTIVITY_ENTRY(KNoClients, PRStates::TProcessDestroy, MeshMachine::TNoTag)

 	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, MeshMachine::TAwaitingLeaveComplete, CoreActivities::CDestroyActivity::TNoTagOrNoTagBackwards)

 	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingAndRemoveControlProvider)

NODEACTIVITY_END()

}

namespace PRSetParamsRequest

{

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRSetParams, TCFScpr::TSetParamsRequest)

	FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingParamRequest, CoreNetStates::TNoTagOrBearerPresent)

	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, PRStates::TPassToServiceProvider, CoreNetStates::TAwaitingParamResponse, MeshMachine::TTag<CoreNetStates::KBearerPresent>)

	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, PRStates::TStoreParamsAndPostToOriginators)

	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TStoreAndRespondWithCurrentParams)

NODEACTIVITY_END()

#else

DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRSetParams, TNodeSignal::TNullMessageId)

NODEACTIVITY_END()

#endif

}

// no Store in case of GetParamsRequest

namespace PRGetParamsRequest

{

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRGetParams, TCFScpr::TGetParamsRequest)

	FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingParamRequest, CoreNetStates::TNoTagOrBearerPresent)

	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, PRStates::TPassToServiceProvider, CoreNetStates::TAwaitingParamResponse, MeshMachine::TTag<CoreNetStates::KBearerPresent>)

	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, CoreStates::TPostToOriginators)

	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TRespondWithRetrievedParams)

NODEACTIVITY_END()

#else

DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRGetParams, TNodeSignal::TNullMessageId)

NODEACTIVITY_END()

#endif

}

namespace PRBindToActivity

{

//PRBindToActivity is responsible for handling TCFDataClient::TBindTo;

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityBindTo, PRBindTo, TCFDataClient::TBindTo, CBindToActivity::NewL)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingBindTo, CBindToActivity::TNoTagOrBearerReady)

    //TBindTo can hold:

    //[KNoTag] 		 - a valid serviceProvider cookie that this node isn't bound to;

    //[KBearerReady] - a valid serviceProvider cookie that this node is already bound to;

    //[KBearerReady] - a NULL serviceProvider (this node is at the stack's bottom);

	  //{ JOINING NEW SERVICE PROVIDER

		//a valid serviceProvider supplied, new to this node, let's join it;

	    NODEACTIVITY_ENTRY(KNoTag, CBindToActivity::TSendControlClientJoinRequest, CoreStates::TAwaitingJoinComplete, TTag<KBearerReady>)

	  //}

	//serviceProvider provisionally joined. Now the activity needs to propagate iteslf (TBindTo) to its dataclients.

	//The dataclients are either present or not. If not this activity will assume this is the layer construction phase

	//and will attempt to construct a default dataclient.

	THROUGH_NODEACTIVITY_ENTRY(KBearerReady, MeshMachine::TDoNothing, CBindToActivity::TNoTagOrDataClientReady)

	  //{ DATA CLIENT CREATION

		//No dataclients present, assume this is the layer creation phase. Attempt to create a dataclient.

		NODEACTIVITY_ENTRY(KNoTag, CBindToActivity::TCreateDataClient, TAcceptErrorState<CoreNetStates::TAwaitingDataClientJoin>, MeshMachine::TErrorTagOr<CBindToActivity::TNoTagOrBindToComplete>)

	    //BindTo activity is the pre-start layer builder, hence it always requests the dataclient from the factory.

	    //The factory (being aware of the phase) may decide to:

	    //1. create a new dataclient          -> process dataclient creation            [KNoTag]

	    //2. return a preexisting dataclient  -> bind the client                        [KDataClientReady]

	    //3. not to create a dataclient       -> send TBindToComplete to the originator [KBindToComplete]

		THROUGH_NODEACTIVITY_ENTRY(KNoTag, PRStates::TProcessDataClientCreation, TTag<KDataClientReady>)

	  //}

    THROUGH_NODEACTIVITY_ENTRY(KDataClientReady, MeshMachine::TDoNothing, CBindToActivity::TNoTagOrBearerReadyOrBindToComplete)

      //{ BINDING DATACLIENTS LOOP

	    //Dataclient(s) is/are ready. Depending on whether the node has the lower layer or not,

	    //we will [KNoTag] or will not [KNoBearer] need to request a binder for the dataclient.

		  //{SERVICE PROVIDER PRESENT

			NODEACTIVITY_ENTRY(KNoTag, CBindToActivity::TRequestCommsBinder, TAcceptErrorState<CoreNetStates::TAwaitingBinderResponse>, TErrorTagOr<TTag<KBearerReady> >)

	      //}

		NODEACTIVITY_ENTRY(KBearerReady, PRActivities::CBindToActivity::TSendBindTo, CBindToActivity::TAwaitingBindToCompleteOrError,

																					 TErrorTagOr<TTag<KDataClientReady | NetStateMachine::EBackward> >)

	  //}

	//Binding is finished. If this is not autocommit (see TCFDataClient::TBindTo), the activity will reply TCFDataClient::TBindToComplete

	//to the sender await for the confirmation (TCFDataClient::TCommitBindTo) or cancelation (TBase::TCancel) from the sender.

	//If this is autommit, the activity will skip awaiting for TCFDataClient::TCommitBindTo and commit itself.

	THROUGH_NODEACTIVITY_ENTRY(KBindToComplete, CBindToActivity::TSendBindToComplete, CBindToActivity::TNoTagOrCommit)

	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, MeshMachine::TAwaitingMessageState<TCFDataClient::TCommitBindTo>, TErrorTagOr<TTag<KCommit> >)

	//commiting (either implicit or explicit).

	NODEACTIVITY_ENTRY(KCommit, CBindToActivity::TCommit, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

	//This is not autocommit and the sender has just explicitly cancelled. Alternativelly this is an error path.

	//Cancelling/processing error entiles sending TCancel to all dataclients awaiting confirmation

	//as well as it entiles leaving the new service provider.

	NODEACTIVITY_ENTRY(KErrorTag, CBindToActivity::TCancel, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)

NODEACTIVITY_END()

}

namespace PRStartActivity

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStart, PRStart, TCFServiceProvider::TStart, PRActivities::CStartActivity::NewL)

    FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingStart, CoreNetStates::TNoTagOrBearerPresentBlockedByStop)

	NODEACTIVITY_ENTRY(KBearerPresent, CoreNetStates::TBindSelfToPresentBearer, CoreNetStates::TAwaitingBindToComplete, TTag<KBearerPresent>)

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendNoBearer, MeshMachine::TAwaitingMessageState<TCFControlProvider::TBearer>, CoreNetStates::TNoTagOrBearerPresentOrErrorTag)

	//Start the service provider, use the default cancellation.

	//Forward TCancel to the service provider, wait for TStarted or TError (via the Error Activity)

	//When TStarted arrives after TCancel the activity will move to the nearest KErrorTag

	NODEACTIVITY_ENTRY(KBearerPresent, CoreNetStates::TStartServiceProviderRetry, CoreNetStates::TAwaitingStarted, MeshMachine::TNoTagOrErrorTag)

	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TDoNothing)

	//Start data clients, use the default cancellation.

	//Forward TCancel to the self, wait for TCFDataClient::TStarted or TError (via the Error Activity)

	//When TCFDataClient::TStarted arrives after TCancel the activity will move to the nearest KErrorTag

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStartSelf, CoreNetStates::TAwaitingDataClientStarted, MeshMachine::TNoTagOrErrorTag)

	NODEACTIVITY_ENTRY(KErrorTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientStopped, MeshMachine::TErrorTag)

	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseAndClearActivityError)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendStarted)

NODEACTIVITY_END()

}

namespace PRStopActivity

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStop, PRStop, TCFServiceProvider::TStop, MeshMachine::CNodeRetryActivity::NewL)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingStop, TActiveOrNoTagBlockedByBindTo)

	THROUGH_NODEACTIVITY_ENTRY(KActiveTag, CoreNetStates::TCancelDataClientStart, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientStopped, CoreNetStates::TNoTagOrNoBearer)

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendStop, CoreNetStates::TAwaitingStopped, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingRequestToServiceProvider, MeshMachine::TAwaitingLeaveComplete, TTag<CoreNetStates::KNoBearer>)

	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KNoBearer, PRStates::TSendStoppedAndGoneDown)

NODEACTIVITY_END()

}

namespace PRDataClientStartActivity

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityStartDataClient, PRDataClientStart, TCFDataClient::TStart)

    FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientStart, CoreNetStates::TNoTagOrNoDataClients)

	NODEACTIVITY_ENTRY(KNoTag, PRStates::TStartDataClients, TAcceptErrorState<CoreNetStates::TAwaitingDataClientsStarted>, MeshMachine::TErrorTagOr<MeshMachine::TTag<CoreNetStates::KNoDataClients> >)

	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KNoDataClients, PRStates::TSendDataClientStarted)

	NODEACTIVITY_ENTRY(KErrorTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientsStopped, MeshMachine::TErrorTag)

	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseAndClearActivityError)

NODEACTIVITY_END()

}

namespace PRDataClientStopActivity

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStopDataClient, PRDataClientStop, TCFDataClient::TStop, MeshMachine::CPreallocatedNodeRetryActivity::New)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientStop, MeshMachine::TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, PRStates::TProcessDataClientStop, CoreNetStates::TNoTagOrDataClientsToStopBlockedByStarting)

	NODEACTIVITY_ENTRY(CoreNetStates::KDataClientsToStop, CoreNetStates::TStopDataClients, CoreNetStates::TAwaitingDataClientsStopped, MeshMachine::TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, CoreNetStates::TNoTagOrUnbindOnStop)

	NODEACTIVITY_ENTRY(CoreNetStates::KUnbind, CoreNetStates::TSendClientLeavingRequestToServiceProvider, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

	// Note that if CMMCommsProviderBase::DestroyOrphanedDataClients() finds this activity running, it

	// will do nothing and assume that destruction of orphans will be initiated below.

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, PRStates::TDestroyOrphanedDataClients, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TSendDataClientStopped)

NODEACTIVITY_END()

}

namespace PRForwardStateChangeActivity

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityForwardStateChange, PRForwardStateChange, TCFMessage::TStateChange)

	NODEACTIVITY_ENTRY(KNoTag, PRStates::TForwardStateChange, MeshMachine::TAwaitingMessageState<TCFMessage::TStateChange>, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRDataClientStatusChangeActivity

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityDataClientStatusChange, PRDataClientStatusChange, TCFControlProvider::TDataClientStatusChange)

	NODEACTIVITY_ENTRY(KNoTag, PRStates::THandleDataClientStatusChangeAndDestroyOrphans, CoreNetStates::TAwaitingDataClientStatusChange, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

namespace PRGoneDownActivity

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityGoneDown, PRGoneDown, TCFControlClient::TGoneDown, CGoneDownActivity::New)

	// Our Service Provider has gone down unexpectedly (we haven't issued a TStop)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingGoneDown, MeshMachine::TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TCancelAndCloseZone0ClientExtIfaces, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingRequestToServiceProvider, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, CGoneDownActivity::TSendErrorRecoveryReq, MeshMachine::TAwaitingErrorRecoveryResponseOrError, CoreStates::TRetryOrIgnoreOrPropagate)

	THROUGH_NODEACTIVITY_ENTRY(CoreStates::KRetry, MeshMachine::TDoNothing, CGoneDownActivity::TIgnoreOrPropagate)

	LAST_NODEACTIVITY_ENTRY(CoreStates::KIgnore, MeshMachine::TDoNothing)

	NODEACTIVITY_ENTRY(CoreStates::KPropagate, CoreNetStates::TCancelStartAndStopSelf, CoreNetStates::TAwaitingDataClientStopped, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TSendGoneDown)

NODEACTIVITY_END()

}

namespace PRGoneUpActivity

{

// This Activity forward the TGoneUp event to the Control Clients nodes that are

// not in the originator lis

DECLARE_DEFINE_NODEACTIVITY(ECFActivityGoneUp, PRGoneUp, TCFControlClient::TGoneUp)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingGoneUp, MeshMachine::TNoTag)

    LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendGoneUp)

NODEACTIVITY_END()

}

namespace PRLegacyRMessage2HandlerActivity

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityLegacyRMessage2Handler, PRLegacyRMessage2Handler, TNodeSignal::TNullMessageId, MeshMachine::CNodeParallelMessageStoreActivityBase::NewL)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingLegacyRMessage2Ext, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TProcessOrForwardRMessage2Ext, CoreNetStates::TAwaitingRMessage2Processed, MeshMachine::TNoTag)

    LAST_NODEACTIVITY_ENTRY(KNoTag, CoreStates::TPostToOriginators)

NODEACTIVITY_END()

}

namespace CoreActivities

{

DECLARE_DEFINE_ACTIVITY_MAP(coreActivitiesAll)

	ACTIVITY_MAP_ENTRY(CoreErrorActivity, CoreError) //Must be first in the table

ACTIVITY_MAP_END()

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

//

//Error Activity

//

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

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

    {

	TUint c = GetNextActivityCountL(aActivitySig,aNode);

    return new(ELeave)CErrorActivity(aActivitySig, aNode, c);

    }

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

	:	MeshMachine::CNodeParallelActivityBase(aActivitySig, aNode, aActivitiesCount), iErroredActivityId(MeshMachine::KActivityNull)

	{

	}

CErrorActivity::~CErrorActivity()

	{

	if (Error() != KErrNone)

		{

		CNodeActivityBase* a = iNode.FindActivityById(iErroredActivityId);

		if (a)

			{

			a->SetError(Error());

			a->SetIdle();

			}

    	}

    SetError(KErrNone);

    }

TBool CErrorActivity::IsIdle() const

	{

	return NetStateMachine::ACore::IsIdle();

	}

void CErrorActivity::StartL(TNodeContextBase& aContext, const Messages::XNodePeerId& /*aOriginator*/, const TStateTriple& aFirst)

	{

	__ASSERT_DEBUG(IsIdle(), User::Panic(KSpecAssert_ESockCrStaCPRAC, 1));

  	MESH_LOG_ACTIVITY_EXT(KESockMeshMachine, this, &aContext, (_L8("CErrorActivity %08x:\tStartL->starting activity"), this));

	NetStateMachine::ACore::Start(&aContext, aFirst);

    MESH_LOG_ACTIVITY_EXT(KESockMeshMachine, this, &aContext, (_L8("CErrorActivity %08x:\tStartL->activity started"),this));

	}

TBool CErrorActivity::Next(TNodeContextBase& aContext)

	{

	TBool ret = EFalse;

	if (aContext.iMessage.IsMessage<TEBase::TCancel>())

		{

		CNodeActivityBase* a = iNode.FindActivityById(iErroredActivityId);

		//Special handling for TCancel.

		if (a && a->FindOriginator(aContext.iSender) != KErrNotFound)

			{

			ret = ETrue;

			//iActiviy could have handled it, but chose not to.

			Cancel(aContext);

			//consume the message, otherwise the iActivity will get idled and iActivity reference

			//will become invalid.

			aContext.iMessage.ClearMessageId();

			}

		}

	else

		{

		//If we have sent TErrorRecoveryRequest, we had to have set PostedToId() to the recipient (ControlProvider)

		//as otherwise there would be no path for propagating the potential TCancel.

		//The response however (TErrorRecoveryResponse or TError) will not necesserily come from that recipient (CP)

		//(for example it could be coming from the MCpr and we could be the SCpr).

		//Normally this would be a problem because any unrelated TError message arriving to the node

		//and presented to the awaiting state would easily be confused with the response (TError == no recovery on the MCpr == EPropagate).

		//We avoid the problem by checking all arriving  messages if they are adressed to our activity (but we don't

		//check the sender.

	    const TNodeCtxId* recipient = address_cast<const TNodeCtxId>(&aContext.iRecipient);

		if (recipient && (ActivityId() == recipient->NodeCtx()))

			{

			ret = ACore::Next(&aContext);

			if(ret)

				{

		    	MESH_LOG_ACTIVITY_EXT(KMeshMachineSubTag, this, &aContext, (_L8("CNodeActivityBase %08x:\tNext->transition"), this));

				}

			}

		}

	return ret;

  	}

EXPORT_DEFINE_SMELEMENT(CErrorActivity::TAwaitingError, NetStateMachine::MState, CErrorActivity::TContext)

EXPORT_C TBool CErrorActivity::TAwaitingError::Accept()

    {

	if (! iContext.iMessage.IsMessage<TEBase::TError>())

		{

		return EFalse;

		}

	TEBase::TError& errorMessage = message_cast<TEBase::TError>(iContext.iMessage);

	//Diagnostic panic only. TError message should not be travelling around with KErrNone.

	//If you see this panic, please send a proper error code.

	__ASSERT_DEBUG(errorMessage.iValue != KErrNone, User::Panic(KSpecAssert_ESockCrStaCPRAC, 2));

    MeshMachine::CNodeActivityBase* aa = iContext.Node().FindAddressedActivity(iContext);

    //TError is always a response. If there is no activity addressed by the TError,

    //then we assume the activity hasn't bothered waiting for the result.

    //We hence ignore the error.

    if (aa)

    	{

        aa->SetError(errorMessage.iValue);

    	aa->SetIdle();

    	}

    errorMessage.ClearMessageId();

    return EFalse;

    }

DEFINE_SMELEMENT(CErrorActivity::TCFAwaitingError, NetStateMachine::MState, CErrorActivity::TContext)

EXPORT_C TBool CErrorActivity::TCFAwaitingError::Accept()

    {

	if (! iContext.iMessage.IsMessage<TEBase::TError>())

		{

		return EFalse;