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

//

/**

 @file

 @internalTechnology

*/

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include "avctpremotedevices.h"

#include "avctpbody.h"

#include "avctpserviceutils.h"

#include "avctpcommon.h"

#include "avctpPriorities.h"

#include "avctpserviceutils.h"

#include "channelcontrollers.h"

using namespace SymbianAvctp;

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVCTP_SERVICES);

#endif

RNestableLock::RNestableLock()

	: iRefCount(0)

	, iThreadId(KInvalidThreadId)	// set to an invalid id

	{

	}

TInt RNestableLock::CreateLocal()

	{

	TInt err = iLock.CreateLocal();

	if(err == KErrNone)

		{

		err = iMetaLock.CreateLocal();

		}

	if(err != KErrNone)

		{

		Close();

		}

	return err;

	}

void RNestableLock::Close()

	{

	iLock.Close();

	iMetaLock.Close();

	iRefCount = 0;

	}

void RNestableLock::Wait()

	{

	iMetaLock.Wait();

	TThreadId currentThreadId = RThread().Id();

	if(iThreadId == TThreadId(KInvalidThreadId) || currentThreadId != iThreadId)

		{

		iMetaLock.Signal();

		iLock.Wait();

		iMetaLock.Wait();

		iThreadId = currentThreadId;

		}

	++iRefCount;

	iMetaLock.Signal();

	}

void RNestableLock::Signal()

	{

	iMetaLock.Wait();

	// Assert if current thread is stored current thread?

	if(--iRefCount == 0)

		{

		iLock.Signal();

		iThreadId = TThreadId(KInvalidThreadId);

		}

	iMetaLock.Signal();

	}

TAvctpRemoteDeviceInfo::TAvctpRemoteDeviceInfo(const TBTDevAddr& aAddr) :

	iAddr(aAddr),

	iHasSecondChannel(EFalse)

	{

	LOG_FUNC

	}

const TBTDevAddr& TAvctpRemoteDeviceInfo::RemoteAddress() const

	{

	LOG_FUNC

	return iAddr;

	}

TBool TAvctpRemoteDeviceInfo::HasSecondChannel() const

	{

	LOG_FUNC

	return iHasSecondChannel;

	}

void TAvctpRemoteDeviceInfo::SetHasSecondChannel(TBool aHasSecondChannel)

	{

	LOG_FUNC

	iHasSecondChannel = aHasSecondChannel;

	}

/**

Two phase constructor of CAvctpRemoteDevices which deals with connection and disconnection 

of a remote device. 

@param aNotify provides access to the MAvctpEventNotify

@param aSocketServ a connected comms session

@internalComponent

*/

CAvctpRemoteDevices* CAvctpRemoteDevices::NewL(MAvctpEventNotify& aNotify, RSocketServ& aSocketServ, SymbianAvctp::TPid aPid)

	{

	LOG_STATIC_FUNC

	CAvctpRemoteDevices* self = CAvctpRemoteDevices::NewLC(aNotify, aSocketServ, aPid);

	CleanupStack::Pop(self);

	return self;

	}

/**

Two phase constructor of CAvctpRemoteDevices which deals with connection and disconnection 

of a remote device. 

This leaves newly created object on cleanupstack

@param aAvctpBody provides access to the MAvctpEventNotify

@param aSocketServ a connected comms session

@internalComponent

*/

CAvctpRemoteDevices* CAvctpRemoteDevices::NewLC(MAvctpEventNotify& aNotify, RSocketServ& aSocketServ, SymbianAvctp::TPid aPid)

	{

	LOG_STATIC_FUNC

	CAvctpRemoteDevices* self = new(ELeave) CAvctpRemoteDevices(aNotify, aSocketServ);

	CleanupStack::PushL(self);

	self->ConstructL(aPid);

	return self;	

	}

/**

c'tor

@internalComponent

*/

CAvctpRemoteDevices::CAvctpRemoteDevices(MAvctpEventNotify& aNotify, RSocketServ& aSocketServ):

 	iNotify(aNotify),

	iSocketServ(aSocketServ)

	{

	LOG_FUNC

	}

/** 

@internalComponent

*/

void CAvctpRemoteDevices::ConstructL(SymbianAvctp::TPid aPid)

	{

	LOG_FUNC

	User::LeaveIfError(iLock.CreateLocal()); 

	iPid = aPid;

	iState = EListening;

	iPrimaryChannelController = CPrimaryChannelController::NewL(*this, iSocketServ, aPid);	

	iPrimaryChannelController->Listen();

	}

/**

d'tor

@internalComponent

*/	

CAvctpRemoteDevices::~CAvctpRemoteDevices()

	{

	LOG_FUNC

	iLock.Wait();

	iLock.Close();

	iRemoteAddrs.Close();

	delete iSecondaryChannelController;

	delete iPrimaryChannelController;

	}

/**

Starts a connection to a remote device

@param aBTDevice the remote device to connect to

@internalComponent

*/

TInt CAvctpRemoteDevices::PrimaryChannelAttachRequest(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	iLock.Wait();

	TInt err = KErrRepeatConnectionAttempt;

	// Start the connection attempt

	if (iState == EListening)

		{

		if (!IsAttached(aBTDevice))

			{

			iState = ECreatingControlLink;

			iPrimaryChannelController->AttachRequest(aBTDevice);

			err = KErrNone;

			}

		}

	if (err != KErrNone)

		{

		iState = EListening;

		}

	iLock.Signal();

	return err;

	}

/**

Called after a Attach Indicate. If the connection hasn't been accepted it send back to the server

a refuse attach ioctl, and the client won't be notified through the controlling channel

@param aBTDevice the remote device to add

@param aClientsAccepts ETrue if the client has accepted the Attach Indication or

					   EFalse if the client has denied the Attach Indication

@param aChannel the controlling channel through the indication has been received

@internalComponent

*/

TInt CAvctpRemoteDevices::PropagateAttachRsp(const TBTDevAddr& aBTDevice, 

							  			      TBool aClientsAccepts,

							  			      TInt aChannel)

	{

	LOG_FUNC

	TInt err = KErrNone;

	if (aClientsAccepts) 

		{

		if (err == KErrNone && !IsAttached(aBTDevice) && aChannel == KAvctpPrimaryChannel)

			{

			//only add device on primary control channel connection

			TAvctpRemoteDeviceInfo info(aBTDevice);

			err = iRemoteAddrs.Append(info);

			}

		}

	else

		{

		__ASSERT_DEBUG(aChannel == KAvctpPrimaryChannel || aChannel == KAvctpSecondaryChannel, Panic(EAvctpInvalidChannel));

		CBaseChController* pointer = (aChannel == KAvctpPrimaryChannel) ? ((CBaseChController*)iPrimaryChannelController) : ((CBaseChController*)iSecondaryChannelController);

		__ASSERT_DEBUG(pointer, Panic(EAvctpNullControllerChannel));

		pointer->RefuseAttach(aBTDevice);	// won't receive a confirmation

		}	

	return err;

	}

/**

Explicitly disconnect from the give remote device.

@internalComponent

*/

TInt CAvctpRemoteDevices::PrimaryChannelDetachRequest(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	iLock.Wait();

	TInt err = KErrFirstChannelNotAttached;

	const TAvctpRemoteDeviceInfo* info = RemoteDeviceInfo(aBTDevice);

	if (info)

		{

		iPrimaryChannelController->DetachRequest(aBTDevice);

		err = KErrNone;

		}

	iLock.Signal();

	// else covered by ret

	return err;

	}

void CAvctpRemoteDevices::PrimaryChannelCancelAttach(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	iLock.Wait();

	if (!IsAttached(aBTDevice) && iState == ECreatingControlLink)

		{

		// the notifications are only propagated if the state is indicating an

		// outstanding request. So, simply changing the state to listening will avoid

		// the notification to be propagated. 

		// We also need to notify the stack that we are not interested so to have a consistent state

		// It is safe to call RefuseAttach that deal with this scenario server side.

		iPrimaryChannelController->RefuseAttach(aBTDevice);

		iState = EListening;	

		}

	iLock.Signal();

	}

TInt CAvctpRemoteDevices::SecondaryChannelAttachRequest(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	iLock.Wait();

	TInt err = KErrFirstChannelNotAttached;

	const TAvctpRemoteDeviceInfo* info = RemoteDeviceInfo(aBTDevice);

	if (info)

		{

		err = KErrRepeatConnectionAttempt;

		if (!info->HasSecondChannel())

			{

			__ASSERT_DEBUG(iSecondaryChannelNotify, Panic(EAvctpSecondChannelNotPresent));

			if (iState == EListening)

				{

				iState = ECreatingSecondLink;

				iSecondaryChannelController->AttachRequest(aBTDevice);

				err = KErrNone;

				}

			}

		}

	iLock.Signal();

	return err;

	}

TInt CAvctpRemoteDevices::SecondaryChannelDetachRequest(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	iLock.Wait();

	TInt err = KErrSecondChannelNotAttached;

	const TAvctpRemoteDeviceInfo* info = RemoteDeviceInfo(aBTDevice);

	if (info)

		{

		if (info->HasSecondChannel())

			{

			__ASSERT_DEBUG(iSecondaryChannelNotify, Panic(EAvctpSecondChannelNotPresent));

			iSecondaryChannelController->DetachRequest(aBTDevice);

			err = KErrNone;

			}

		}

	iLock.Signal();

	return err;

	}

void CAvctpRemoteDevices::SecondaryChannelCancelAttach(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	iLock.Wait();

	if (IsAttached(aBTDevice) && iState == ECreatingSecondLink)

		{

		// the notifications are only propagated if the state is indicating an

		// outstanding request. So, simply changing the state to listening will avoid

		// the notification to be propagated.

		iState = EListening;	

		}

	iLock.Signal();

	}

void CAvctpRemoteDevices::RemoveRemoteDevice(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	__DEBUG_ONLY

		(

		TBuf<KBTAddressLength> address;

		aBTDevice.GetReadable(address);

		)

	LOG1(_L("BT Device 0x%S"), &address);

	TInt index;	  

	for(index= 0; index < iRemoteAddrs.Count(); index++)

		{

		if (iRemoteAddrs[index].RemoteAddress() == aBTDevice)

			{

			iRemoteAddrs.Remove(index);

			break; // since there should only be one remote device per TBTDevAddr

			}

		}

	}

const TAvctpRemoteDeviceInfo* CAvctpRemoteDevices::RemoteDeviceInfo(const TBTDevAddr& aBTDevice) const

	{

	LOG_FUNC

	const TAvctpRemoteDeviceInfo* deviceInfo = NULL;

	TInt index;

	for (index = 0; index < iRemoteAddrs.Count(); index++)

		{

		if (iRemoteAddrs[index].RemoteAddress() == aBTDevice)

			{

			deviceInfo = &iRemoteAddrs[index];

			break; // there should only be one remote device on each TBTDevAddr

			}

		}

	return deviceInfo;

	}

TBool CAvctpRemoteDevices::IsAttached(const TBTDevAddr& aBTDevice) const

	{

	LOG_FUNC

	iLock.Wait();

	TBool ans = RemoteDeviceInfo(aBTDevice) ? ETrue : EFalse;

#ifdef _DEBUG

//	// Check there is only one remote device on this TBTDevAddr in the array

	TInt numDevices = 0;

	TInt index;

	for (index = 0; index < iRemoteAddrs.Count(); index++)

		{

		if (iRemoteAddrs[index].RemoteAddress() == aBTDevice)

			{

			numDevices++;

			}

		}

	__ASSERT_DEBUG(((ans && numDevices == 1) || (!ans && numDevices == 0)), Panic(EAvctpRemoteAddressOccursMultipleTimes));

#endif // _DEBUG

	LOG1(_L("IsAttached() result is: %d"), ans)

	iLock.Signal();

	return ans;

	}

/**

All Errors to do with a remote device will result in a disconnect Ind happening

because all device errors are currently fatal. NB since the actual error doesn't

matter to the client they don't get informed of it.

*/

void CAvctpRemoteDevices::NotifyError(const TBTDevAddr& aBTDevice, TInt aError, TInt aChannel)

	{

	LOG_FUNC

	MAvctpEventNotify* notify = aChannel == KAvctpPrimaryChannel ? &iNotify : iSecondaryChannelNotify; 

	notify->MaenErrorNotify(aBTDevice, aError);	

	// don't do anything here as the client may have closed the RAvctp object after the NotifyError

	}

void CAvctpRemoteDevices::SetSecondaryChannelNotifyL(MAvctpEventNotify* aSecondChannelNotify)

	{

	LOG_FUNC

	iLock.Wait();

	__ASSERT_DEBUG(!aSecondChannelNotify || !iSecondaryChannelNotify, Panic(EAvctpSecondaryChannelNotifyAlreadyAssigned));

	if(aSecondChannelNotify)

		{

		iSecondaryChannelNotify = aSecondChannelNotify;

		iSecondaryChannelController = CSecondaryChannelController::NewL(*this, iSocketServ, iPid);

		iSecondaryChannelController->Listen();

		}

	else

		{

		delete iSecondaryChannelController;

		iSecondaryChannelController = NULL;

		}

	iLock.Signal();

	}

void CAvctpRemoteDevices::PrimaryChannelAttachConfirm(const TBTDevAddr& aAddr, TInt aMtu, TInt aError)

	{

	LOG_FUNC

	iLock.Wait();

	// state must be:

	// ECreatingControlLink because we have requested to be attached.

	// EListening because we had asked to be attached but then we canceled the request.

	__ASSERT_DEBUG(iState == ECreatingControlLink || iState == EListening, Panic(EAvctpInvalidChannelState));

	if (iState == ECreatingControlLink)

		{

		iNotify.MaenAttachConfirm(aAddr, aMtu, aError);

		if (aError == KErrNone && !IsAttached(aAddr))

			{

			TAvctpRemoteDeviceInfo info(aAddr);

			aError = iRemoteAddrs.Append(info);

			}

		}

	iState = EListening;

	iPrimaryChannelController->Listen();

	iLock.Signal();

	}

void CAvctpRemoteDevices::PrimaryChannelAttachIndicate(const TBTDevAddr& aAddr, TInt aMtu)

	{

	LOG_FUNC

	iLock.Wait();

	TBool clientAccepts = EFalse;

	iNotify.MaenAttachIndicate(aAddr, aMtu, clientAccepts);

	TInt err = PropagateAttachRsp(aAddr, clientAccepts, KAvctpPrimaryChannel);

	// we can have an error if the array append fails 

	if (err == KErrNone)

		{

		if (clientAccepts)

			{

			iPrimaryChannelController->AgreeAttachment(aAddr);

			// iSecondaryChannelController->AttachPassively(aAddr);

			}

		}

	else