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

// Dummy implementation file for a SubConnection Provider

// 

//

/**

 @file

 @internalComponent

*/

#include <comms-infras/ss_log.h>

#include <comms-infras/corescpractivities.h>

#include <cs_subconparams.h>

#include <cs_subconevents.h>

#include "dummypr_subconnprov.h"

#include "dummypr_metaconnprov.h"

#include <elements/sd_mintercept.h>

#ifdef __CFLOG_ACTIVE

	#define KDummySCPRTag KESockConnectionTag

#endif

using namespace ESock;

using namespace MeshMachine;

//We reserve space for two preallocated activities that may start concurrently on the SCPR

//node: destroy and data client stop.

static const TUint KDefaultMaxPreallocatedActivityCount = 2;

static const TUint KMaxPreallocatedActivitySize = sizeof(MeshMachine::CNodeRetryParallelActivity) + sizeof(MeshMachine::APreallocatedOriginators<4>);

static const TUint KDummySCPRPreallocatedActivityBufferSize = KDefaultMaxPreallocatedActivityCount * KMaxPreallocatedActivitySize;

namespace DummySCPRStates

{

DEFINE_SMELEMENT(TRaiseGranted, NetStateMachine::MStateTransition, DummySCPRStates::TContext)

void TRaiseGranted::DoL()

	{

	if (iContext.Node().incomingStatus == TRUE)

		{

		//generate paramsgranted.

		CSubConGenEventParamsGranted* grantedevent = CSubConGenEventParamsGranted::NewL();

	    grantedevent->SetFamily(KSubConQoSFamily);

	    iContext.Node().NotifyClientsL(*grantedevent);

	    iContext.Node().incomingStatus = FALSE;

		}

	}

DEFINE_SMELEMENT(TAwaitingReBindTo, NetStateMachine::MState, DummySCPRStates::TContext)

TBool TAwaitingReBindTo::Accept()

	{

	const TLayerSelectionInfo* selectionInfo = static_cast<const TLayerSelectionInfo*>(

		iContext.Node().AccessPointConfig().FindExtension(TLayerSelectionInfo::TypeId()));

	ASSERT(selectionInfo); // should always be there

	TCFDataClient::TBindTo* bindToMsg = Messages::message_cast<TCFDataClient::TBindTo>(&iContext.iMessage);

	if (bindToMsg && iContext.Node().ServiceProvider() && bindToMsg->iNodeId != iContext.Node().ServiceProvider()->RecipientId())

	    {

	    if (TCprConfigModifier::Is(selectionInfo->CprConfig(), TCprConfigModifier::ESCPRHangOnRebind))

	        {

	        return ETrue;

	        }

	    else if (TCprConfigModifier::Is(selectionInfo->CprConfig(), TCprConfigModifier::ESCPRFailOnRebind))

	        {

	        iContext.iMessage.ClearMessageId();

	        Messages::RClientInterface::OpenPostMessageClose(iContext.NodeId(), iContext.iSender, 

                Messages::TEBase::TError(KErrAbort).CRef());

	        }

	    }

	return EFalse;

	}

DEFINE_SMELEMENT(TAwaitingBrokenStart, NetStateMachine::MState, DummySCPRStates::TContext)

TBool TAwaitingBrokenStart::Accept()

	{

	const TLayerSelectionInfo* selectionInfo = static_cast<const TLayerSelectionInfo*>(

		iContext.Node().AccessPointConfig().FindExtension(TLayerSelectionInfo::TypeId()));

	ASSERT(selectionInfo); // should always be there

	return (iContext.iMessage.IsMessage<TCFDataClient::TStart>() && 

			TCprConfigModifier::Is(selectionInfo->CprConfig(), TCprConfigModifier::ESCPRHangOnStart));

	}

}

namespace DummySCprParamsRequest

{

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, dummySCprParamRequest, TCFScpr::TSetParamsRequest)

	NODEACTIVITY_ENTRY(KNoTag, PRStates::TRespondWithCurrentParams, PRStates::TAwaitingParamRequest,  MeshMachine::TNoTag)

#else

DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, dummySCprParamRequest, TCFScpr::TParamsRequest)

	NODEACTIVITY_ENTRY(KNoTag, SCprStates::TRespondWithCurrentParams, SCprStates::TAwaitingParamRequest,  MeshMachine::TNoTag)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

NODEACTIVITY_END()

}

namespace DummyBindToActivity

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityBindTo, dummyBindTo, TCFDataClient::TBindTo)

	FIRST_NODEACTIVITY_ENTRY(DummySCPRStates::TAwaitingReBindTo, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, CoreStates::TNeverAccept,  MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)

NODEACTIVITY_END()

}

namespace DummyBreakStartActivity

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStart, dummyBreakSCPrStart, TCFDataClient::TStart, PRActivities::CStartActivity::NewL)

    FIRST_NODEACTIVITY_ENTRY(DummySCPRStates::TAwaitingBrokenStart, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, CoreStates::TNeverAccept,  MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)

NODEACTIVITY_END()

}

namespace DummyStartActivity

{

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

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

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

 	LAST_NODEACTIVITY_ENTRY(KNoTag, DummySCPRStates::TRaiseGranted)

NODEACTIVITY_END()

}

// Activity Map

namespace DummySCPRStates

{

DEFINE_ACTIVITY_MAP(stateMap)

   ACTIVITY_MAP_ENTRY(DummySCprParamsRequest, dummySCprParamRequest)

   ACTIVITY_MAP_ENTRY(DummyBindToActivity, dummyBindTo)

   ACTIVITY_MAP_ENTRY(DummyBreakStartActivity, dummyBreakSCPrStart)   

   ACTIVITY_MAP_ENTRY(DummyStartActivity, dummySCPrStart)   

ACTIVITY_MAP_END_BASE(SCprActivities, coreSCprActivities)

}

CDummySubConnectionProvider* CDummySubConnectionProvider::NewL(ESock::CSubConnectionProviderFactoryBase& aFactory)

    {

    CDummySubConnectionProvider* self = new (ELeave) CDummySubConnectionProvider(aFactory);

    CleanupStack::PushL(self);

    self->ConstructL(KDummySCPRPreallocatedActivityBufferSize);

    CleanupStack::Pop(self);

    return self;

    }

CDummySubConnectionProvider::CDummySubConnectionProvider(CSubConnectionProviderFactoryBase& aFactory)

:CCoreSubConnectionProvider(aFactory,DummySCPRStates::stateMap::Self())

	{

	LOG_NODE_CREATE(KDummySCPRTag, CDummySubConnectionProvider);

	}

CDummySubConnectionProvider::~CDummySubConnectionProvider()

	{

	LOG_NODE_DESTROY(KDummySCPRTag, CDummySubConnectionProvider);

	}

void CDummySubConnectionProvider::SetToIncomingL()

	{

 	_LIT(KName,"Test1");

 	TBuf<5> paramName(KName);

 	const int qosParams = 128;

	//RCFParameterFamilyBundle& pfb = CreateParameterBundleL();

	//RParameterFamily family = pfb.CreateFamilyL(KSubConQoSFamily); //PJLEFT

	RCFParameterFamilyBundle newBundle;

	newBundle.CreateL();

	iParameterBundle.Open(newBundle);

	RParameterFamily family = newBundle.CreateFamilyL(KSubConQoSFamily);

	// Create the generic set

	CSubConQosGenericParamSet* isubConQosGenParSet = CSubConQosGenericParamSet::NewL(family, RParameterFamily::EGranted);

    isubConQosGenParSet->SetHeaderMode(0);

    isubConQosGenParSet->SetName(paramName);

    isubConQosGenParSet->SetDownlinkBandwidth(qosParams);

    isubConQosGenParSet->SetDownLinkMaximumBurstSize(qosParams);

    isubConQosGenParSet->SetDownLinkAveragePacketSize(qosParams);

    isubConQosGenParSet->SetDownLinkDelay(qosParams);

    isubConQosGenParSet->SetDownLinkDelayVariation(qosParams);

   	isubConQosGenParSet->SetDownLinkMaximumBurstSize(qosParams);

   	isubConQosGenParSet->SetDownLinkPriority(qosParams);

   	isubConQosGenParSet->SetDownLinkMaximumPacketSize(qosParams);

   	isubConQosGenParSet->SetUpLinkAveragePacketSize(qosParams);

   	isubConQosGenParSet->SetUpLinkDelay(qosParams);

   	isubConQosGenParSet->SetUplinkBandwidth(qosParams);

   	isubConQosGenParSet->SetUpLinkDelayVariation(qosParams);

   	isubConQosGenParSet->SetUpLinkMaximumBurstSize(qosParams);

   	isubConQosGenParSet->SetUpLinkMaximumPacketSize(qosParams);

   	isubConQosGenParSet->SetUpLinkPriority(qosParams);

 	incomingStatus = ETrue;

	}