// 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 the helper active objects that talk to AVDTP

// 

//

/**

 @publishedPartner

*/

#include "gavdpInternal.h"

#include "gavdpinterface.h"

/**

The default helper has EPriorityStandard.  Some of the derived helpers

will set their priority to something different when running.  This enables

enforcement of orderings, as because both a helper and an indication may

have an outstanding completion we need to ensure that these are scheduled

in the order that will cause the notifications to the client in the correct

order.

An example of this:

AVDTP recieves an Open, which it indicates to GAVDP.  

On receipt of the Open GAVDP will issue socket connects.

AVDTP completes the socket connects.

AVDTP receives an incoming Start and issues a Start indication to GAVDP by Ioctl completion.

GAVDP now has two outstanding completed requests: 

	- the Start indication (leading to GAVDP_StartIndication).

	- the UPlaneConnect completion (leading to GAVDP_BearerReady).

Unless we ensure that the connect is processed before the start, the client

may receive the start indication before it has sockets available.

*/

CGavdpHelper::CGavdpHelper(CGavdp& aGavdp, MGavdpUser& aUser)

: CActive(EPriorityStandard),

  iGavdp(&aGavdp),

  iUser(aUser)

	{

	CActiveScheduler::Add(this);

	}

TInt CGavdpHelper::RunError(TInt aError)

	{

	RDebug::Print(_L("GAVDP::RunError %d"), aError);

	if (iGavdp)

		{	

		Gavdp().ServiceComplete(aError);

		}

	User().GAVDP_Error(aError, KNullDesC8); // helpers with extended error can't use this path

	//delete this whether or not we know about our CGavdp owner:

	//if we do - it will no longer know about us (see CGavdp::ServiceComplete)

	//if we don't - it will have detached from us earlier and expect us to

	//clean ourselves up

	delete this;

	return KErrNone;

	}	

void CGavdpHelper::CheckFailedL()

	{

	// if failed, leave and tell Gavdp service is complete

	User::LeaveIfError(iStatus.Int());

	}

/**

Called by helpers to inform GAVDP they no-longer need its services, but still have

calls to make to the User

The helper will be detached from GAVDP, and upon completion of their duties they should

delete themselves

This enables GAVDP to do more for the client while the helper carries on

**/

void CGavdpHelper::DetachFromGavdp(TInt aError)

	{

	Gavdp().ServiceComplete(aError);

	iGavdp = NULL;

	}

inline MGavdpUser& CGavdpHelper::User()

	{

	return iUser;

	}

CGavdpDiscover* CGavdpDiscover::NewL(CGavdp& aGavdp, MGavdpUser& aUser)

	{

	return new (ELeave) CGavdpDiscover(aGavdp, aUser);

	}

CGavdpDiscover::CGavdpDiscover(CGavdp& aGavdp, MGavdpUser& aUser)

: CGavdpHelper(aGavdp, aUser)

	{

	}

CGavdpDiscover::~CGavdpDiscover()

	{

	Cancel();

	}

void CGavdpDiscover::DoCancel()

	{

	AvdtpRequester().CancelAll();

	}

void CGavdpDiscover::RunL()

	{

	CheckFailedL();

	// found n SEPs - create a buffer into which to place the details

	// short circuit this if zero SEPs found

	User::LeaveIfError(iConfirm().iResult);

	DetachFromGavdp(KErrNone);

	TFixedArray<TAvdtpSEPInfo, KMaxAvdtpNumSEPs>& sepInfos = iConfirm().iDiscoveredSEPs();

	for (TInt i=0;i<=iConfirm().iNumSEPs-1;i++)

		{

		const TAvdtpSEPInfo info = sepInfos[i];

		User().GAVDP_SEPDiscovered(info);

		}

	User().GAVDP_SEPDiscoveryComplete();

	delete this;

	}

void CGavdpDiscover::Begin()

	{

	AvdtpRequester().Ioctl(EDiscoverSEPs, iStatus, &iConfirm, KSolBtAVDTPSignalling);

	SetActive();	

	}

CGavdpGetCaps* CGavdpGetCaps::NewL(CGavdp& aGavdp,

					  			  MGavdpUser& aUser,

					  			  TSEID aSEID,

					  			  TAvdtpServiceCategories aInterestingCategories)

	{

	CGavdpGetCaps* g = new (ELeave) CGavdpGetCaps(aGavdp, aUser, aSEID, aInterestingCategories);

	CleanupStack::PushL(g);

	g->ConstructL();

	CleanupStack::Pop(g);

	return g;

	}

void CGavdpGetCaps::ConstructL()

	{

	TPckg<TSEID> seidPckg(iSEID);

	iSEPCapBuf = seidPckg.AllocL();

	iSEPCapPtr.Set(iSEPCapBuf->Des());

	}

CGavdpGetCaps::CGavdpGetCaps(CGavdp& aGavdp, MGavdpUser& aUser,

							 TSEID aSEID, TAvdtpServiceCategories aInterestingCategories)

: CGavdpHelper(aGavdp, aUser), iSEPCapPtr(0,0), iSEID(aSEID), iInteresting(aInterestingCategories)

	{

	}

CGavdpGetCaps::~CGavdpGetCaps()

	{

	Cancel();

	delete iSEPCapBuf;

	}

void CGavdpGetCaps::DoCancel()

	{

	AvdtpRequester().CancelAll();

	}

void CGavdpGetCaps::Begin()

	{

	AvdtpRequester().Ioctl(EGetCapabilities, iStatus ,&iSEPCapPtr, KSolBtAVDTPSignalling);

	SetActive();

	}

void CGavdpGetCaps::RunL()

	{

	CheckFailedL();

	// iSEPCapPtr now has mask of capabilities at this point

	TAvdtpServiceCatBitMask sepCapMask = *reinterpret_cast<const TAvdtpServiceCatBitMask*>(iSEPCapPtr.Ptr());

	// don't trouble user with ones they'd ignore anyway

	sepCapMask &= iInteresting();

	if (!sepCapMask)

		{

		// the remote sep has no capabilities the user is interested in

		// tell them NotSupported

		User::Leave(KErrNotSupported);

		}

	for (TInt index=0; index<ENumberOfServiceCategories; index++)

		{

		// go through each bit

		if (sepCapMask & (1<<index)) // test for bit set

			{		

			// it's set - create a buffer big enough to receive the value

			const TAvdtpServiceCategory servcat = static_cast<TAvdtpServiceCategory>(index+1);

			TInt bufsize =0;

			switch (servcat)

				{

				case EServiceCategoryMediaTransport:

					{

					bufsize = sizeof(TAvdtpMediaTransportCapabilities);

					}

					break;

				case EServiceCategoryReporting:

					{

					bufsize = sizeof(TAvdtpReportingCapabilities);

					}

					break;

				case EServiceCategoryRecovery:

					{

					bufsize = sizeof(TAvdtpRecoveryCapabilities);

					}

					break;

				case EServiceCategoryContentProtection:

					{

					bufsize = sizeof(TAvdtpContentProtectionCapabilities);

					}

					break;

				case EServiceCategoryHeaderCompression:

					{

					bufsize = sizeof(TAvdtpHeaderCompressionCapabilities);	

					}

					break;

				case EServiceCategoryMultiplexing:

					{

					bufsize = sizeof(TAvdtpMultiplexingCapability);

					}

					break;

				case EServiceCategoryMediaCodec:

					{

					// to handle an arbitrary codec (different LOSCs)

					// we need to assume largest LOSC.  It's not around

					// for long, so should be ok to make it big.

					bufsize = KUnknownLOSC;

					}

					break;

				}

			if (iSEPCapBuf->Length() < bufsize)

				{

				iSEPCapBuf = iSEPCapBuf->ReAllocL(Max(bufsize, sizeof(TInternalGetSEPCapability)));

				}

			TPckgBuf<TInternalGetSEPCapability> capbuf;

			capbuf().iSEID = iSEID;

			capbuf().iServiceCategory = servcat;

			// send into socket, output will be capability

			iSEPCapPtr.Set(iSEPCapBuf->Des());

			iSEPCapPtr.Copy(capbuf);

			User::LeaveIfError(AvdtpRequester().GetOpt(EGetAVDTPCapabilityResponse, KSolBtAVDTPSignalling, iSEPCapPtr));

			TAvdtpServiceCapability* cap = NULL;

			TRAPD(err, cap = TAvdtpServiceCapability::AllocFromPDUL(servcat, *iSEPCapBuf));

			if (err == KErrNone)

				{

				User().GAVDP_SEPCapability(cap); //ownership transferred!!

				}

			else if (err == KErrNoMemory)

				{

				// Special case OOM conditions to allow the client code to see them.

				// Otherwise the 'assume capability unsupported' block below hides the

				// error.

				User::Leave(err);

				}

			else

				{

				// probably a capability not supported by us, so no point telling user

				// we don't want to leave though - try to process next capability

				}

			}

		}

	DetachFromGavdp(KErrNone);		

	User().GAVDP_SEPCapabilityComplete();

	// in future - should prob go back to scheduler and do one at a time		

	// we've got them all

	delete this;

	}

CGavdpAbort* CGavdpAbort::NewL(CGavdp& aGavdp, MGavdpUser& aUser, TSEID aSEID)

	{

	return new (ELeave) CGavdpAbort(aGavdp, aUser, aSEID);

	}

CGavdpAbort::CGavdpAbort(CGavdp& aGavdp, MGavdpUser& aUser, TSEID aSEID)

: CGavdpHelper(aGavdp, aUser)

	{

	iSEID() = aSEID;

	}

CGavdpAbort::~CGavdpAbort()

	{

	Cancel();

	}

void CGavdpAbort::DoCancel()

	{

	AvdtpRequester().CancelAll();

	}

void CGavdpAbort::Begin()

	{

	SetPriority(EPriorityHigh);

	AvdtpRequester().Ioctl(EAbortStream, iStatus ,&iSEID, KSolBtAVDTPSignalling);

	SetActive();

	}

void CGavdpAbort::RunL()

	{

	CheckFailedL();

	DetachFromGavdp(KErrNone);	

	User().GAVDP_AbortStreamConfirm();

	delete this;

	}

CGavdpStart* CGavdpStart::NewL(CGavdp& aGavdp,

					  		   MGavdpUser& aUser,

					  		   TSEID aSeid)

	{

	return new (ELeave) CGavdpStart(aGavdp, aUser, aSeid);

	}

CGavdpStart::CGavdpStart(CGavdp& aGavdp, MGavdpUser& aUser, TSEID aSeid)

: CGavdpHelper(aGavdp, aUser), iSeidPckg(aSeid)

	{

	}

CGavdpStart::~CGavdpStart()

	{

	Cancel();

	}

void CGavdpStart::DoCancel()

	{

	AvdtpRequester().CancelAll();

	}

void CGavdpStart::Begin()

	{

	AvdtpRequester().Ioctl(EStartStreaming, iStatus, &iSeidPckg, KSolBtAVDTPSignalling);

	SetActive();

	}

void CGavdpStart::RunL()

	{

	// at present since GAVDP only allows one seid to start at a time then there is

	// no need for extended info, AVDTP also makes this assumption

	CheckFailedL();

	DetachFromGavdp(KErrNone);

	User().GAVDP_StartStreamsConfirm();

	delete this;

	}

CGavdpSuspend* CGavdpSuspend::NewL(CGavdp& aGavdp,

					  		   MGavdpUser& aUser,

					  		   TSEID aSeid)

	{

	return new (ELeave) CGavdpSuspend(aGavdp, aUser, aSeid);

	}

CGavdpSuspend::CGavdpSuspend(CGavdp& aGavdp, MGavdpUser& aUser, TSEID aSeid)

: CGavdpHelper(aGavdp, aUser), iSeidPckg(aSeid)

	{

	}

CGavdpSuspend::~CGavdpSuspend()

	{

	Cancel();

	}

void CGavdpSuspend::DoCancel()

	{

	AvdtpRequester().CancelAll();

	}

void CGavdpSuspend::Begin()

	{

	AvdtpRequester().Ioctl(ESuspendStreaming, iStatus, &iSeidPckg, KSolBtAVDTPSignalling);

	SetActive();

	}

void CGavdpSuspend::RunL()

	{

	// at present since GAVDP only allows one seid to suspend at a time then there is

	// no need for extended info, AVDTP also makes this assumption

	CheckFailedL();

	DetachFromGavdp(KErrNone);

	User().GAVDP_SuspendStreamsConfirm();

	delete this;

	}

CGavdpSelectSEP* CGavdpSelectSEP::NewL(CGavdp& aGavdp, MGavdpUser& aUser)

	{

	return new (ELeave) CGavdpSelectSEP(aGavdp, aUser);

	}

CGavdpSelectSEP::CGavdpSelectSEP(CGavdp& aGavdp, MGavdpUser& aUser)

: CGavdpHelper(aGavdp, aUser)

	{

	}

CGavdpSelectSEP::~CGavdpSelectSEP()

	{

	Cancel();

	}

void CGavdpSelectSEP::DoCancel()

	{

	AvdtpRequester().CancelAll();

	}

void CGavdpSelectSEP::Begin()

	{

	AvdtpRequester().Ioctl(ESelectSEP, iStatus, &iRejDataBuf, KSolBtAVDTPSignalling);

	SetActive();

	}

void CGavdpSelectSEP::RunL()

	{

	// if the Ioctl itself failed then we might have an error in the iStatus...

	TInt result = iStatus.Int();

	CheckFailedL();

	DetachFromGavdp(KErrNone);	

	// the ioctl mechanism may have worked but the signalling failed - with extended data...

	result = iRejDataBuf().iError;

	if (result!=KErrNone)

		{

		// the error buffer contains extended failure data

		User().GAVDP_Error(result, iRejDataBuf);

		}

	else

		{

		User().GAVDP_ConfigurationConfirm();

		}

	delete this;

	}

	{

	}

: CGavdpHelper(aGavdp, aUser)

	{

	iSocketAddress.SetBTAddr(aAddr);

	iSocketAddress.SetSession(ESignalling);

	}

CGavdpConnector::~CGavdpConnector()

	{

	Cancel();

	}

void CGavdpConnector::DoCancel()

	{

	}

void CGavdpConnector::Begin()

	{

	// Ensure that once this is completed the RunL is scheduled

	// before handling completion of the indication ioctl.

	SetPriority(EPriorityStandard+1);

	AvdtpRequester().Connect(iSocketAddress, iStatus);

	SetActive();

	}

void CGavdpConnector::RunL()

	{

	// Do not call CGavdpHelper::CheckFailedL() here - avdtp will indicate a failure to connect, 

	// and GAVDP is informed via CGavdpIndicator::RunL().

	TInt error = iStatus.Int();

	DetachFromGavdp(error);	

	if (error == KErrNone)

		{

		User().GAVDP_ConnectConfirm(iSocketAddress.BTAddr());	// reuse the same callback to make life easier for app

		}

	else

		{

		User().GAVDP_Error(error, KNullDesC8);

		}