// 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 avdtp logical channel factory

// which creates the logical (L2CAP) channels for transport and signalling channels

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include <bluetoothav.h>

#include "bt.h"

#include "avdtpLogicalChannelFactory.h"

#include "gavdpinterface.h"

#include "avdtputil.h"

#include "avdtp.h"

#include "avdtpDirectChannel.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVDTP);

#endif

CLogicalChannelFactory* CLogicalChannelFactory::NewL(CBluetoothProtocolBase& aProtocol, CProtocolBase& aSAPFactory)

	{

	LOG_STATIC_FUNC

	CLogicalChannelFactory* f = new (ELeave) CLogicalChannelFactory(aProtocol, aSAPFactory);

	CleanupStack::PushL(f);

	f->ConstructL();

	CleanupStack::Pop(f);

	return f;

	}

CLogicalChannelFactory::CLogicalChannelFactory(CBluetoothProtocolBase& aProtocol,

												CProtocolBase& aSAPFactory)

: iProtocol(aProtocol), iBearerSAPFactory(aSAPFactory),

  iUnclaimedLogicalChannels(_FOFF(CManagedLogicalChannel, iFactoryQLink)),

  iPendingActiveJobs(_FOFF(CLogicalChannelFactoryRequest, iFactoryQLink)),

  iPendingPassiveSignallingJobs(_FOFF(CLogicalChannelFactoryRequest, iFactoryQLink)),

  iPendingPassiveSessionJobs(_FOFF(CLogicalChannelFactoryRequest, iFactoryQLink)),

  iCloseChannelJobs(_FOFF(CLogicalChannelFactoryRequest, iFactoryQLink))

	{

	LOG_FUNC

	}

CLogicalChannelFactory::~CLogicalChannelFactory()

	{

	LOG_FUNC

	iProtocol.StopProtocolListening();

	// iterator through jobs and destroy - they'll take down unclaimed channels

	TSglQueIter<CLogicalChannelFactoryActiveRequest> iter(iPendingActiveJobs);

	while (iter)

		{

		delete iter++;

		}

	TSglQueIter<CCloseSessionLogicalChannels> closeIter(iCloseChannelJobs);

	while(closeIter)

		{

		delete closeIter++;

		}

	TDblQueIter<CManagedLogicalChannel> unclaimedChannelsIter(iUnclaimedLogicalChannels);

	while (unclaimedChannelsIter)

		{

		delete unclaimedChannelsIter++;

		}

	// We shouldn't be deleted when we have a job outstanding

	__ASSERT_DEBUG(!iAsyncTryNextJob->IsActive(), Panic(EAvdtpLogicalChannelFactoryDeletionWhileJobPending));

	delete iAsyncTryNextJob;

	delete iCurrentActiveJob;

	}

void CLogicalChannelFactory::ConstructL()

	{

	LOG_FUNC

	TCallBack callback(TryNextJob, this);

	iAsyncTryNextJob = new(ELeave) CAsyncCallBack(callback, CActive::EPriorityStandard);

	}

CCreateSignallingLogicalChannel* CCreateSignallingLogicalChannel::NewLC(const TBTDevAddr& aAddr,

																		XLogicalChannelFactoryClient& aClient,

																		TLogicalChannelFactoryRequestId aId,

																		CLogicalChannelFactory& aLogicalChannelFactory)

	{

	LOG_STATIC_FUNC

	CCreateSignallingLogicalChannel* r = new (ELeave) CCreateSignallingLogicalChannel(aAddr, aClient, aId);

	CleanupStack::PushL(r);

	r->ConstructL(aLogicalChannelFactory); // create the channel holders

	return r;

	}

CCreateSignallingLogicalChannel* CCreateSignallingLogicalChannel::NewL(const TBTDevAddr& aAddr,

																	   XLogicalChannelFactoryClient& aClient,

																	   TLogicalChannelFactoryRequestId aId,

																	   CLogicalChannelFactory& aLogicalChannelFactory)

	{

	LOG_STATIC_FUNC

	CCreateSignallingLogicalChannel* r =

							CCreateSignallingLogicalChannel::NewLC(aAddr,

																   aClient,

																   aId,

																   aLogicalChannelFactory);

	CleanupStack::Pop();

	return r;

	}

void CCreateSignallingLogicalChannel::ConstructL(CLogicalChannelFactory& aLogicalChannelFactory)

	{

	LOG_FUNC

	iLogicalChannels[0] = CManagedLogicalChannel::NewL(aLogicalChannelFactory,

														iRemoteDev,

														KInitialSequenceNumber,

														iId);

	}

CCreateSignallingLogicalChannel::CCreateSignallingLogicalChannel(const TBTDevAddr& aAddr, XLogicalChannelFactoryClient& aClient, TLogicalChannelFactoryRequestId aId)

: CLogicalChannelFactoryActiveRequest(aAddr, aClient, aId)

	{

	LOG_FUNC

	// this job has one channel

	iNumChannelsRequired = 1;

	// so SAP[0] is a signalling SAP

	}

CCreateSessionLogicalChannels* CCreateSessionLogicalChannels::NewLC(const TBTDevAddr& aAddr,

													XLogicalChannelFactoryClient& aClient,

													TLogicalChannelFactoryRequestId aId,

													TInt aNumRequired)

	{

	LOG_STATIC_FUNC

	CCreateSessionLogicalChannels* r =

		new (ELeave) CCreateSessionLogicalChannels(aAddr, aClient, aId, aNumRequired);

	CleanupStack::PushL(r);

	return r;

	}

CCreateSessionLogicalChannels* CCreateSessionLogicalChannels::NewL(const TBTDevAddr& aAddr,

												   XLogicalChannelFactoryClient& aClient,

												   TLogicalChannelFactoryRequestId aId,

												   TInt aNumRequired)

	{

	LOG_STATIC_FUNC

	CCreateSessionLogicalChannels* r = new (ELeave) CCreateSessionLogicalChannels(aAddr,

														aClient,

														aId,

														aNumRequired);

	return r;

	}

CCreateSessionLogicalChannels::CCreateSessionLogicalChannels(const TBTDevAddr& aAddr,

											 XLogicalChannelFactoryClient& aClient,

											 TLogicalChannelFactoryRequestId aId,

											 TInt aNumRequired)

: CLogicalChannelFactoryActiveRequest(aAddr, aClient, aId)

	{

	LOG_FUNC

	// this job has one, two or three channels - but all need to come up for success

	iNumChannelsRequired = aNumRequired;

	}

//************************************************************************

// Close Logical Channels

//************************************************************************

CCloseSessionLogicalChannels* CCloseSessionLogicalChannels::NewL(XLogicalChannelFactoryClient& aClient,

												   TLogicalChannelFactoryRequestId aId)

	{

	LOG_STATIC_FUNC

	CCloseSessionLogicalChannels* r =  CCloseSessionLogicalChannels::NewLC(aClient, aId);

	CleanupStack::Pop(r);

	return r;

	}

CCloseSessionLogicalChannels* CCloseSessionLogicalChannels::NewLC(XLogicalChannelFactoryClient& aClient,

												   TLogicalChannelFactoryRequestId aId)

	{

	LOG_STATIC_FUNC

	CCloseSessionLogicalChannels* r = new (ELeave) CCloseSessionLogicalChannels(aClient,

														aId);

	CleanupStack::PushL(r);

	return r;

	}

CCloseSessionLogicalChannels::~CCloseSessionLogicalChannels()

	{

	LOG_STATIC_FUNC

	BTSocketTimer::Remove(iTimerEntry);

	CloseChannels(EFalse);

	}

/**

One of this job's logical channels has been closed by the remote.  If this

is the final remaining channel the job is completed.

@param aChannel The channel that has been closed.

*/

void CCloseSessionLogicalChannels::ChannelClosed(CManagedLogicalChannel* aChannel)

	{

	LOG_FUNC

	TBool channelsRemaining = EFalse;

	for(TInt i = 0; i < KAvdtpChannelArraySize; i++)

		{

		if(iLogicalChannels[i] == aChannel)

			{

			iLogicalChannels[i] = NULL;

			}

		else if(iLogicalChannels[i])

			{

			channelsRemaining = ETrue;

			}

		}

	aChannel->Shutdown();

	delete aChannel;

	if(!channelsRemaining)

		{

		BTSocketTimer::Remove(iTimerEntry);

		// Notify factory of request completion

		TLogicalChannelFactoryTicket ticket(NULL, iId);

		iClient.LogicalChannelFactoryRequestComplete(ticket, KErrNone);

		}

	}

/**

Begin the job.  

@param aTimeout Number of milliseconds to wait for the remote to close

				the channels before locally initiating the shutdown.

*/

void CCloseSessionLogicalChannels::StartJob(TInt aTimeout)	

	{

	LOG_FUNC

	if(aTimeout)

		{

		TCallBack callBack(WatchdogBarked, this);

		iTimerEntry.Set(callBack);

		BTSocketTimer::Queue(aTimeout, iTimerEntry);

		}

	else

		{

		CloseChannels(ETrue);

		}

	}

/**

Static function called on expiry of channel close watchdog.

*/

TInt CCloseSessionLogicalChannels::WatchdogBarked(TAny* aCloseLogicalChannels)

	{

	LOG_STATIC_FUNC

	static_cast<CCloseSessionLogicalChannels*>(aCloseLogicalChannels)->CloseChannels(ETrue);

	return KErrNone;

	}

/**

Close all remaining channels.  

@param aNotifyCompletion if ETrue then inform client that job is complete

						 if EFalse then silently close remaining channels

*/

void CCloseSessionLogicalChannels::CloseChannels(TBool aNotifyCompletion)

	{

	LOG_FUNC

	for(TInt i = 0; i < KAvdtpChannelArraySize; i++)

		{

		if(iLogicalChannels[i])

			{

			iLogicalChannels[i]->Shutdown();

			delete iLogicalChannels[i];

			iLogicalChannels[i] = NULL;

			}

		}

	if(aNotifyCompletion)

		{

		// Notify factory of request completion

		TLogicalChannelFactoryTicket ticket(NULL, iId);

		iClient.LogicalChannelFactoryRequestComplete(ticket, KErrNone);

		}

	}

/** 

Constructor.

@param aClient Client to be notified on completion of this job. 

@param aId The job id of this job.

*/

CCloseSessionLogicalChannels::CCloseSessionLogicalChannels(XLogicalChannelFactoryClient& aClient,

											 TLogicalChannelFactoryRequestId aId)

: CLogicalChannelFactoryRequest(aClient, aId)

	{

	LOG_FUNC

	}

CLogicalChannelFactoryRequest::CLogicalChannelFactoryRequest(XLogicalChannelFactoryClient& aClient,

															 TLogicalChannelFactoryRequestId aId)

: iClient(aClient), iId(aId)

	{

	LOG_FUNC

	}

CLogicalChannelFactoryPassiveRequest::CLogicalChannelFactoryPassiveRequest(XLogicalChannelFactoryClient& aClient,

    																		  TLogicalChannelFactoryRequestId aId,

    																		  CBluetoothProtocolBase& aAvdtp)

 : CLogicalChannelFactoryRequest(aClient, aId), iAvdtp(aAvdtp)

   	{

   	LOG_FUNC

   	}

CLogicalChannelFactoryPassiveRequest::~CLogicalChannelFactoryPassiveRequest()

 	{

	LOG_FUNC

 	iAvdtp.DecrementListeners();

 	} 

void CLogicalChannelFactoryPassiveRequest::BaseConstructL()

 	{

 	LOG_FUNC

 	User::LeaveIfError(iAvdtp.IncrementListeners());

 	}

CLogicalChannelFactoryActiveRequest::CLogicalChannelFactoryActiveRequest(const TBTDevAddr& aAddr, XLogicalChannelFactoryClient& aClient, TLogicalChannelFactoryRequestId aId)

: CLogicalChannelFactoryRequest(aClient, aId), iRemoteDev(aAddr)

	{

	LOG_FUNC

	}

CExpectSignallingLogicalChannel* CExpectSignallingLogicalChannel::NewL(XLogicalChannelFactoryClient& aClient,

 																	   TLogicalChannelFactoryRequestId aId,

 																	   CBluetoothProtocolBase& aAvdtp)											 

   	{

   	LOG_STATIC_FUNC

 	CExpectSignallingLogicalChannel* req = new (ELeave)CExpectSignallingLogicalChannel(aClient, aId, aAvdtp);

 	CleanupStack::PushL(req);

 	req->ConstructL();

 	CleanupStack::Pop(req);

 	return req;

 	}

void CExpectSignallingLogicalChannel::ConstructL()

 	{

 	LOG_FUNC

	BaseConstructL();

   	}

CExpectSignallingLogicalChannel::CExpectSignallingLogicalChannel(XLogicalChannelFactoryClient& aClient,

 																 TLogicalChannelFactoryRequestId aId,

 																 CBluetoothProtocolBase& aAvdtp)

: CLogicalChannelFactoryPassiveRequest(aClient, aId, aAvdtp)

   	{

   	LOG_FUNC

   	iNumChannelsRequired = 1;

   	}

CExpectSessionLogicalChannels* CExpectSessionLogicalChannels::NewL(XLogicalChannelFactoryClient& aClient,

																   TLogicalChannelFactoryRequestId aId,

										   						   TInt aNumRequired,

										   						   CBluetoothProtocolBase& aAvdtp)

	{

	LOG_STATIC_FUNC

	CExpectSessionLogicalChannels* req = new (ELeave)CExpectSessionLogicalChannels(aClient, aId, aNumRequired, aAvdtp);

	CleanupStack::PushL(req);

	req->ConstructL();

	CleanupStack::Pop(req);

	return req;

	}

void CExpectSessionLogicalChannels::ConstructL()

 	{

 	LOG_FUNC

 	BaseConstructL();

   	}

CExpectSessionLogicalChannels::CExpectSessionLogicalChannels(XLogicalChannelFactoryClient& aClient,

															 TLogicalChannelFactoryRequestId aId,

															 TInt aNumRequired,

															 CBluetoothProtocolBase& aAvdtp)

: CLogicalChannelFactoryPassiveRequest(aClient, aId, aAvdtp)

	{

	LOG_FUNC

	iNumChannelsRequired = aNumRequired;

	}

CLogicalChannelFactoryActiveRequest::~CLogicalChannelFactoryActiveRequest()

	{

	LOG_FUNC

	// clear up any unclaimed stuff - array will be empty if saps claimed

	for (TInt i=0; i<iLogicalChannels.Count(); i++)

		{

		delete iLogicalChannels[i];

		}

	}

void CLogicalChannelFactory::DeleteRequest(CLogicalChannelFactoryRequest *aRequest)

	{

	LOG_FUNC

	iIdManager.FreeId(aRequest->iId);	// free the ID associated with this request

	delete aRequest;

	}

void CLogicalChannelFactory::Cancel(TLogicalChannelFactoryTicket& aJobSpec)

/*

The caller has decided they don't want to have the SAPs

we need to find the job and update it as Cancelled

we MUST then disconnect these channels as the remote entity will

misunderstand what sessions could be running over them

i.e. we cannot keep these SAPs just in case someone else wants them!

*/

	{

	LOG_FUNC

	// only cancel if the job is outstanding

	if (aJobSpec.State()==TLogicalChannelFactoryTicket::ERequestOutstanding)

		{

		TSglQueIter<CLogicalChannelFactoryRequest> iter(iPendingActiveJobs);

		CLogicalChannelFactoryRequest* request = NULL;

		TBool found = EFalse;

		while (iter)

			{

			// try active jobs first

			request = iter++;

			if (request->iId==aJobSpec.iId)

				{

				iPendingActiveJobs.Remove(*static_cast<CLogicalChannelFactoryActiveRequest*>(request));

				DeleteRequest(request);

				found = ETrue;

				}

			}

		if (!found)

			{

			// go through pending *passive signalling* jobs now

			iter = iPendingPassiveSignallingJobs;

			while (iter)

				{

				request = iter++;

				if (request->iId==aJobSpec.iId)

					{

					iPendingPassiveSignallingJobs.Remove(*static_cast<CLogicalChannelFactoryPassiveRequest*>(request));

					DeleteRequest(request);

					found = ETrue;

					}

				}

			}

		if (!found)

			{

			// go through pending *passive session* jobs now

			iter = iPendingPassiveSessionJobs;

			while (iter)

				{

				request = iter++;

				if (request->iId==aJobSpec.iId)

					{

					iPendingPassiveSessionJobs.Remove(*static_cast<CLogicalChannelFactoryPassiveRequest*>(request));

					DeleteRequest(request);

					found = ETrue;

					}

				}

			}

		if (!found)

			{

			// perhaps it's the current one

			if (iCurrentActiveJob && iCurrentActiveJob->iId == aJobSpec.iId)

				{

				iCurrentJobCancelled = ETrue;

				}

			}

		if (found)

			{

			aJobSpec.SetState(TLogicalChannelFactoryTicket::ERequestIdle);

			}

		}

	}

void CLogicalChannelFactory::FreeId(TAny* aFactory)

	{

	LOG_STATIC_FUNC

	CLogicalChannelFactory *fact = static_cast<CLogicalChannelFactory*>(aFactory);

	fact->iIdManager.FreeId(fact->iId);

	}

TLogicalChannelFactoryTicket CLogicalChannelFactory::CreateSignallingLogicalChannelL(const TBTDevAddr& aAddr, XLogicalChannelFactoryClient& aClient)

	{

	LOG_FUNC

	// check that we don't have an inbound one from remote

	// if we have then we just use that unclaimed one

	// if we don't then go and create an outbound one

	TLogicalChannelFactoryRequestId id;

	TLogicalChannelFactoryTicket::TLogicalChannelFactoryRequestState state;

	CManagedLogicalChannel* ch = FindUnclaimedLogicalChannel(aAddr, ESignalling, id);