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

// Implements the SCO SAP class

// 

//

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include <bluetooth/hci/hciframe.h>

#include "SCOSAP.h"

#include "physicallinksmanager.h"

#include "physicallinks.h"

#include "hcifacade.h"

#include "linkutil.h"

#include "linkmuxer.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_HCI_CSCOLINK);

#endif

CSCOLink* CSCOLink::NewLC(CPhysicalLinksManager& aConnectionMan, CPhysicalLink* aConnection)

	{

	LOG_STATIC_FUNC

	CSCOLink* s = new(ELeave) CSCOLink(aConnectionMan, aConnection);

	CleanupStack::PushL(s);

	s->ConstructL();

	return s;

	}

CSCOLink* CSCOLink::NewL(CPhysicalLinksManager& aLinksMan, CPhysicalLink* aPhysicalLink)

	{

	LOG_STATIC_FUNC

	CSCOLink* s = NewLC(aLinksMan, aPhysicalLink);

	CleanupStack::Pop();

	return s;

	}

CSCOLink::CSCOLink(CPhysicalLinksManager& aLinksMan, CPhysicalLink* aPhysicalLink)

: CBTSynchronousLink(aLinksMan, aPhysicalLink, ESCOLink)

	{

	LOG_FUNC

	iUserHVPacketTypes = EAnySCOPacket;

	}

void CSCOLink::ConstructL()

	{

	LOG_FUNC

	CBTSynchronousLink::ConstructL();

	}

CSCOLink::~CSCOLink()

	{

	LOG_FUNC

	}

TInt CSCOLink::GetOption(TUint /*aLevel*/, TUint /*aName*/, TDes8& /*aOption*/) const

	{

	LOG_FUNC

	return KErrNotSupported;

	}

TInt CSCOLink::SAPSetOption(TUint aLevel,TUint aName,const TDesC8 &aOption)

/**

	Case ESyncSetUserPacketTypes:

	Store the user specified pakcet types if at least one of the SCO packet types is set

	The packet types bitmask will be passed as a parameter of CPhysicalLink::Connect(const TBTSyncPackets aUserPacketTypes)

	in DoActiveOpenL()

*/

	{

	LOG_FUNC

	TInt rerr = KErrNone;

	if(aLevel != KSolBtSCO)

		{

		rerr = KErrNotSupported;

		}

	if(rerr == KErrNone)

		{

		switch (aName)

			{

			case ESCOSetUserPacketTypes:

				{

				TUint16 optHVPacketTypes = *reinterpret_cast<const TUint16*>(aOption.Ptr());

				if (EAnySCOPacket & optHVPacketTypes) //make sure at least one HV type is supported

					{

					iUserHVPacketTypes = static_cast<TUint16>(optHVPacketTypes & (EAnySCOPacket));//Just SCO packet types are stored

					iUserHVPacketTypes /= EPacketsHV1;

					}

				else

					{

					rerr = KErrNotSupported;

					}

				break;

				}

			case ESyncUserPacketTypes:

				{

				TUint16 optHVPacketTypes = *reinterpret_cast<const TUint16*>(aOption.Ptr());

				if(TBTSyncPackets::ESyncAnySCOPacket & optHVPacketTypes) //make sure at least one HV type is supported

					{

					iUserHVPacketTypes = static_cast<TUint16>(optHVPacketTypes & (TBTSyncPackets::ESyncAnySCOPacket));//Just SCO packet types are stored

					}

				else

					{

					rerr = KErrNotSupported;

					}

				break;

				}

			default:

				rerr = KErrNotSupported;

			}

		}

	return rerr;

	}

TUint CSCOLink::DoWrite(const TDesC8& aData, TUint /*aOptions*/, TSockAddr* /*aAddr*/)

/**

	Actually do the write - has been checked for length

	In future could write data on a specific SCO "subchannel" if we do that sort of thing

	between devices - possibly then use aAddr or aOptions

**/

	{

	LOG_FUNC

	TUint retVal = 0;

	TInt err = KErrNone;

#ifdef STACK_SCO_DATA

	// Trim length of data if necessary

	TPtrC8 data = aData.Left(CHctlSynchronousDataFrame::KHCTLMaxSynchronousDataSize);

	if (iLinksMan.LinkManagerProtocol().LinkMuxer().CanWriteSCOData())

		{

		// for now just try to write - if it fails then it doesnt matter - its

		// a lot more *s*ynchronous than sticking it in a queue ;-)

		LOG(_L("CSCOLink: Can write SCO data..."));

		delete iOutboundSCOFrame;

		iOutboundSCOFrame = NULL;

		const CHCIFacade& facade = iLinksMan.HCIFacade(); 

		TRAP(err, iOutboundSCOFrame = facade.NewSynchronousDataFrameL(static_cast<TUint8>(data.Length())));

		if(iOutboundSCOFrame && err == KErrNone)

			{

			// got the frame - so go and use it

			facade.FormatSCOData(*iOutboundSCOFrame, iHandle, data);

			if (facade.WriteSCOData(*iOutboundSCOFrame) == KErrNone)

				{

				retVal = data.Length(); // we sent this many bytes

				}

			}

		}

	else

		{

		LOG(_L("CSCOLink: ERROR Cannot write SCO data."));

		Socket()->Error(((err == KErrNone) ? KErrInUse : err), MSocketNotify::EErrorSend);

		}

#else

	LOG(_L("CSCOLink: ERROR SCO data via stack not supported."))

	Socket()->Error(KErrNotSupported, MSocketNotify::EErrorSend);

#endif

	return retVal;

	}

void CSCOLink::PacketTypeChange(THCIErrorCode aErr, THCIConnHandle aConnH, TUint16 aNewPacket)

	{

	LOG_FUNC

	iState->PacketTypeChange(*this, aErr, aConnH, aNewPacket);

	}

TBool CSCOLink::IsLinkProbablyPossible()

	{

	LOG_FUNC

	return Baseband().IsSCOPossible();

	}

TInt CSCOLink::MakeConnection(CPhysicalLink* aPhysLink)

	{

	LOG_FUNC

	// Stores packets as sync packet types, uses packets as SCO types.

	return aPhysLink->SCOConnect(iUserHVPacketTypes << KSCOvsSyncHVOffset);

	}

TDes8& CSCOLink::InboundFrame()

	{

	LOG_FUNC

	return iInboundSCOFrame;

	}

void CSCOLink::SetExtOptions(TBTSyncConnectOpts /*aSyncOpts*/)

	{

	LOG_FUNC

	}