// Copyright (c) 1999-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 <bluetooth/logger.h>

#include "physicallinkmetrics.h"

#include "physicallinks.h"

#include "linkutil.h"

#include "ProxySAP.h"

#include "btsockettimer.h"

#include <bluetooth/hci/hciutil.h>

#include <bluetooth/hci/readfailedcontactcountercommand.h>

#include <bluetooth/hci/readlinkqualitycommand.h>

#include <bluetooth/hci/readrssicommand.h>

#include <bluetooth/hci/readtransmitpowerlevelcommand.h>

#include <bluetooth/hci/readrssicompleteevent.h>

#include <bluetooth/hci/readlinkqualitycompleteevent.h>

#include <bluetooth/hci/readfailedcontactcountercompleteevent.h>

#include <bluetooth/hci/readtransmitpowerlevelcompleteevent.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);

#endif

TPLMManager::TPLMManager()

	:iPLMQue(_FOFF(CBTProxySAP, iPLMLink))

	{

	LOG_FUNC

	}

void TPLMManager::UpdatePLMState(THciCommandState aPLMState)

	{

	LOG_FUNC

	FTRACE(FPrint(_L("TPLMManager::UpdatePLMState, Previous state :: %d\n"), iPLMState));

	iPLMState = aPLMState;

	FTRACE(FPrint(_L("TPLMManager::UpdatePLMState, Changed state :: %d\n"), iPLMState));

	}

void TPLMManager::RegisterProxySAP(CBTProxySAP& aSAP)

	{

	LOG_FUNC

	iPLMQue.AddLast(aSAP);

	}

void TPLMManager::UpdatePLMValue(TInt aPLMValue)

	{

	LOG_FUNC

	FTRACE(FPrint(_L("TPLMManager::UpdatePLMValue, Previous PLM value :: %d\n"), (PLMValue())() ));

	iPLMValue() = aPLMValue;

	FTRACE(FPrint(_L("TPLMManager::UpdatePLMValue, Changed PLM value :: %d\n"), (PLMValue())() ));

	}

TPckgBuf<TInt>& TPLMManager::PLMValue()

	{

	LOG_FUNC

	return iPLMValue;

	}

THciCommandState TPLMManager::PLMState() const

	{

	LOG_FUNC

	return iPLMState;

	}

void TPLMManager::NotifyQueuedProxySAPs(TInt aErr, TUint aName, TDesC8* aBuf)

	{

	LOG_FUNC

	TDblQueIter<CBTProxySAP> iter(iPLMQue);

	CBTProxySAP* thisSAP;

	// Iterate through all ProxySAPs that have requested this PLM, notifying them

	while ((thisSAP = iter++) != NULL)

		{

		thisSAP->IoctlComplete(aErr, KSolBtLMProxy, aName, aBuf);

		thisSAP->iPLMLink.Deque();

		}

	}

/*Check if we have any outstanding requests registered by the clients*/

TBool TPLMManager::AnyOutstandingClientRequest() const

	{

	LOG_FUNC

	if(iPLMQue.IsEmpty())

		{

		return EFalse;

		}

	else

		{

		return ETrue;

		}

	}

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

// class CPhysicalLinkMetrics

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

CPhysicalLinkMetrics* CPhysicalLinkMetrics::NewL(CPhysicalLink& aLink, MHCICommandQueue& aCmdController)

	{

	LOG_STATIC_FUNC

	CPhysicalLinkMetrics* self = new(ELeave) CPhysicalLinkMetrics(aLink, aCmdController);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CPhysicalLinkMetrics::CPhysicalLinkMetrics(CPhysicalLink& aLink, MHCICommandQueue& aCmdController)

	: iParent(aLink),

	  iCmdController(aCmdController),

	  iQueLink(this)

	{

	TCallBack plmCb(PLMEventReceived, this);

	iPLMTimer.Set(plmCb);

	iParent.SubscribeLinkObserver(*this);

	}

void CPhysicalLinkMetrics::ConstructL()

	{

	LOG_FUNC

	}

CPhysicalLinkMetrics::~CPhysicalLinkMetrics()

	{

	RemovePLMCommands();

	}

void CPhysicalLinkMetrics::PhysicalLinkChange(const TBTBasebandEventNotification& aEvent, CPhysicalLink& /* aPhysicalLink */)

	{

	LOG_FUNC;

	if (aEvent.EventType() == ENotifyPhysicalLinkDown || aEvent.EventType() == ENotifyPhysicalLinkError)

		{

		RemovePLMPoll();

		iRssi.NotifyQueuedProxySAPs(KErrDisconnected, KLMReadRssiIoctl, &iDummyResult);

		iLinkQuality.NotifyQueuedProxySAPs(KErrDisconnected, KLMReadLinkQualityIoctl, &iDummyResult);

		iFailedContactCounter.NotifyQueuedProxySAPs(KErrDisconnected, KLMReadFailedContactCounterIoctl, &iDummyResult);

		iTransmitPowerLevel.NotifyQueuedProxySAPs(KErrDisconnected, KLMReadCurrentTransmitPowerLevelIoctl, &iDummyResult);

		}

	}

TPhysicalLinkObserverQLink& CPhysicalLinkMetrics::ObserverQLink()

	{

	return iQueLink;

	}

void CPhysicalLinkMetrics::ReadNewPhysicalLinkMetricValue(TUint aIoctlName, CBTProxySAP& aSAP, TInt aCurrentValue)

	{

	LOG_FUNC;

	switch (aIoctlName)

		{

		case KLMReadRssiIoctl:

			{

			// If the command has not been issued, we issue now

			if (iRssi.PLMState() == ECommandIdle)

				{

				iRssi.UpdatePLMValue(aCurrentValue);

				iRssi.RegisterProxySAP(aSAP);

				//Issue the command and change the state to ECommandIssued

				ReadRssiCommand();

				}

			// Otherwise, if the command is waiting for the timer to expire, and the current value the user has is

			// different to the currently cached value, we complete straight away

			else if (iRssi.PLMState() == ECommandBlockedForTimer && aCurrentValue != iRssi.PLMValue()())

				{

				aSAP.IoctlComplete(KErrNone, KSolBtLMProxy, KLMReadRssiIoctl, &iRssi.PLMValue());

				}

			// Otherwise, if we are waiting for the command to complete, or we are waiting for the timer to expire,

			// and the value the user has is the same as the cached valuewe just queue the SAP.

			else

				{

				iRssi.RegisterProxySAP(aSAP);

				}

			}

			break;

		case KLMReadLinkQualityIoctl:

			{

			// If the command has not been issued, we issue now

			if (iLinkQuality.PLMState() == ECommandIdle)

				{

				iLinkQuality.UpdatePLMValue(aCurrentValue);

				iLinkQuality.RegisterProxySAP(aSAP);

				//Issue the command and change the state to ECommandIssued

				ReadLinkQualityCommand();

				}

			// Otherwise, if the command is waiting for the timer to expire, and the current value the user has is

			// different to the currently cached value, we complete straight away

			else if (iLinkQuality.PLMState() == ECommandBlockedForTimer && aCurrentValue != iLinkQuality.PLMValue()())

				{

				aSAP.IoctlComplete(KErrNone, KSolBtLMProxy, KLMReadLinkQualityIoctl, &iLinkQuality.PLMValue());

				}

			// Otherwise, if we are waiting for the command to complete, or we are waiting for the timer to expire,

			// and the value the user has is the same as the cached valuewe just queue the SAP.

			else

				{

				iLinkQuality.RegisterProxySAP(aSAP);

				}

			}

			break;

		case KLMReadFailedContactCounterIoctl:

			{

			// If the command has not been issued, we issue now

			if (iFailedContactCounter.PLMState() == ECommandIdle)

				{

				iFailedContactCounter.UpdatePLMValue(aCurrentValue);

				iFailedContactCounter.RegisterProxySAP(aSAP);

				//Issue the command and change the state to ECommandIssued

				ReadFailedContactCounterCommand();

				}

			// Otherwise, if the command is waiting for the timer to expire, and the current value the user has is

			// different to the currently cached value, we complete straight away

			else if (iFailedContactCounter.PLMState() == ECommandBlockedForTimer && aCurrentValue != iFailedContactCounter.PLMValue()())

				{

				aSAP.IoctlComplete(KErrNone, KSolBtLMProxy, KLMReadFailedContactCounterIoctl, &iFailedContactCounter.PLMValue());

				}

			// Otherwise, if we are waiting for the command to complete, or we are waiting for the timer to expire,

			// and the value the user has is the same as the cached valuewe just queue the SAP.

			else

				{

				iFailedContactCounter.RegisterProxySAP(aSAP);

				}

			}

			break;

		case KLMReadCurrentTransmitPowerLevelIoctl:

			{

			// If the command has not been issued, we issue now

			if (iTransmitPowerLevel.PLMState() == ECommandIdle)

				{

				iTransmitPowerLevel.UpdatePLMValue(aCurrentValue);

				iTransmitPowerLevel.RegisterProxySAP(aSAP);

				//Issue the command and change the state to ECommandIssued

				ReadTransmitPowerLevelCommand();

				}

			// Otherwise, if the command is waiting for the timer to expire, and the current value the user has is

			// different to the currently cached value, we complete straight away

			else if (iTransmitPowerLevel.PLMState() == ECommandBlockedForTimer && aCurrentValue != iTransmitPowerLevel.PLMValue()())

				{

				aSAP.IoctlComplete(KErrNone, KSolBtLMProxy, KLMReadCurrentTransmitPowerLevelIoctl, &iTransmitPowerLevel.PLMValue());

				}

			// Otherwise, if we are waiting for the command to complete, or we are waiting for the timer to expire,

			// and the value the user has is the same as the cached valuewe just queue the SAP.

			else

				{

				iTransmitPowerLevel.RegisterProxySAP(aSAP);

				}

			}

			break;

		default:

			__ASSERT_DEBUG(EFalse, Panic(EBTProxySAPInvalidIoctl));

		}

	}

void CPhysicalLinkMetrics::ReadRssiCommand()

	{

	LOG_FUNC

	TRAPD(err, ReadRssiCommandL());

	if (err != KErrNone)

		{

		iRssi.NotifyQueuedProxySAPs(err, KLMReadRssiIoctl, &iDummyResult);

		}

	}

void CPhysicalLinkMetrics::ReadRssiCommandL()

	{

	LOG_FUNC

	// Ownership of cmd transfered even if MhcqAddCommandL leaves

	CReadRSSICommand* cmd = CReadRSSICommand::NewL(iParent.Handle());

	iCmdController.MhcqAddCommandL(cmd, *this);

	iRssi.UpdatePLMState(ECommandIssued);

	}

void CPhysicalLinkMetrics::ReadLinkQualityCommand()

	{

	LOG_FUNC

	TRAPD(err, ReadLinkQualityCommandL());

	if (err != KErrNone)

		{

		iLinkQuality.NotifyQueuedProxySAPs(err, KLMReadLinkQualityIoctl, &iDummyResult);

		}

	}

void CPhysicalLinkMetrics::ReadLinkQualityCommandL()

	{

	LOG_FUNC

	// Ownership of cmd transfered even if MhcqAddCommandL leaves

	CReadLinkQualityCommand* cmd = CReadLinkQualityCommand::NewL(iParent.Handle());

	iCmdController.MhcqAddCommandL(cmd, *this);

	iLinkQuality.UpdatePLMState(ECommandIssued);

	}

void CPhysicalLinkMetrics::ReadFailedContactCounterCommand()

	{

	LOG_FUNC

	TRAPD(err, ReadFailedContactCounterCommandL());

	if (err != KErrNone)

		{

		iFailedContactCounter.NotifyQueuedProxySAPs(err, KLMReadFailedContactCounterIoctl, &iDummyResult);

		}

	}

void CPhysicalLinkMetrics::ReadFailedContactCounterCommandL()

	{

	LOG_FUNC

	// Ownership of cmd transfered even if MhcqAddCommandL leaves

	CReadFailedContactCounterCommand* cmd = CReadFailedContactCounterCommand::NewL(iParent.Handle());

	iCmdController.MhcqAddCommandL(cmd, *this);

	iFailedContactCounter.UpdatePLMState(ECommandIssued);

	}

void CPhysicalLinkMetrics::ReadTransmitPowerLevelCommand()

	{

	LOG_FUNC

	TRAPD(err, ReadTransmitPowerLevelCommandL());

	if (err != KErrNone)

		{

		iTransmitPowerLevel.NotifyQueuedProxySAPs(err, KLMReadCurrentTransmitPowerLevelIoctl, &iDummyResult);

		}

	}

void CPhysicalLinkMetrics::ReadTransmitPowerLevelCommandL()

	{

	LOG_FUNC

	// Ownership of cmd transfered even if MhcqAddCommandL leaves

	CReadTransmitPowerLevelCommand* cmd = CReadTransmitPowerLevelCommand::NewL(iParent.Handle(), ECurrentTransmitPowerLevel);

	iCmdController.MhcqAddCommandL(cmd, *this);

	iTransmitPowerLevel.UpdatePLMState(ECommandIssued);

	}

void CPhysicalLinkMetrics::MhcqcCommandErrored(TInt aErrorCode, const CHCICommandBase* aCommand)

	{

	LOG_FUNC

	__ASSERT_DEBUG(aCommand, Panic(EHCIUnknownCommandEvent));   // this should never happen

	LOG2(_L("error code:%d opcode:0x%x"), aErrorCode, aCommand->Opcode());

	switch (aCommand->Opcode())

		{

		case KReadFailedContactCounterOpcode:

			iFailedContactCounter.UpdatePLMState(ECommandIdle);			

			iFailedContactCounter.NotifyQueuedProxySAPs(aErrorCode, KLMReadFailedContactCounterIoctl, &iDummyResult);

			break;

		case KReadLinkQualityOpcode:

			iLinkQuality.UpdatePLMState(ECommandIdle);

			iLinkQuality.NotifyQueuedProxySAPs(aErrorCode, KLMReadLinkQualityIoctl, &iDummyResult);

			break;

		case KReadRSSIOpcode:

			iRssi.UpdatePLMState(ECommandIdle);

			iRssi.NotifyQueuedProxySAPs(aErrorCode, KLMReadRssiIoctl, &iDummyResult);			

			break;

		case KReadTransmitPowerLevelOpcode:

			iTransmitPowerLevel.UpdatePLMState(ECommandIdle);

			iTransmitPowerLevel.NotifyQueuedProxySAPs(aErrorCode, KLMReadCurrentTransmitPowerLevelIoctl, &iDummyResult);						

			break;

		default:

			//LOG1(_L("physicallinkmetrics.cpp: Invalid command opcode, expecting only PLM commands but got %d command"),aCommand->Opcode());

			__ASSERT_DEBUG(EFalse, Panic(EHCICommandBadArgument));

		}

	}

// From MHCICommandQueueClient

void CPhysicalLinkMetrics::MhcqcCommandEventReceived(const THCIEventBase& aEvent,

													 const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	switch(aEvent.EventCode())

		{

		case ECommandCompleteEvent:

			{

			const THCICommandCompleteEvent& completeEvent = THCICommandCompleteEvent::Cast(aEvent);

			CommandCompleteEvent(completeEvent);

			break;

			}

		default:

			{

			LOG1(_L("Warning!! Unexpected Event Received (event code:%d)"), aEvent.EventCode());

			__ASSERT_DEBUG(EFalse, Panic(EHCIUnexpectedEvent));

			break;

			}

		}	

	}

void CPhysicalLinkMetrics::CommandCompleteEvent(const THCICommandCompleteEvent& aEvent)

	{

	LOG_FUNC

	THCIOpcode opcode = aEvent.CommandOpcode();

	switch (opcode)

		{

		case KReadFailedContactCounterOpcode:

			{

			const TReadFailedContactCounterCompleteEvent& event = TReadFailedContactCounterCompleteEvent::Cast(aEvent);

			HandleReadFailedContactCounterCompleteEvent(event);

			}

			break;

		case KReadLinkQualityOpcode:

			{

			const TReadLinkQualityCompleteEvent& event = TReadLinkQualityCompleteEvent::Cast(aEvent);

			HandleReadLinkQualityCompleteEvent(event);

			}

			break;

		case KReadRSSIOpcode:

			{

			const TReadRSSICompleteEvent& event = TReadRSSICompleteEvent::Cast(aEvent);

			HandleReadRssiCompleteEvent(event);

			}

			break;

		case KReadTransmitPowerLevelOpcode:

			{

			const TReadTransmitPowerLevelCompleteEvent& event = TReadTransmitPowerLevelCompleteEvent::Cast(aEvent);

			HandleReadTransmitPowerLevelCompleteEvent(event);

			}

			break;

		default:

			LOG2(_L("Warning: Unexpected Command complete event! Opcode %d error code %d"), opcode, aEvent.ErrorCode());

			__ASSERT_DEBUG(EFalse, Panic(EHCIUnknownCommandCompleteOpcode));

			break;

		}

	}

void CPhysicalLinkMetrics::HandleReadFailedContactCounterCompleteEvent(const TReadFailedContactCounterCompleteEvent& aEvent)

	{

	LOG_FUNC

	TUint8 result = 0;

	TInt err = CHciUtil::SymbianErrorCode(aEvent.ErrorCode());

	if (err == KErrNone)

		{

		result = aEvent.FailedContactCounter();

		}

	if (err != KErrNone || static_cast<TInt>(result) != iFailedContactCounter.PLMValue()())

		{

		iFailedContactCounter.UpdatePLMValue(result);

		// Notify all SAPs via IoctlComplete, with the result or an error code

		iFailedContactCounter.NotifyQueuedProxySAPs(err, KLMReadFailedContactCounterIoctl, &iFailedContactCounter.PLMValue());

		}

	iFailedContactCounter.UpdatePLMState(ECommandBlockedForTimer);		

	QueueNextPLMPollIfNotAlreadyQueued();	

	}

void CPhysicalLinkMetrics::HandleReadLinkQualityCompleteEvent(const TReadLinkQualityCompleteEvent& aEvent)

	{

	LOG_FUNC

	TUint8 result = 0;

	TInt err = CHciUtil::SymbianErrorCode(aEvent.ErrorCode());

	if (err == KErrNone)

		{

		result = aEvent.LinkQuality();

		}

	// Notify all SAPs via IoctlComplete, with the result or an error code

	if (err != KErrNone || static_cast<TInt>(result) != iLinkQuality.PLMValue()())

		{

		iLinkQuality.UpdatePLMValue(result);

		// Notify all SAPs via IoctlComplete, with the result or an error code

		iLinkQuality.NotifyQueuedProxySAPs(err, KLMReadLinkQualityIoctl, &iLinkQuality.PLMValue());

		}

	iLinkQuality.UpdatePLMState(ECommandBlockedForTimer);

	QueueNextPLMPollIfNotAlreadyQueued();

	}

void CPhysicalLinkMetrics::HandleReadRssiCompleteEvent(const TReadRSSICompleteEvent& aEvent)

	{

	LOG_FUNC

	TUint8 result = 0;

	TInt err = CHciUtil::SymbianErrorCode(aEvent.ErrorCode());

	if (err == KErrNone)

		{

		result = aEvent.RSSI().RSSI();

		}

	if (err != KErrNone || static_cast<TInt>(result) != iRssi.PLMValue()())

		{

		iRssi.UpdatePLMValue(result);

		// Notify all SAPs via IoctlComplete, with the result or an error code

		iRssi.NotifyQueuedProxySAPs(err, KLMReadRssiIoctl, &iRssi.PLMValue());

		}

	iRssi.UpdatePLMState(ECommandBlockedForTimer);

	QueueNextPLMPollIfNotAlreadyQueued();

	}

void CPhysicalLinkMetrics::HandleReadTransmitPowerLevelCompleteEvent(const TReadTransmitPowerLevelCompleteEvent& aEvent)

	{

	LOG_FUNC

	TUint8 result = 0;

	TInt err = CHciUtil::SymbianErrorCode(aEvent.ErrorCode());

	if (err == KErrNone)

		{

		result = aEvent.TransmitPowerLevel();

		}

	if (err != KErrNone || static_cast<TInt>(result) != iTransmitPowerLevel.PLMValue()())

		{

		iTransmitPowerLevel.UpdatePLMValue(result);

		// Notify all SAPs via IoctlComplete, with the result or an error code

		iTransmitPowerLevel.NotifyQueuedProxySAPs(err, KLMReadCurrentTransmitPowerLevelIoctl, &iTransmitPowerLevel.PLMValue());

		}

	iTransmitPowerLevel.UpdatePLMState(ECommandBlockedForTimer);

	QueueNextPLMPollIfNotAlreadyQueued();

	}

/*static*/ TInt CPhysicalLinkMetrics::PLMEventReceived(TAny* aThis)

	{

	static_cast<CPhysicalLinkMetrics*>(aThis)->iPLMTimerQueued = EFalse;