// btincoming.cpp
// 
// Copyright (c) 2008 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//

#include <e32base.h>
#include "btincomingserial.h"
#include "btservice.h"
#include "btdebug.h"

_LIT(KBtSerialPanic, "BTSerial");
void Panic(TBtSerialPanic aReason)
	{
	TRACE2("BtIncoming panic %d", aReason);
	User::Panic(KBtSerialPanic, aReason);
	};
	
	
NONSHARABLE_CLASS(CBtRegQuery) : public CActive
	{
public:
	CBtRegQuery(CBluetoothIncomingSerialConnection& aOwner);
	void Start(CBTRegistryResponse& aResponse);
private:
	virtual void RunL();
	virtual void DoCancel();
private:
	CBluetoothIncomingSerialConnection& iOwner;
	CBTRegistryResponse* iResponse;
	};
	

EXPORT_C CBluetoothIncomingSerialConnection* CBluetoothIncomingSerialConnection::NewL(MBtIncomingConnectionObserver& aObserver)
	{
	TRACE1("CBluetoothIncomingSerialConnection::NewL");
	CBluetoothIncomingSerialConnection* self = new(ELeave)CBluetoothIncomingSerialConnection(aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CBluetoothIncomingSerialConnection::~CBluetoothIncomingSerialConnection()
	{
	TRACE1("CBluetoothIncomingSerialConnection::~CBluetoothIncomingSerialConnection");
	delete iService;
	delete iSocket;
	iSockServ.Close();
	iSdpSession.Close();
	}
	
CBluetoothIncomingSerialConnection::CBluetoothIncomingSerialConnection(MBtIncomingConnectionObserver& aObserver)
	: iObserver(aObserver)
	{
	}
	
void CBluetoothIncomingSerialConnection::ConstructL()
	{
	TRACE1("+CBluetoothIncomingSerialConnection::ConstructL");
	User::LeaveIfError(iSdpSession.Connect());
	User::LeaveIfError(iSockServ.Connect());
	TUUID serialPortUUID = TUUID(0x1101);
	iService = CBtService::NewL(serialPortUUID, iSdpSession, iSockServ, *this, KRFCOMM); 
	
	// create a blank socket for the incoming connection
	iSocket = CBluetoothSocket::NewL(*this, iSockServ);
	TRACE1("-CBluetoothIncomingSerialConnection::ConstructL");
	}
	
	
EXPORT_C void CBluetoothIncomingSerialConnection::WaitForConnection()
	{
	TRACE1("CBluetoothIncomingSerialConnection::WaitForConnection");
	iService->AcceptConnection(*iSocket);
	}
	
EXPORT_C TBool CBluetoothIncomingSerialConnection::Connected()
	{
	TRACE2("CBluetoothIncomingSerialConnection::Connected %d", iSocketReady);
	return iSocketReady;
	}
	
EXPORT_C TBTDevAddr CBluetoothIncomingSerialConnection::ConnectedDeviceAddrL()
	{
	if (!iSocketReady) User::Leave(KErrNotReady);
	TBTSockAddr remote;
	iSocket->RemoteName(remote);
	return remote.BTAddr();
	}
	
EXPORT_C void CBluetoothIncomingSerialConnection::GetConnectedDeviceNameL()
	{
	if (iConnectedDevice) return;
	if (!iSocketReady) User::Leave(KErrNotReady);
	// lazy construction....
	if (!iRegQuery) iRegQuery = new(ELeave)CBtRegQuery(*this);
	if (iRegQuery->IsActive())
		{
		return;
		}
	if (reinterpret_cast<RHandleBase&>(iBtRegServ).Handle() == KNullHandle)
		{
		User::LeaveIfError(iBtRegServ.Connect());
		}
	if (iBtReg.SubSessionHandle() == KNullHandle)
		{
		User::LeaveIfError(iBtReg.Open(iBtRegServ));
		}
	if (!iRegReponse) iRegReponse = CBTRegistryResponse::NewL(iBtReg);
	
	
	TBTSockAddr remote;
	iSocket->RemoteName(remote);

	TBTRegistrySearch findConnected;
	findConnected.FindAddress(remote.BTAddr());
	TRequestStatus stat;
	iBtReg.CreateView(findConnected, stat);
	User::WaitForRequest(stat);
	User::LeaveIfError(stat.Int());
	
	iRegQuery->Start(*iRegReponse);
	}
	
void CBluetoothIncomingSerialConnection::QueryComplete(TInt aError)
	{
	iBtReg.CloseView();
	if (aError == KErrNone)
		{
		RBTDeviceArray& results = iRegReponse->Results();
		if (results.Count() != 1)
			// we queried by BD address, so should get 1 (or 0) results
			{
			aError = KErrNotFound;
			}
		if (aError == KErrNone)
			{
			TRAP(aError, iConnectedDevice = results[0]->CopyL());
			}
		if (aError == KErrNone)
			{
			if (iConnectedDevice->IsValidFriendlyName())
				{
				aError = iDeviceName.Create(iConnectedDevice->FriendlyName());
				}
			else
				{
				aError = iDeviceName.Create(iConnectedDevice->DeviceName().Length());
				if (aError == KErrNone)
					{
					iDeviceName.Copy(iConnectedDevice->DeviceName());
					}
				}
			if (aError!=KErrNone)
				{
				delete iConnectedDevice;
				iConnectedDevice = NULL;
				}
				
			}
		}
	iObserver.BtNameReceived(aError, iDeviceName);
	}

EXPORT_C void CBluetoothIncomingSerialConnection::Write(const TDesC8& aData)
	{
	TRACE1("CBluetoothIncomingSerialConnection::Write");
	__ASSERT_ALWAYS(iSocketReady, Panic(EBtSerialNotConnected));
	__ASSERT_ALWAYS(!iSending, Panic(EBtSerialWritePending));
	TInt err = iSocket->Send(aData, 0);
	if (err==KErrNone)
		{
		iSending = ETrue;
		}
	else
		{
		iObserver.BtWriteComplete(err);
		}
	}
	
EXPORT_C void CBluetoothIncomingSerialConnection::CancelWrite()
	{
	TRACE1("CBluetoothIncomingSerialConnection::CancelWrite");
	iSocket->CancelSend();
	iSending = EFalse;
	}
	
EXPORT_C void CBluetoothIncomingSerialConnection::Read(TDes8& aData)
	{
	TRACE1("CBluetoothIncomingSerialConnection::Read");
	__ASSERT_ALWAYS(iSocketReady, Panic(EBtSerialNotConnected));
	__ASSERT_ALWAYS(!iReceiving, Panic(EBtSerialReadPending));
	aData.Zero();	
	TInt err = iSocket->RecvOneOrMore(aData, 0, iXferLen);
	if (err==KErrNone)
		{
		iReceiving = ETrue;
		}
	else
		{
		iObserver.BtReadComplete(err);
		}
	}
	
EXPORT_C void CBluetoothIncomingSerialConnection::CancelRead()
	{
	TRACE1("CBluetoothIncomingSerialConnection::CancelRead");
	iSocket->CancelRead();
	iReceiving = EFalse;
	}
	
EXPORT_C void CBluetoothIncomingSerialConnection::ShutDown()
	{
	iSocket->Shutdown(RSocket::EImmediate);
	}

void CBluetoothIncomingSerialConnection::HandleConnectCompleteL(TInt _BTDEB(aErr))
	{
	TRACE2("CBluetoothIncomingSerialConnection::HandleConnectCompleteL(%d)", aErr);
	}
	
void CBluetoothIncomingSerialConnection::HandleAcceptCompleteL(TInt _BTDEB(aErr))
	{
	TRACE2("CBluetoothIncomingSerialConnection::HandleAcceptCompleteL(%d)", aErr);
	}
	
void CBluetoothIncomingSerialConnection::HandleShutdownCompleteL(TInt aErr)
	{
	TRACE2("CBluetoothIncomingSerialConnection::HandleShutdownCompleteL(%d)", aErr);
	iObserver.BtShutdownComplete(aErr);
	}
	
void CBluetoothIncomingSerialConnection::HandleSendCompleteL(TInt aErr)
	{
	TRACE1("CBluetoothIncomingSerialConnection::HandleSendCompleteL");
	__ASSERT_ALWAYS(iSending, PANIC());
	iSending = EFalse;
	iObserver.BtWriteComplete(aErr);
	}
	
void CBluetoothIncomingSerialConnection::HandleReceiveCompleteL(TInt aErr)
	{
	TRACE1("CBluetoothIncomingSerialConnection::HandleReceiveCompleteL");
	__ASSERT_ALWAYS(iReceiving, PANIC());
	iReceiving = EFalse;
	iObserver.BtReadComplete(aErr);
	}

void CBluetoothIncomingSerialConnection::HandleIoctlCompleteL(TInt _BTDEB(aErr))
	{
	TRACE2("CBluetoothIncomingSerialConnection::HandleIoctlCompleteL(%d)", aErr);
	}
	
void CBluetoothIncomingSerialConnection::HandleActivateBasebandEventNotifierCompleteL(TInt _BTDEB(aErr), TBTBasebandEventNotification& /*aEventNotification*/)
	{
	TRACE2("CBluetoothIncomingSerialConnection::HandleActivateBasebandEventNotifierCompleteL(%d)", aErr);
	}
	
void CBluetoothIncomingSerialConnection::HandleNewConnection(CBluetoothSocket* aConnectedSocket)
	{
	TRACE1("CBluetoothIncomingSerialConnection::HandleNewConnection");
	__ASSERT_ALWAYS(iSocket == aConnectedSocket, PANIC());
	iSocketReady = ETrue;
	iObserver.BtSerialConnected();
	}
	
void CBluetoothIncomingSerialConnection::HandleConnectFailed(TInt aError)
	{
	TRACE2("CBluetoothIncomingSerialConnection::HandleConnectFailed", aError);
	iSocketReady = EFalse;
	iObserver.BtSerialError(aError);
	}
	
CBtRegQuery::CBtRegQuery(CBluetoothIncomingSerialConnection& aOwner)
	: CActive(CActive::EPriorityStandard), iOwner(aOwner)
	{
	CActiveScheduler::Add(this);
	}
	
void CBtRegQuery::Start(CBTRegistryResponse& aBtResponse)
	{
	iResponse = &aBtResponse;
	iResponse->Start(iStatus);
	SetActive();
	}
		
void CBtRegQuery::RunL()
	{
	iOwner.QueryComplete(iStatus.Int());
	}
	
void CBtRegQuery::DoCancel()
	{
	iResponse->Cancel();
	// nasty race condition inside CBTRegistryResponse which means the cancal call may not
	// request out TRequestStatus (if DoCancel doesn't need to be called)
	if (iStatus == KRequestPending)
		{
		TRequestStatus* stat = &iStatus;
		User::RequestComplete(stat, KErrCancel);
		}
	}