// 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:

// Implementation of Generic Audio-Video Distribution Profile - GAVDP

// The CGavdp class acts as a "Body" implementation to the RGavdp "Handle"

// 

//

/**

 @publishedPartner

*/

#include "gavdpInternal.h"

CGavdp* CGavdp::NewL(MGavdpUser& aServiceUser, RSocketServ& aSocketServer, RGavdp& aHandle)

	{

#ifndef BLUETOOTH_NO_AV

	CGavdp* gavdp = new(ELeave) CGavdp(aServiceUser, aSocketServer, aHandle);

	CleanupStack::PushL(gavdp);

	gavdp->ConstructL();

	CleanupStack::Pop(gavdp);

	return gavdp;

#else

	User::Leave(KErrNotSupported);

	return NULL; // not reached

#endif

	}

CGavdp::~CGavdp()

	{

	DeAllocSocketsAndHelpers();

	iSocketServer.Close();

	}

void CGavdp::DeAllocSocketsAndHelpers()

	{

	delete iRequesterHelper;

	iRequesterHelper = NULL;

	delete iIndicatorHelper;

	iIndicatorHelper = NULL;

	AvdtpRequester().Close();

	AvdtpIndicator().Close();

	}

void CGavdp::ConstructL()

	{

	User::LeaveIfError(iSocketServer.Connect());

	ConstructSocketsAndHelpersL();

	}

void CGavdp::Cancel()

	{

	if (iRequesterHelper)

		{

		delete iRequesterHelper;

		iRequesterHelper = NULL;

		iState = EIdle;

		// it is the client's job to recover state, so they should send an Abort.

		}

	// leave indications running.

	}

void CGavdp::ConstructSocketsAndHelpersL()

	{

	User::LeaveIfError(AvdtpRequester().Open(iSocketServer, KAVDTPProtocolName));

	// mark as for signalling purposes

	TAvdtpSockAddr addr;

	addr.SetSession(ESignalling);

	User::LeaveIfError(AvdtpRequester().Bind(addr));

	// start reading for AVDTP indications

	User::LeaveIfError(AvdtpIndicator().Open(iSocketServer, KAVDTPProtocolName));

	User::LeaveIfError(AvdtpIndicator().SetOpt(ESetAsSecondarySAP,

								  KSolBtAVDTPInternal,

								  KNullDesC8));

	User::LeaveIfError(AvdtpRequester().SetOpt(EBindToSecondarySAP,

									  KSolBtAVDTPInternal,

									  KNullDesC8));

	iIndicatorHelper = CGavdpIndicator::NewL(*this, iServiceUser);

	iIndicatorHelper->Begin();

	}

CGavdp::CGavdp(MGavdpUser& aServiceUser, RSocketServ& aClientSocketServer, RGavdp& aHandle)

: iClientSocketServer(aClientSocketServer), iServiceUser(aServiceUser), iHandle(aHandle)

	{

	}

void CGavdp::Connect(const TBTDevAddr& aRemoteAddr)

	{

	__ASSERT_ALWAYS((iState == EIdle || iState == EListening), Panic(EGavdpBadState));

	__ASSERT_ALWAYS(iNumSEPsRegistered, Panic(EGavdpSEPMustBeRegisteredBeforeConnect));

	__ASSERT_ALWAYS(aRemoteAddr!=TBTDevAddr(0), Panic(EGavdpBadRemoteAddress));

	__ASSERT_ALWAYS(!iRequesterHelper, Panic(EGavdpBadState));

	AvdtpRequester().SetOpt(EStopAwaitPassiveSignallingChannel, KSolBtAVDTPSignalling, NULL);

	TRAPD(err, iRequesterHelper = CGavdpConnector::NewL(*this, iServiceUser, aRemoteAddr));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iState = EConnecting;

		iRequesterHelper->Begin();	

		}	

	}

void CGavdp::DiscoverRemoteSEPs()

	{

	__ASSERT_ALWAYS(!iRequesterHelper, Panic(EGavdpBadState));

	TRAPD(err, iRequesterHelper = CGavdpDiscover::NewL(*this, iServiceUser));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iRequesterHelper->Begin();	

		}

	}

void CGavdp::GetRemoteSEPCapabilities(TSEID aSEID, const TAvdtpServiceCategories& aInterestingCategories)

	{

	__ASSERT_ALWAYS(!iRequesterHelper /*&& iServiceUser*/, Panic(EGavdpBadState));

	CheckSEID(aSEID);

	TRAPD(err, iRequesterHelper = CGavdpGetCaps::NewL(*this,

											 iServiceUser,

											 aSEID,

											 aInterestingCategories));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iRequesterHelper->Begin();	

		}

	}

TInt CGavdp::BeginConfiguringRemoteSEP(TSEID aRemoteSEID, TSEID aLocalSEID)

	{

	__ASSERT_ALWAYS(iState!=EConfiguringRemoteSEP, Panic(EGavdpBadState));

	CheckSEID(aRemoteSEID);

	CheckSEID(aLocalSEID);

	TInternalSelectRemoteSEP select;

	select.iLocalSEID = aLocalSEID;

	select.iRemoteSEID = aRemoteSEID;

	TPckg<TInternalSelectRemoteSEP> seidpckg(select);

	TInt err = AvdtpRequester().SetOpt(EStartConfiguringRemote, KSolBtAVDTPSignalling, seidpckg);

	if (err==KErrNone)

		{

		iState = EConfiguringRemoteSEP;

		}

	return err;

	}

TInt CGavdp::BeginConfiguringLocalSEP(TSEID aSEID)

	{

	__ASSERT_ALWAYS(iState!=EConfiguringLocalSEP, Panic(EGavdpBadState));

	TPckg<TSEID> seidpckg(aSEID);

	TInt err = AvdtpRequester().SetOpt(EStartConfiguringLocal, KSolBtAVDTPSignalling, seidpckg);

	if (err==KErrNone)

		{

		iState = EConfiguringLocalSEP;

		}

	return err;

	}

TInt CGavdp::AddSEPCapability(const TAvdtpServiceCapability& aCapability)

	{

	__ASSERT_ALWAYS(iState==EConfiguringLocalSEP || iState==EConfiguringRemoteSEP,

																Panic(EGavdpBadState));

	// convert into protocol form - this is a handy way to get a descriptor for IPC purposes

	// if AVDTP requires the reverse operation it is of course allowed to get back to the T class form

	RBuf8 buf;

	TInt err = aCapability.AsProtocol(buf);

	if (err==KErrNone)

		{

		err = AvdtpRequester().SetOpt(EAddCapabilitySelection,KSolBtAVDTPSignalling, buf);

		}

	buf.Close();

	return err; 

	}

void CGavdp::CommitSEPConfiguration()

	{

	__ASSERT_ALWAYS(iState == EConfiguringLocalSEP || iState == EConfiguringRemoteSEP, Panic(EGavdpBadState));

	__ASSERT_ALWAYS(!iRequesterHelper, Panic(EGavdpBadState));

	TRAPD(err, iRequesterHelper = CGavdpSelectSEP::NewL(*this, iServiceUser));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iRequesterHelper->Begin();

		}

	}

void CGavdp::StartStream(TSEID aSEID)

	{

	__ASSERT_ALWAYS(!iRequesterHelper, Panic(EGavdpBadState));

	TRAPD(err, iRequesterHelper = CGavdpStart::NewL(*this, iServiceUser, aSEID));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iRequesterHelper->Begin();	

		}	

	}

void CGavdp::SuspendStream(TSEID aSEID)

	{

	__ASSERT_ALWAYS(!iRequesterHelper, Panic(EGavdpBadState));

	TRAPD(err, iRequesterHelper = CGavdpSuspend::NewL(*this, iServiceUser, aSEID));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iRequesterHelper->Begin();	

		}	

	}

void CGavdp::AbortStream(TSEID aSEID)	

	{

	__ASSERT_ALWAYS(!iRequesterHelper, Panic(EGavdpBadState));

	CheckSEID(aSEID);

	TRAPD(err, iRequesterHelper = CGavdpAbort::NewL(*this, iServiceUser, aSEID));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iRequesterHelper->Begin();	

		}

	}

void CGavdp::SendSecurityControl(TSEID aSEID, const TDesC8& aSecurityData)	

	{

	__ASSERT_ALWAYS(!iRequesterHelper, Panic(EGavdpBadState));

	CheckSEID(aSEID);

	TRAPD(err, iRequesterHelper = CGavdpSecurityControl::NewL(*this, iServiceUser, aSEID, aSecurityData));

	if (err)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	else

		{

		iRequesterHelper->Begin();	

		}

	}

TInt CGavdp::RegisterSEP(TAvdtpSEPInfo& aInfo)

	{

	// note this is a GetOpt - but it also sets:

	// in goes the info, without SEID

	// out comes the same structure with SEID filled in

	TPckg<TAvdtpSEPInfo> sepInfo(aInfo);

	TInt err = AvdtpRequester().GetOpt(ERegisterSEP, KSolBtAVDTPSignalling, sepInfo);

	if (err==KErrNone)

		{

		iNumSEPsRegistered++;

		}

	return err;

	}

/**

Called when gavdp client has registed all seps and is ready

May be short lived as they may try to connect out quickly

*/

TInt CGavdp::Listen()

	{

	__ASSERT_ALWAYS(iNumSEPsRegistered, Panic(EGavdpSEPMustBeRegisteredBeforeListen));

	TInt ret = KErrNone;

	if (iState!=EConnected)

		{

		// start awaiting for signalling channel as as SEP has been successfully registered

		ret = AvdtpRequester().SetOpt(EAwaitPassiveSignallingChannel, KSolBtAVDTPSignalling, NULL);

		if (KErrNone==ret)

			{

			iState = EListening;

			}

		}

	else

		{

		ret = KErrInUse;

		}

	return ret;

	}

// private

void CGavdp::SendResponse( TInternalAvdtpAirIndication aIndication,

						  TInt aResult,

						  const TAny* aResponseData/*=NULL*/,

						  TInt aResponseDataLen/*=0*/)

	{

	TInt err = KErrNone;

	switch (aIndication.iIndication)

		{

		case EAvdtpSetConfiguration:

		case EAvdtpReconfigure:

			{

			TAvdtpInternalConfigurationResponse rsp;

			rsp.iSEID = aIndication.iSEID;

			rsp.iTransactionLabel = aIndication.iTransactionLabel;

			rsp.iResult = aResult;

			rsp.iIsReconfigure = aIndication.iIndication==EAvdtpReconfigure;

			if (aResult!=KErrNone)

				{

				__ASSERT_DEBUG(aResponseData, Panic(EGavdpResponseDataExpected));

				rsp.iCategory = *static_cast<const TAvdtpServiceCategory*>(aResponseData);

				}

			TPckg<TAvdtpInternalConfigurationResponse> pckg(rsp);

			err = AvdtpRequester().SetOpt(ESendConfigurationResponse, KSolBtAVDTPSignalling, pckg);

			break;

			}

		case EAvdtpSecurityControl:

			{

			// optional to send data in response

			TAvdtpInternalSecurityControlResponse rsp;

			rsp.iSEID = aIndication.iSEID;

			rsp.iTransactionLabel = aIndication.iTransactionLabel;

			rsp.iResult = aResult;

			if (aResult==KErrNone)

				{

				rsp.iSecurityControlInfo.Copy(static_cast<const TUint8*>(aResponseData), aResponseDataLen);

				}

			TPckg<TAvdtpInternalSecurityControlResponse> pckg(rsp);			

			err = AvdtpRequester().SetOpt(ESendSecurityControlResponse, KSolBtAVDTPSignalling, pckg);

			break;

			}

		case EAvdtpStart:

			{

			TAvdtpInternalStartResponse rsp;

			rsp.iSEID = aIndication.iSEID;

			rsp.iTransactionLabel = aIndication.iTransactionLabel;

			rsp.iResult = aResult;

			TPckg<TAvdtpInternalStartResponse> pckg(rsp);

			err = AvdtpRequester().SetOpt(ESendStartResponse, KSolBtAVDTPSignalling, pckg);		

			break;

			}

		case EAvdtpSuspend:

			{

			TAvdtpInternalSuspendResponse rsp;

			rsp.iSEID = aIndication.iSEID;

			rsp.iTransactionLabel = aIndication.iTransactionLabel;

			rsp.iResult = aResult;

			TPckg<TAvdtpInternalSuspendResponse> pckg(rsp);

			err = AvdtpRequester().SetOpt(ESendSuspendResponse, KSolBtAVDTPSignalling, pckg);

			break;

			}

		}	

	if (err!=KErrNone)

		{

		iServiceUser.GAVDP_Error(err, KNullDesC8);

		}

	}

void CGavdp::ServiceComplete(TInt aResult)

	{

	__ASSERT_DEBUG(iRequesterHelper, Fault(EGavdpHelperCompletingBadly));

	iRequesterHelper = NULL;

	if (aResult==KErrNone)

		{

		switch (iState)

			{

			case EConfiguringRemoteSEP:

			case EListening:

			case EConnecting:

				iState = EConnected;

				break;

			case EConfiguringLocalSEP:

				{

				iState = EIdle;

				break;

				}

			}

		}

	else

		{

		iState = EIdle; // or perhaps errored? 

		}

	}

void CGavdp::Error(TInt aError)

	{

	delete iRequesterHelper;

	iRequesterHelper = NULL;

	}

void CGavdp::FatalError()

	{

	//Unbind from the body before informing the user

	iHandle.UnbindBody();

	//Now tell the user we are DEAD

	iServiceUser.GAVDP_Error(KErrDied, KNullDesC8);

	//Cleanup: we've unbound from the body, We are no longer owned. Delete ourselves

	delete this;

	}

/*

Forms the binding between passively created signalling and sockets

*/

void CGavdp::BindSignallingL(const TBTDevAddr& aRemoteAddress)

	{

	// use the same helper as if we originated the signalling channel

	if (iRequesterHelper)

		{

		// the client has just issued another command

		// this is likely to be something that renders the connections invalid anyway

		// eg Abort, Config

		User::Leave(KErrInUse);

		}

	iRequesterHelper->Begin();

	}

/*

Forms the binding between passively created transport sessions and sockets

*/

void CGavdp::BindBearersL(TSEID aSEID, TBool aRequireReporting, TBool aRequireRecovery)

	{

	// which bearers? spy on set config to see if rec&rep in use

	// or from the indication?

	//certainly media

	CheckSEID(aSEID);

	TAvdtpSockAddr addr;

	AvdtpRequester().RemoteName(addr);	

	addr.SetSEID(aSEID);

	if (iRequesterHelper)

		{