// 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 eSCO 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_LINKMGR);
#endif

// ----------------------------------------------------------------------------
// eSCO link
// ----------------------------------------------------------------------------
CeSCOLink* CeSCOLink::NewLC(CPhysicalLinksManager& aConnectionMan, CPhysicalLink* aConnection)
	{
	CeSCOLink* s = new(ELeave) CeSCOLink(aConnectionMan, aConnection);
	CleanupStack::PushL(s);
	s->ConstructL();
	return s;
	}


CeSCOLink* CeSCOLink::NewL(CPhysicalLinksManager& aLinksMan, CPhysicalLink* aPhysicalLink)
	{
	CeSCOLink* s = NewLC(aLinksMan, aPhysicalLink);
	CleanupStack::Pop();
	return s;
	}

CeSCOLink::CeSCOLink(CPhysicalLinksManager& aLinksMan, CPhysicalLink* aPhysicalLink)
: CBTSynchronousLink(aLinksMan, aPhysicalLink, EeSCOLink)
	{
	iUserPacketTypes = TBTSyncPackets::ESyncAnyESCOPacket;
	}

void CeSCOLink::ConstructL()
	{
	CBTSynchronousLink::ConstructL();
	}

CeSCOLink::~CeSCOLink()
	{
	}

TInt CeSCOLink::GetOption(TUint aLevel, TUint aName, TDes8& aOption) const
	{
	if (aLevel != KSolBtESCO)
		{
		return KErrNotSupported;
		}
	
	switch (aName)
		{
		case EeSCOExtOptions:
			{
			TBTeSCOLinkParams* options = reinterpret_cast<TBTeSCOLinkParams*>(const_cast<TUint8*>(aOption.Ptr()));
			options->iBandwidth.iTransmit = iTransmitBandwidth;
			options->iBandwidth.iReceive = iReceiveBandwidth;
			options->iLatency = iMaxLatency;
			options->iRetransmissionEffort = iRetransmissionEffort;
			options->iCoding = iVoiceSettings;
			return KErrNone;
			}
		
		default:
			return KErrNotSupported;
		}
	}

TInt CeSCOLink::SAPSetOption(TUint aLevel, TUint aName, const TDesC8& aOption)
/**
	Case ESyncSetUserPacketTypes:
	Store the user specified pakcet types if at least one of the eSCO packet types is set
	The packet types bitmask will be passed as a parameter of CPhysicalLink::Connect(const TBTSyncPackets aUserPacketTypes)
	in DoActiveOpenL()
*/
	{
	switch (aLevel)
		{
		case KSolBtSCO:
			switch (aName)
				{
				case ESyncUserPacketTypes:
					{
					TBTSyncPacketTypes optPacketTypes = *reinterpret_cast<const TBTSyncPacketTypes*>(aOption.Ptr());
					if (TBTSyncPackets::ESyncAnyESCOPacket & optPacketTypes) //make sure at least one packet type is supported
						{
						iUserPacketTypes = static_cast<TBTSyncPacketTypes>(optPacketTypes & (TBTSyncPackets::ESyncAnyESCOPacket));//Just eSCO packet types are stored
						}
					else
						{
						return KErrNotSupported;
						}
					
					break;
					}
				
				default:
					return KErrNotSupported;
				}
			break;
			
		case KSolBtESCO:
			switch (aName)
				{
				case EeSCOExtOptions:
					{
					TBTeSCOLinkParams options = *reinterpret_cast<const TBTeSCOLinkParams*>(aOption.Ptr());
					
					iTransmitBandwidth	= Max(options.iBandwidth.iTransmit, KMinESCOBandwidth);
					iReceiveBandwidth	= Max(options.iBandwidth.iReceive, KMinESCOBandwidth);
					iMaxLatency 		= Max(options.iLatency, KMinESCOLatency);
					iRetransmissionEffort = options.iRetransmissionEffort;
					iVoiceSettings		= options.iCoding;
					
					break;
					}

				default:
					return KErrNotSupported;
				}
			break;
			
		default:
			return KErrNotSupported;
		}
	
	return KErrNone;
	}


TUint CeSCOLink::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
**/
	{
	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 CeSCOLink::PacketTypeChange(THCIErrorCode aErr, THCIConnHandle aConnH, TUint16 aNewPacket)
	{
	iState->PacketTypeChange(*this, aErr, aConnH, aNewPacket);
	}

TBool CeSCOLink::IsLinkProbablyPossible()
	{
	TUint minBandwidth = MinBandwidth();
	if ((iTransmitBandwidth < minBandwidth) || (iReceiveBandwidth < minBandwidth))
		{
		return EFalse;
		}
	
	TUint maxBandwidth = MaxBandwidth();
	if ((iTransmitBandwidth != KESCOBandwidthDontCare) && (iTransmitBandwidth > maxBandwidth))
		{
		return EFalse;
		}
	
	if ((iReceiveBandwidth != KESCOBandwidthDontCare) && (iReceiveBandwidth > maxBandwidth))
		{
		return EFalse;
		}
	
	if (iMaxLatency < KMinESCOLatency)
		{
		return EFalse;
		}
	
	TBool airCodingOK = EFalse;
	TBTFeatures airCodings = iLinksMan.LinkManagerProtocol().PacketsSupportedLocally();
	switch (iVoiceSettings & KAirCodingFormatBits)
		{
		case ECVSD:
			airCodingOK = airCodings[ESupportedCVSDBit];
			break;
			
		case EuLawLog:
			airCodingOK = airCodings[ESupportedu_lawLogBit];
			break;
		
		case EALawLog:
			airCodingOK = airCodings[ESupportedA_lawLogBit];
			break;
		
		case ETransparentData:
			airCodingOK = airCodings[ESupportedTransparentSCODataBit];
			break;
		
		default:
			break;
		}

	return airCodingOK;
	}


TUint CeSCOLink::MinBandwidth()
	{
	TReal bandwidth = ((KMinESCOPacketSize *  KMilliSecondsFactor) / iMaxLatency);
	return static_cast<TUint>(bandwidth);
	}


TUint CeSCOLink::MaxBandwidth()
	{
	TInt maxPacketSize = 0;
	TInt interval = 1;
	
	if (iUserPacketTypes & TBTSyncPackets::ESyncPacketsEV5)
		{
		maxPacketSize = KMaxEV5Size;
		interval = KEV5Slots + KEV3Slots;
		}
	else if (iUserPacketTypes & TBTSyncPackets::ESyncPacketsEV4)
		{
		maxPacketSize = KMaxEV4Size;
		interval = KEV4Slots + KEV3Slots;
		}
	else if (iUserPacketTypes & TBTSyncPackets::ESyncPacketsEV3)
		{
		maxPacketSize = KMaxEV3Size;
		interval = KEV3Slots + KEV3Slots;
		}
	
	// Simple, easy to read version...
	//TReal bandwidth = (maxPacketSize / (KBasebandSlotTime * tesco));
	
	// Faster, still correct but harder to understand...  Add 1 to force rounding up, just in case.
	TUint bandwidth = ((KBasebandSlotsPerSecond * maxPacketSize) / interval) + 1;
	return bandwidth;
	}


TInt CeSCOLink::MakeConnection(CPhysicalLink* aPhysLink)
	{
	return aPhysLink->SynchronousConnect(iTransmitBandwidth, iReceiveBandwidth,
		iMaxLatency, iVoiceSettings,
		iRetransmissionEffort, iUserPacketTypes);
	}


TDes8& CeSCOLink::InboundFrame()
	{
	return iInboundSCOFrame;
	}

void CeSCOLink::SetExtOptions(TBTSyncConnectOpts aSyncOpts)
	{
	iVoiceSettings = aSyncOpts.iAirMode & KAirCodingFormatBits;
	
	// Using nasty magic numbers as we have a naming clash...  Responses to a command
	// use a different numbering scheme to setup commands.
	const TInt KCVSDResponse = 2;
	if (iVoiceSettings <= KCVSDResponse)
		{
		if (iVoiceSettings == KCVSDResponse)
			{
			iVoiceSettings = ECVSD;
			}
		else
			{
			iVoiceSettings++;
			}
		}
	
	TInt interval = aSyncOpts.iTransmissionInterval;
	
	TReal latency = interval * KBasebandSlotTime * KMilliSecondsFactor;
	iMaxLatency = static_cast<TInt16>(latency + 1);
	
	iTransmitBandwidth = static_cast<TUint>((KBasebandSlotsPerSecond * aSyncOpts.iTxPacketLength / interval) + 1);
	iReceiveBandwidth = static_cast<TUint>((KBasebandSlotsPerSecond * aSyncOpts.iRxPacketLength / interval) + 1);
	iRetransmissionEffort = aSyncOpts.iRetransmissionWindow;
	}

TUint16 CeSCOLink::GetPacketMask() const
	{
	return iUserPacketTypes;
	}

void CeSCOLink::GetExtOptions(TBTeSCOLinkParams& aOptions) const
	{
	aOptions.iBandwidth.iTransmit = iTransmitBandwidth;
	aOptions.iBandwidth.iReceive = iReceiveBandwidth;
	aOptions.iLatency = iMaxLatency;
	aOptions.iRetransmissionEffort = iRetransmissionEffort;
	aOptions.iCoding = iVoiceSettings;
	}