// 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 Synchronous SAP class

// 

//

#include <bluetooth/logger.h>

#include <bt_sock.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

CBTSynchronousLink::CBTSynchronousLink(CPhysicalLinksManager& aLinksMan, CPhysicalLink* aPhysicalLink, TLinkType aLinkType)

: CBTBasebandSAP(aLinksMan, aPhysicalLink), iLinkType(aLinkType)

	{

	LOG2(_L("Creating sync SAP 0x%08x, type %d"), this, aLinkType);

	iState = &aLinksMan.LinkManagerProtocol().

			SyncStateFactory().GetState(CSyncLinkStateFactory::EClosed);

	}

void CBTSynchronousLink::ConstructL()

	{

	CBTBasebandSAP::ConstructL();

	}

CBTSynchronousLink::~CBTSynchronousLink()

	{

	LOG2(_L("Destroying sync SAP 0x%08x, iPhysicalLink 0x%08x"), this, iPhysicalLink);

	/*

	The ASSERT below has been commented due to an issue with ESock.

	During a normal shutdown, a CBTSynchronousLink will always unbind from the physical link before

	calling CanClose(). However automated tests have shown that there is no guarantee that during a 

	normal shutdown ESock will wait until the SAP has called CanClose() before deleting it. If

	the socket is closed whilst ESock is waiting for the CanClose() it will immediately delete the

	SAP (and complete the Shutdown request with KErrCancel). In this case the SAP will still be

	bound to a physical link.

	If the ESock issue is rectified, the ASSERT should be reinstated.

	ASSERT(!iPhysicalLink);

	*/

	iState->Deletion(*this);

	ReleaseAndUnbind();

	}

void CBTSynchronousLink::ReleaseAndUnbind()

/**

	NB If the physical link is unbound, and the SCO packet type is

	already ENoSCOLink, this function will do nothing!

*/

	{

	LOG1(_L("CBTSyncLink (0x%08x): Release and unbind"), this);

	if(iPhysicalLink)

		{

		iPhysicalLink->UndoOverridePark();

		}

	UnbindLink(iLinkType); //sets iPhysicalLink to NULL

	}

void CBTSynchronousLink::PhysicalLinkChange(const TBTBasebandEventNotification& IF_FLOGGING(aEvent), CPhysicalLink& __DEBUG_ONLY(aPhysicalLink))

	{

	__ASSERT_DEBUG(&aPhysicalLink == iPhysicalLink, Panic(EBTSCOSAPWrongPhysicalLink));

	// spec says should never have got parked with sco link

	//__ASSERT_DEBUG(!(aEvent.EventType() & ENotifyParkMode), Panic(EBTSCOSAPExistsWhenParking));

	//

	// Above ASSERT too strong as races are occuring. Log, but 'ignore'.

	#ifdef __FLOG_ACTIVE

	if (!(aEvent.EventType() & ENotifyParkMode))

		{

		LOG(_L("Sync SAP: Park request received with an active eSCO link. Likely to be a race."));

		}

	#endif

	}

void CBTSynchronousLink::AutoBind()

	/**

	   Pick an appropriate local port.

	**/

	{

	}

TInt CBTSynchronousLink::SetLocalName(TSockAddr& /*aAddr*/)

/**

	Override KErrNotSupported in base class.

*/

	{

	return KErrNone;

	}

void CBTSynchronousLink::Start()

	{

	iState->Start(*this);

	}

void CBTSynchronousLink::Timeout(TBasebandTimeout aTimeout)

	{

	iState->Timeout(*this, aTimeout);

	}

TInt CBTSynchronousLink::SetRemName(TSockAddr& aAddr)

	{

	TBTSockAddr bbAddr(aAddr);	// convert

	iRemoteDev=bbAddr.BTAddr();

	return KErrNone;	// to avoid race conditions we check for ACL later

	}

void CBTSynchronousLink::ActiveOpen()

/**

	Attach SCO link - the packet type should have been set by this stage

**/

	{

	iState->ActiveOpen(*this);

	}

void CBTSynchronousLink::DoActiveOpenL()

	{

	// proceed with creating the SCO link, but first check that phy exists

	CPhysicalLink* foundPhysicalLink = iLinksMan.FindPhysicalLink(iRemoteDev);

	if (!foundPhysicalLink)

		{

		// cannot do this until baseband is up...SCO Transports aren't allowed to instantiate

		// PHYs

		User::Leave(KErrNotReady);

		}

	else

		{

		if (foundPhysicalLink->HasSyncLink())

			{

			User::Leave(KErrInUse);

			}

		// go and actually make the link

		if(!IsLinkProbablyPossible())

			{

			User::Leave(KErrOverflow);

			}

		foundPhysicalLink->OverridePark();

		BindLink(iLinkType, *foundPhysicalLink);

		//Initiate a SCO connection with user specified packet types. all types will be allowed

		//if SetOption has not been called.

		TInt err = MakeConnection(foundPhysicalLink);

		if (err)

			{

			UnbindLink(iLinkType);

			User::Leave(err);

			}

		}

	}

TInt CBTSynchronousLink::PassiveOpen(TUint aQueSize)

/**

	Record ourselves as willing to accept a SCO link (possibly of the CoD we want)

**/

	{

	LOG1(_L("CBTSyncLink (0x%08x): PassiveOpen"), this);

	return iState->PassiveOpen(*this, aQueSize);

	}

TUint CBTSynchronousLink::Write(const TDesC8& aData, TUint aOptions, TSockAddr* aAddr)

	{

	return iState->Write(*this, aData, aOptions, aAddr);

	}

void CBTSynchronousLink::PacketsSent(THCIConnHandle /*aHandle*/, TUint16 /*aNumPackets*/)

	{

	// ignore - no need to unblock socket

	}

TBool CBTSynchronousLink::ConnectRequest(const TBTConnect& aSCOLink, const CPhysicalLink& aPhysicalLink)

	{

	return iState->ConnectRequest(*this, aSCOLink, aPhysicalLink);

	}

void CBTSynchronousLink::GetData(TDes8& aDesc,TUint /*aOptions*/,TSockAddr* /*aAddr*/)

	{

	// return the packet - we only have one - if other stuff has got overwritten

	// so be it - we're going for synchronicity...

	aDesc = InboundFrame();

	}

void CBTSynchronousLink::ConnectComplete(const TBTConnect& aSCOLink)

	{

	TBTSyncConnectOpts SCODefaultOpts(KSCODefaultTransmissionInterval, KSCODefaultRetransmissionWindow,

		KSCODefaultRxPacketLength, KSCODefaultTxPacketLength, KSCODefaultAirMode);

	SyncConnectComplete(aSCOLink, SCODefaultOpts);

	}

void CBTSynchronousLink::SyncConnectComplete(const TBTConnect& aSCOLink, const TBTSyncConnectOpts& aSyncOpts)

	{

	iState->ConnectComplete(*this, aSCOLink, aSyncOpts);

	}

void CBTSynchronousLink::Disconnection()

	{

	LOG2(_L("CBTSyncLink (0x%08x): disconnection on handle %d"), this, iHandle);

	iState->Disconnection(*this);

	}

void CBTSynchronousLink::ParentClosing()

	{

	iState->ParentClosing(*this);

	}

void CBTSynchronousLink::DataReceived(THCIConnHandle __DEBUG_ONLY(aConnH), TUint8 /*aIgnore*/, const TDesC8& aData)

	{

	__ASSERT_DEBUG(aConnH == Handle(), Panic(EBTSCOSAPWrongSCOSAP));

	iState->DataReceived(*this, aData);

	}

void CBTSynchronousLink::Error(TInt aErr)

	{

	iState->Error(*this, aErr);

	}

void CBTSynchronousLink::Shutdown(TCloseType aClose)

/**

	Detach SCO

**/

	{

	LOG2(_L("CBTSyncLink (0x%08x): shutdown no data on handle %d"), this, iHandle);

	iState->Shutdown(*this, aClose);

	}

void CBTSynchronousLink::Shutdown(TCloseType aClose, const TDesC8& /*aDisconnectionData*/)

/**

	Detach SCO - ESock seems to send us through this way 

	whatever the client request has been. The overload above probably does

	not need implementing.

**/

	{

	LOG2(_L("CBTSyncLink (0x%08x): shutdown on handle %d"), this, iHandle);

	iState->Shutdown(*this, aClose);

	}

TBool CBTSynchronousLink::IsIdle() const

	{

	return iState->IsIdle();

	}

TBool CBTSynchronousLink::IsOpen() const

	{

	return iState->IsOpen();

	}

TInt CBTSynchronousLink::CommonShutdown()

	{

	// not common to all baseband SAPs - only for closing SCO links at moment

	// since PhysicalLink object looks after the PHY, and ACL goes up/down with that

	TRAPD(err, iLinksMan.HCIFacade().DisconnectL(Handle(), static_cast<THCIErrorCode>(KActiveDisconnectReason)));

	return err;

	}

TBool CBTSynchronousLink::ConnectPending() const

	{

	return iState->IsConnectPending();

	}

//----------------------------------------------------------------------------------

// STATE FACTORY

//----------------------------------------------------------------------------------

CSyncLinkStateFactory* CSyncLinkStateFactory::NewL()

	{

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

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop();

	return ret;

	}

void CSyncLinkStateFactory::ConstructL()

	{

	iStates[EClosed]				=new (ELeave) TSCOLinkStateClosed(*this);

	iStates[EWaitForSCO]			=new (ELeave) TSCOLinkStateWaitForSCO(*this);

	iStates[EListening]				=new (ELeave) TSCOLinkStateListening(*this);

	iStates[EAccepting]				=new (ELeave) TSCOLinkStateAccepting(*this);

	iStates[EWaitForStart]			=new (ELeave) TSCOLinkStateWaitForStart(*this);

	iStates[EWaitForStartError]		=new (ELeave) TSCOLinkStateWaitForStartError(*this);

	iStates[EOpen]					=new (ELeave) TSCOLinkStateOpen(*this);

	iStates[EClosing]				=new (ELeave) TSCOLinkStateClosing(*this);

	}

CSyncLinkStateFactory::~CSyncLinkStateFactory()

	{

	iStates.DeleteAll();

	}

TSyncLinkState& CSyncLinkStateFactory::GetState(CSyncLinkStateFactory::TSyncLinkStates aState)

	{

	__ASSERT_DEBUG(iStates[aState],  Panic(ELinkMgrBadSCOState));

	return *iStates[aState];

	}

TInt CSyncLinkStateFactory::StateIndex(const TSyncLinkState* aState) const

	{

	TInt state;

	for (state = 0; state < ESyncLinkMaxState; state++)

		{

		if (iStates[state] == aState)

			{

			return state;

			}

		}

	return KUnknownState;

	}

//----------------------------------------------------------------------------------

// STATES

//----------------------------------------------------------------------------------

TSyncLinkState::TSyncLinkState(CSyncLinkStateFactory& aFactory)

: iFactory(aFactory)

	{

	}

void TSyncLinkState::PanicInState(TLinkPanic aPanic) const

	{

	Panic(aPanic, iFactory.StateIndex(this));

	}

void TSyncLinkState::ChangeState(CBTSynchronousLink& aContext, CSyncLinkStateFactory::TSyncLinkStates aState) const

	{

	aContext.iState->Exit(aContext);

#ifdef __FLOG_ACTIVE

	TSyncLinkState* state=&iFactory.GetState(aState);

	LOG2(_L("SCOLink: State %S -> %S"), &aContext.iState->iName, &state->iName);

#endif //__FLOG_ACTIVE

	aContext.iState=&iFactory.GetState(aState);

	aContext.iState->Enter(aContext);

	}

void TSyncLinkState::Enter(CBTSynchronousLink& /*aContext*/) const

	{

	// do nothing

	}

void TSyncLinkState::Deletion(CBTSynchronousLink& /*aContext*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	}

void TSyncLinkState::Exit(CBTSynchronousLink& /*aContext*/) const

	{

	// do nothing

	}

void TSyncLinkState::Timeout(CBTSynchronousLink& /*aContext*/, TBasebandTimeout /*aTimeout*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	}

void TSyncLinkState::Shutdown(CBTSynchronousLink& /*aContext*/, CServProviderBase::TCloseType /*aCloseType*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	}

TInt TSyncLinkState::PassiveOpen(CBTSynchronousLink& /*aContext*/, TUint /*aQueSize*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	return KErrNotSupported;

	}

void TSyncLinkState::ActiveOpen(CBTSynchronousLink& /*aContext*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	}

TBool TSyncLinkState::ConnectRequest(CBTSynchronousLink& /*aContext*/, const TBTConnect& /*aSCOLink*/, const CPhysicalLink& /*aPhysicalLink*/) const

	{

#ifdef _DEBUG

	PanicInState(EBTSCOSAPUnexpectedEvent); //listener code could be suspect

#endif

	return EFalse;

	}

void TSyncLinkState::Error(CBTSynchronousLink& /*aContext*/, TInt __DEBUG_ONLY(aErr)) const

	{

	// Don't propogate the error as listeners don't care if the hardware has gone down

	__ASSERT_DEBUG(aErr==KErrHardwareNotAvailable||aErr==EHostSecurityRejection, PanicInState(EBTSCOSAPUnexpectedEvent));

	}

void TSyncLinkState::ConnectComplete(CBTSynchronousLink& /*aContext*/, const TBTConnect& /*aConnect*/, const TBTSyncConnectOpts& /*aSyncOpts*/) const

	{

	// eat unexpected HW event

	}

void TSyncLinkState::Disconnection(CBTSynchronousLink& /*aContext*/) const

	{

	// eat unexpected HW event

	}

void TSyncLinkState::DataReceived(CBTSynchronousLink& /*aContext*/, const TDesC8& /*aData*/) const

	{

	// dump data

	}

void TSyncLinkState::PacketTypeChange(CBTSynchronousLink& /*aContext*/, THCIErrorCode /*aErr*/, THCIConnHandle /*aConnH*/, TUint16 /*aNewPacket*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	}

void TSyncLinkState::Start(CBTSynchronousLink& /*aContext*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	}

TUint TSyncLinkState::Write(CBTSynchronousLink& /*aContext*/, const TDesC8& /*aData*/, TUint /*aOptions*/, TSockAddr* /*aAddr*/) const

	{

	PanicInState(EBTSCOSAPUnexpectedEvent);

	return 0;

	}

TBool TSyncLinkState::IsIdle() const

	{

	return EFalse;

	}

TBool TSyncLinkState::IsOpen() const

	{

	return EFalse;

	}

void TSyncLinkState::ParentClosing(CBTSynchronousLink& /*aContext*/) const

	{

	// Swallow the event.

	}

TBool TSyncLinkState::IsConnectPending() const

	{

	return EFalse;

	}

//----------------------------------------------------------------------------------

TSCOLinkStateClosed::TSCOLinkStateClosed(CSyncLinkStateFactory& aFactory)

: TSyncLinkState(aFactory)

	{

	STATENAME("TSCOLinkStateClosed");

	}

void TSCOLinkStateClosed::Enter(CBTSynchronousLink& aContext) const

	{

	aContext.ReleaseAndUnbind();

	}

void TSCOLinkStateClosed::Start(CBTSynchronousLink& /*aContext*/) const

	{

	//gulp

	}

void TSCOLinkStateClosed::ActiveOpen(CBTSynchronousLink& aContext) const

	{

	TRAPD(err, aContext.DoActiveOpenL());

	if (err)

		{

		aContext.Socket()->Error(err, MSocketNotify::EErrorConnect);

		}

	else

		{

		ChangeState(aContext, CSyncLinkStateFactory::EWaitForSCO);

		}

	}

TBool TSCOLinkStateClosed::IsIdle() const

	{

	return ETrue;

	}

TInt TSCOLinkStateClosed::PassiveOpen(CBTSynchronousLink& aContext, TUint /*aQueSize*/) const

	{

	// need to attach to the PHY

	TInt err = aContext.iLinksMan.AddListener(aContext, aContext.iLinkType);

	if (err == KErrNone)

		{

		ChangeState(aContext, CSyncLinkStateFactory::EListening);

		}

	return err;

	}

void TSCOLinkStateClosed::Shutdown(CBTSynchronousLink& aContext, CServProviderBase::TCloseType aCloseType) const

	{

	LOG(_L("CBTSyncLink: closed state shutdown, immediate"));

	if (aCloseType == CServProviderBase::ENormal)

		{

		aContext.Socket()->CanClose();	// tell socket it's fine to go