/*

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

*

*/

#include "T_BluetoothSynchronousLinkData.h"

#include "T_BTDevAddrData.h"

#include "T_BTSyncBandWidthData.h"

#include "T_BTUtil.h"

#include "T_TBTSockAddrChild.h"

/*@{*/

//Parameters

_LIT(KRSocketServ,												"socketserv");

_LIT(KTBTDevAddr,												"tbtdevaddr");

_LIT(KIntDevAddr,												"integerdevaddr");

_LIT(KPacketType,												"packettype");

_LIT(KSyncPacket,												"syncpacket");

_LIT(KData,														"data");

_LIT(KVoiceSetting,												"voicesetting");

_LIT(KSyncBandwidth,											"syncbandwidth");

_LIT(KLatency,													"latency");

_LIT(KRetransmissionType,										"retransmissiontype");

_LIT(KUseAlternateNotifier,										"usealternatenotifier");

_LIT(KUid,														"uid");

_LIT(KExpectNull,												"expectnull");

_LIT(KExpected, 												"expected");

_LIT(KErrForSetupConnection,									"errforsetupconnection");

_LIT(KErrForSend,												"errforsend");

_LIT(KErrForReceive,											"errforreceive");

_LIT(KErrForAcceptConnection,									"errforacceptconnection");

_LIT(KErrForDisconnect,											"errfordisconnect");

_LIT(KIncOutstanding,											"incoutstanding");

//Commands

_LIT(KCmdNewL,													"NewL");

_LIT(KCmdNewLC,													"NewLC");

_LIT(KCmdSetupConnection,										"SetupConnection");

_LIT(KCmdCancelSetup,											"CancelSetup");

_LIT(KCmdDisconnect,											"Disconnect");

_LIT(KCmdSend,													"Send");

_LIT(KCmdCancelSend,											"CancelSend");

_LIT(KCmdReceive,												"Receive");

_LIT(KCmdCancelReceive,											"CancelReceive");

_LIT(KCmdAcceptConnection,										"AcceptConnection");

_LIT(KCmdCancelAccept,											"CancelAccept");

_LIT(KCmdSetCoding,												"SetCoding");

_LIT(KCmdCoding,												"Coding");

_LIT(KCmdSetMaxBandwidth,										"SetMaxBandwidth");

_LIT(KCmdBandwidth,												"Bandwidth");

_LIT(KCmdSetMaxLatency,											"SetMaxLatency");

_LIT(KCmdLatency,												"Latency");

_LIT(KCmdSetRetransmissionEffort,								"SetRetransmissionEffort");

_LIT(KCmdRetransmissionEffort,									"RetransmissionEffort");

_LIT(KCmdRemoteName,											"RemoteName");

_LIT(KCmdSetNotifier,											"SetNotifier");

_LIT(KCmdDestructor,											"~");

_LIT(KCmdMBSLN_ExtensionInterfaceL,								"MBSLN_ExtensionInterfaceL");

//	Logging

_LIT(KLogMissingParameters,			"Missing parameters '%S' or '%S'");

_LIT(KLogMissingParameter,			"Missing parameter '%S'");

/*@}*/

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CT_BluetoothSynchronousLinkData* CT_BluetoothSynchronousLinkData::NewL()

	{

	CT_BluetoothSynchronousLinkData*	ret=new (ELeave) CT_BluetoothSynchronousLinkData();

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

CT_BluetoothSynchronousLinkData::CT_BluetoothSynchronousLinkData()

:	iData(NULL)

,	iErrForSetupConnection(0)

,	iErrForSend(0)

,	iErrForReceive(0)

,	iErrForAcceptConnection(0)

,	iErrForDisconnect(0)

,	ibtSyncPackets(NULL)

,	iSetupIndex(0)

,	iDisconnectionIndex(0)

,	iAcceptIndex(0)

,	iSendIndex(0)

,	iReceiveIndex(0)

	{

	}

void CT_BluetoothSynchronousLinkData::ConstructL()

	{

	}

CT_BluetoothSynchronousLinkData::~CT_BluetoothSynchronousLinkData()

	{

	DestroyData();

	}

//	Service methods

TAny* CT_BluetoothSynchronousLinkData::GetObject()

	{

	return iData;

	}

void CT_BluetoothSynchronousLinkData::SetObjectL(TAny* aObject)

	{

	//called when loading up persistent data

	DestroyData();

	iData = static_cast<CBluetoothSynchronousLink*>(aObject);

	}

void CT_BluetoothSynchronousLinkData::DisownObjectL()

	{

	iData=NULL;

	}

void CT_BluetoothSynchronousLinkData::DestroyData()

	{

	delete iData;

	iData = NULL;

	if ( ibtSyncPackets )

		{

		ibtSyncPackets = NULL;

		}

	}

inline TCleanupOperation CT_BluetoothSynchronousLinkData::CleanupOperation()

	{

	return CleanupOperation;

	}

void CT_BluetoothSynchronousLinkData::CleanupOperation(TAny* aAny)

	{

	CBluetoothSynchronousLink* arg=static_cast<CBluetoothSynchronousLink*>(aAny);

	delete arg;

	}

void CT_BluetoothSynchronousLinkData::HandleSetupConnectionCompleteL(TInt aError)

	{

	INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleSetupConnectionCompleteL Status (%d)"), aError);

	DecOutstanding();

	if ( aError!=iErrForSetupConnection )

		{

		ERR_PRINTF2(_L("HandleSetupConnectionCompleteL Call failed: aError = %d"),aError);

		SetAsyncError(iSetupIndex, aError);

		}

	else

		{

		INFO_PRINTF1(_L("HandleSetupConnectionCompleteL successful" ));

		}

	}

void CT_BluetoothSynchronousLinkData::HandleDisconnectionCompleteL(TInt aError)

	{

	INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleDisconnectionCompleteL Status (%d)"), aError);

	DecOutstanding();

	if ( aError!=iErrForDisconnect) 

		{

		 ERR_PRINTF2(_L("HandleDisconnectionCompleteL Call failed: aError = %d"),aError);

		 SetAsyncError(iDisconnectionIndex, aError);

		}

	else

		{

		 INFO_PRINTF1(_L("HandleDisconnectionCompleteL successful" ));

		}

	}

void CT_BluetoothSynchronousLinkData::HandleAcceptConnectionCompleteL(TInt aError)

	{

	INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleAcceptConnectionCompleteL Status (%d)"), aError);

	DecOutstanding();

	if ( aError!=iErrForAcceptConnection) 

		{

		ERR_PRINTF2(_L("HandleAcceptConnectionCompleteL Call failed: aError = %d"),aError);

		SetAsyncError(iAcceptIndex, aError);

		}

	else

		{

		INFO_PRINTF1(_L("HandleAcceptConnectionCompleteL successful" ));

		}

	}

void CT_BluetoothSynchronousLinkData::HandleSendCompleteL(TInt aError)

	{

	INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleSendCompleteL Status (%d)"), aError);

	DecOutstanding();

	if ( aError!=iErrForSend )

		{

		ERR_PRINTF2(_L("HandleSendCompleteL Call failed: aError = %d"),aError);

		SetAsyncError(iSendIndex, aError);

		}

	else

		{

		INFO_PRINTF1(_L("HandleSendCompleteL successful" ));

		}

	}

void CT_BluetoothSynchronousLinkData::HandleReceiveCompleteL(TInt aError)

	{

	INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleReceiveCompleteL Status (%d)"), aError);

	DecOutstanding();

	if ( aError!=iErrForReceive )

		{

		ERR_PRINTF2(_L("HandleReceiveCompleteL Call failed: aError = %d"),aError);

		SetAsyncError(iReceiveIndex, aError);

		}

	else

		{

		INFO_PRINTF1(_L("HandleReceiveCompleteL successful" ));

		}

	}

TBool CT_BluetoothSynchronousLinkData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

	{

	TBool	ret = ETrue;

	if ( aCommand==KCmdNewL )

		{

		DoCmdNewL(aSection);

		}

	else if ( aCommand==KCmdNewLC )

		{

		DoCmdNewLC(aSection);

		}

	else if ( aCommand==KCmdSetupConnection )

		{

		DoCmdSetupConnection(aSection, aAsyncErrorIndex);

		}

	else if ( aCommand==KCmdCancelSetup )

		{

		DoCmdCancelSetup();

		}

	else if ( aCommand==KCmdDisconnect )

		{

		DoCmdDisconnect(aSection, aAsyncErrorIndex);

		}

	else if ( aCommand==KCmdSend )

		{

		DoCmdSend(aSection, aAsyncErrorIndex);

		}

	else if ( aCommand==KCmdCancelSend )

		{

		DoCmdCancelSend();

		}

	else if ( aCommand==KCmdReceive )

		{

		DoCmdReceive(aSection, aAsyncErrorIndex);

		}

	else if ( aCommand==KCmdCancelReceive )

		{

		DoCmdCancelReceive();

		}

	else if ( aCommand==KCmdAcceptConnection )

		{

		DoCmdAcceptConnection(aSection, aAsyncErrorIndex);

		}

	else if ( aCommand==KCmdCancelAccept )

		{

		DoCmdCancelAccept();

		}

	else if ( aCommand==KCmdSetCoding )

		{

		DoCmdSetCoding(aSection);

		}

	else if ( aCommand==KCmdCoding )

		{

		DoCmdCoding(aSection);

		}

	else if ( aCommand==KCmdSetMaxBandwidth )

		{

		DoCmdSetMaxBandwidth(aSection);

		}

	else if ( aCommand==KCmdBandwidth )

		{

		DoCmdBandwidth();

		}

	else if ( aCommand==KCmdSetMaxLatency )

		{

		DoCmdSetMaxLatency(aSection);

		}

	else if ( aCommand==KCmdLatency )

		{

		DoCmdLatency(aSection);

		}

	else if ( aCommand==KCmdSetRetransmissionEffort )

		{

		DoCmdSetRetransmissionEffort(aSection);

		}

	else if ( aCommand==KCmdRetransmissionEffort )

		{

		DoCmdRetransmissionEffort(aSection);

		}

	else if ( aCommand==KCmdRemoteName )

		{

		DoCmdRemoteName(aSection);

		}

	else if ( aCommand==KCmdSetNotifier )

		{

		DoCmdSetNotifier(aSection);

		}

	else if ( aCommand==KCmdDestructor )

		{

		DoCmdDestructor();

		}

	else if ( aCommand==KCmdMBSLN_ExtensionInterfaceL )

		{

		DoCmdMBSLN_ExtensionInterfaceL(aSection);

		}

	else

		{

		ret=EFalse;

		}

	return ret;

	}

/**

Test NewL()

*/

void CT_BluetoothSynchronousLinkData::DoCmdNewL(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("CBluetoothSynchronousLink NewL Call"));

	DestroyData();

	TPtrC	socketServName;

	if(GetStringFromConfig(aSection, KRSocketServ(), socketServName))

		{

		RSocketServ* socketServ=static_cast<RSocketServ*>(GetDataObjectL(socketServName));

		TRAPD(err, iData = CBluetoothSynchronousLink::NewL(*this, *socketServ));

		if( err!=KErrNone )

			{

			INFO_PRINTF2(_L("CBluetoothSynchronousLink Standard Constructor NewL err=%d" ),err);

			SetError(err);

			}

		}

	else

		{

		ERR_PRINTF2(KLogMissingParameter, &KRSocketServ());

		SetBlockResult(EFail);

		}

	}

/**

Test NewLC()

*/

void CT_BluetoothSynchronousLinkData::DoCmdNewLC(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("CBluetoothSynchronousLink NewLC Call"));

	DestroyData();

	TPtrC	socketServName;

	if(GetStringFromConfig(aSection, KRSocketServ(), socketServName))

		{

		RSocketServ* socketServ=static_cast<RSocketServ*>(GetDataObjectL(socketServName));

		TRAPD(err, iData = CBluetoothSynchronousLink::NewLC(*this, *socketServ); CleanupStack::Pop(););

		if( err!=KErrNone )

			{

			INFO_PRINTF2(_L("CBluetoothSynchronousLink Standard Constructor NewLC err=%d" ),err);

			SetError(err);

			}

		}

	else

		{

		ERR_PRINTF2(KLogMissingParameter, &KRSocketServ());

		SetBlockResult(EFail);

		}

	}

/**

Test SetupConnection()

*/

void CT_BluetoothSynchronousLinkData::DoCmdSetupConnection(const TDesC& aSection, const TInt aAsyncErrorIndex)

	{

	INFO_PRINTF1(_L("CBluetoothSynchronousLink SetupConnection Call"));

	TBool	foundTBTDevAddr = EFalse;

	TPtrC	tbtDevAddrName;

	CT_BTDevAddrData* tbtDevAddrData = NULL;

	if(GetStringFromConfig(aSection, KTBTDevAddr(), tbtDevAddrName))

		{

		foundTBTDevAddr = ETrue;

		tbtDevAddrData = static_cast<CT_BTDevAddrData*>(GetDataWrapperL(tbtDevAddrName));

		}

	TBool	foundIntDevAddr = EFalse;

	TInt	intBtDevAddr = 0;

	if(GetIntFromConfig(aSection, KIntDevAddr(), intBtDevAddr))

		{

		foundIntDevAddr = ETrue;

		}

	if( !foundTBTDevAddr & !foundIntDevAddr )

		{

		ERR_PRINTF3(KLogMissingParameters, &KTBTDevAddr(), &KIntDevAddr());

		SetBlockResult(EFail);

		}

	TInt err = 0;

	//SetupConnection()2

	TBool	foundPackType = EFalse;

	TPtrC	packetTypeName;

	TInt	packetTypeValue;

	if(GetStringFromConfig(aSection, KPacketType(), packetTypeName))

		{

		if ( CT_BTUtil::GetPacketTypeIntValue(packetTypeName, packetTypeValue) )

			{

			INFO_PRINTF2(_L("CBluetoothSynchronousLink SetupConnection: packetTypeValue = %d"), packetTypeValue);

			foundPackType = ETrue;

			if( foundTBTDevAddr )

				{

				const TBTDevAddr* btDevAddr = tbtDevAddrData->GetAddress();

				err = iData->SetupConnection(*btDevAddr, packetTypeValue);

				}

			else

				{

				const TBTDevAddr intDevAddr(intBtDevAddr);

				iBTDeveAddr = intDevAddr;

				err = iData->SetupConnection(iBTDeveAddr, packetTypeValue);

				}

			}

		else

			{

			ERR_PRINTF1(_L("Unknow input for PacketType"));

			SetBlockResult(EFail);

			}

		}

	//SetupConnection()3

	TBool	foundSyncPack = EFalse;

	TPtrC	syncPacketName;

	if (GetStringFromConfig(aSection, KSyncPacket(), syncPacketName) )

		{

		TBTSyncPackets*	tbtSyncPackets = static_cast<TBTSyncPackets*>(GetDataObjectL(syncPacketName));

		foundSyncPack = ETrue;

		if( foundTBTDevAddr )

			{

			const TBTDevAddr* btDevAddr = tbtDevAddrData->GetAddress();

			err = iData->SetupConnection(*btDevAddr, *tbtSyncPackets);

			}

		else

			{

			const TBTDevAddr intDevAddr(intBtDevAddr);

			iBTDeveAddr = intDevAddr;

			err = iData->SetupConnection(iBTDeveAddr, *tbtSyncPackets);

			}

		}

	//SetupConnection()1

	if( !foundPackType & !foundSyncPack )

		{

		if( foundTBTDevAddr )

			{

			const TBTDevAddr* btDevAddr = tbtDevAddrData->GetAddress();

			err = iData->SetupConnection(*btDevAddr);

			}

		else

			{

			const TBTDevAddr intDevAddr(intBtDevAddr);

			iBTDeveAddr = intDevAddr;

			err = iData->SetupConnection(iBTDeveAddr);

			}

		}

	if(err != KErrNone)

		{

		ERR_PRINTF2(_L("CBluetoothSynchronousLink SetupConnection failed with error %d"), err);

		SetError(err);

		}

	else

		{

		IncOutstanding();

		iSetupIndex = aAsyncErrorIndex;

		}

	if( !GetIntFromConfig(aSection, KErrForSetupConnection(), iErrForSetupConnection))

		{

		ERR_PRINTF2(KLogMissingParameter, &KErrForSetupConnection());

		SetBlockResult(EFail);

		}

	}

/**

Test CancelSetup()

*/

void CT_BluetoothSynchronousLinkData::DoCmdCancelSetup()

	{

	INFO_PRINTF1(_L("CBluetoothSynchronousLink CancelSetup Call"));

	iData->CancelSetup();

	DecOutstanding();

	}

/**

Test Disconnect()

*/

void CT_BluetoothSynchronousLinkData::DoCmdDisconnect(const TDesC& aSection, const TInt aAsyncErrorIndex)

	{

	INFO_PRINTF1(_L("CBluetoothSynchronousLink Disconnect Call"));

	TInt err = iData->Disconnect();

	if(err != KErrNone)

		{