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

//

#include "tavsrc.h"

#include "tavsrcUtils.h"

#include "tavsrcSock.h"

#include "tavsrcController.h"

#include "tavsrcStreamer.h"

#include <es_sock.h>

#include <bt_sock.h>

#include <bluetoothav.h>

#include <btsdp.h>

#include <flogger.h>

#include <btmanclient.h>

#include <remconinterfaceselector.h>

#include <remconcoreapitarget.h>

#include <remcontrackinfotarget.h>

#include <remconabsvoltarget.h>

#include <remconmediainformationtargetobserver.h>

#include <remconinterfaceselector.h>

#include <remconaddress.h>

#include <bacline.h> 

#ifdef DBAWARE

#include "tavsrcmtupdaterdatabaseaware.h"

#else

#include "tavsrcmtupdaterdatabaseunaware.h"

#endif

#include "tavsrcAbsoluteVolume.h"

#ifdef __WINS__

static const TSize KMainConsole(75,30);

static const TSize KLogConsole(75,30);

#else

static const TSize KMainConsole(KConsFullScreen,KConsFullScreen);

static const TSize KLogConsole(KConsFullScreen,KConsFullScreen);

#endif

using namespace SymbianBluetoothAV;

using namespace SymbianSBC;

void CAVTestApp::PreventLowPowerModes()

	{

	// Prevent any other application from setting to low power mode

	TInt err = iPhy.PreventLowPowerModes(EAnyLowPowerMode);

	__LOG(_L("Low power mode prevented, result %d\n"), err);

	}

void CAVTestApp::AllowLowPowerModes()

	{

	// Allow any other application to set to low power mode

	TInt err = iPhy.AllowLowPowerModes(EAnyLowPowerMode);

	__LOG(_L("Low power mode allowed, result %d\n"), err);

	}

void CAVTestApp::EchoStorm()

	{

	//UPF test

	//connect phy

	CBluetoothPhysicalLinks* phys = NULL;

	TRAP_IGNORE(phys = CBluetoothPhysicalLinks::NewL(*this, iSockServ));

	if (phys)

		{

		phys->CreateConnection(iDevAddr);

		}

	}

 void CAVTestApp::HandleCreateConnectionCompleteL(TInt /*aErr*/)

 	{

 	TBuf8<32> echo;

 	RSocket sock;

 	sock.Open(iSockServ, _L("L2CAP"));

 	TL2CAPSockAddr addr;

 	addr.SetBTAddr(iDevAddr);

 	addr.SetPort(1);

 	TRequestStatus status;

 	__LOG(_L("Connecting l2cap"));

 	sock.Connect(addr, status);

 	User::WaitForRequest(status);

	echo.SetMax();

	echo.Fill('!');

	__LOG(_L("Echooing"));

	FOREVER

		{

 		sock.Ioctl(KL2CAPEchoRequestIoctl, status, &echo, KSolBtL2CAP);

 		User::WaitForRequest(status);

		}

 	}

void CAVTestApp::HandleDisconnectCompleteL(TInt /*aErr*/)

 	{ 	

 	}

void CAVTestApp::HandleDisconnectAllCompleteL(TInt /*aErr*/)

	{

	}

void CAVTestApp::CreateStreamerL(RSocketArray aSockets)

	{

	__LOG(_L("Creating new streamer\n"));

	iStreamer = CActiveStreamer::NewL(aSockets,iLogConsole->Console(), *this, iDisplayMode, iPreloadFile);

	__LOG(_L("OK\n"));		

	}

void CAVTestApp::Abort()

	{

	__PRINT(_L("\n (!ABORT!) Enter remote SEID to ABORT"));

	TInt seid = TTavsrcUtils::GetIntFromUser(iActiveConsole->Console());

	__PRINT(_L("\n"));

	__LOG(_L("Aborting SEID &d...\n"),seid);

	iGavdp.AbortStream(TSEID(seid, EFalse));	

	}

void CAVTestApp::SendSecurityControl()

	{

	__PRINT(_L("\n Enter remote SEID to Send Security Control"));

	TInt seid = TTavsrcUtils::GetIntFromUser(iActiveConsole->Console());

	__PRINT(_L("\n"));

	__LOG(_L("Sending security control to SEID %d...\n"),seid);

	TBuf8<20> secBuf(_L8("Danger!\n"));

	iGavdp.SendSecurityControl(TSEID(seid, EFalse), secBuf);	

	}

void CAVTestApp::GetCapabilities()

	{

	if (!iLocalReconfigure) // Don't change the remote SEID if we're reconfiguring

		{

		if (iAutoStream)

			{

			// start at first in shortlisted sep array

			iCurrentSEID = iShortlistedSEIDs[0];

			iShortlistedSEIDs.Remove(0); // so next time around, take head again

			}

		else

			{		

			__PRINT(_L("\n Enter remote SEID to get caps for"));		

			iCurrentSEID = TSEID(TTavsrcUtils::GetIntFromUser(iActiveConsole->Console()), EFalse);

			}

		}

	__PRINT(_L("\n"));

	__LOG(_L("Getting Capabilities for SEID %d...\n"),iCurrentSEID.Value());

	iSEPCapabilities.ResetAndDestroy(); //clear what's already there

	// we're interested in all caps as we are *TEST CODE*

	// some GCs should only register interest in the capabilities they might select

	TAvdtpServiceCategories caps;

	caps.SetCapability(EAllServiceCategories);

	iGavdp.GetRemoteSEPCapabilities(iCurrentSEID, caps);

	}

void CAVTestApp::GAVDP_SEPCapability(TAvdtpServiceCapability* aCapability)

	{

	TInt err;

	PrettyPrint(*aCapability);

	// we own cap, stash it in our RPointerArray for owning and later use

	err = iSEPCapabilities.Append(aCapability);

	if(err == KErrNone)

		{

		// check if remote does SBC

		if (aCapability->Category() == EServiceCategoryMediaCodec)

			{

			if (static_cast<TAvdtpMediaCodecCapabilities*>(aCapability)->MediaCodecType() == EAudioCodecSBC)

				{

				iChosenSEP = ETrue;

				__LOG(_L("Found remote suitable SEP with SEID %d\n"), iCurrentSEID.SEID());

				}

			}

		}

	else

		{

		delete aCapability;

		}

	}

void CAVTestApp::GAVDP_SEPDiscoveryComplete()

	{

	// complete the operation

	iOperations->EndOperation(KTavsrcOpDiscoverSEPs, KErrNone);

	__LOG(_L("GAVDP:SEP Discovery complete.\n"));

	if (iAutoStream)

		{

		// go through all the shortlisted SEPs to find the SBC one

		GetCapabilities();

		}

	TestMenu();

	}

void CAVTestApp::GAVDP_SEPCapabilityComplete()

	{

	// complete the operation

	iOperations->EndOperation(KTavsrcOpGetCapabilities, KErrNone);

	__LOG(_L("GAVDP:SEP has no more capabilities.\n"));

	if ((iAutoStream && iChosenSEP) || iLocalReconfigure)

		{

		// configure iCurrentSEID

		TRAPD(err, ConfigureSEPL());

		if (err != KErrNone)

			{

			__LOG(_L("Error configuring remote SEP: %d\n"), err);

			}

		}

	else if (iAutoStream && !iShortlistedSEIDs.Count())

		{

		__LOG(_L("Error: Remote does not have SBC codec available\n"));

		}

	else if (iAutoStream)

		{

		//try next sep

		GetCapabilities();

		}

	TestMenu();

	}

void CAVTestApp::GAVDP_ConnectConfirm(const TBTDevAddr& aAddr)

	{

	// complete the operation

	iOperations->EndOperation(KTavsrcOpConnect, KErrNone);

	// update our tiny state...

	iGavdpState = ESigConnected;	

	// hack :o)

	iDevAddr = aAddr;

	__LOG(_L("Signalling channel connected = GAVDP ready\n"));

	// Open RBTPhysicalLinkAdapter for prevention of low power modes during streaming

	TInt err = iPhy.Open(iSockServ, iDevAddr);

	__LOG(_L("Opened iPhy, result %d\n"), err);

	TestMenu();

	}

void CAVTestApp::GAVDP_SEPDiscovered(const TAvdtpSEPInfo& aSEPInfo)

	{

	// this test code at present doesnt "remember" the SEPs

	switch (aSEPInfo.MediaType())

		{

		case EAvdtpMediaTypeAudio:

			__LOG(_L("Audio"));

			break;

		case EAvdtpMediaTypeVideo:

			__LOG(_L("Video"));

			break;

		case EAvdtpMediaTypeMultimedia:

			__LOG(_L("Multimedia"));

			break;

		}

	if (aSEPInfo.IsSink())

		{

		__LOG(_L(" Sink"));

		}

	else 

		{

		__LOG(_L(" Source"));

		}

	__LOG(_L(" SEP (SEID %d)"), aSEPInfo.SEID().Value());

	if (aSEPInfo.InUse()) 

		{

		__LOG(_L("[In use]"));

		}

	// as we intend streaming audio, we need a free audio sink sep							

	if (aSEPInfo.MediaType()==EAvdtpMediaTypeAudio && aSEPInfo.IsSink() && !aSEPInfo.InUse())

			{

			 __LOG(_L("<-- Shortlisted SEP"));

			(void)iShortlistedSEIDs.Append(aSEPInfo.SEID());

			}

	__LOG(_L("\n"));

	TestMenu();

	}

void CAVTestApp::GAVDP_AbortStreamConfirm()

	{

	// complete the operation

	iOperations->EndOperation(KTavsrcOpAbort, KErrNone);

	__LOG(_L("GAVDP:Aborted\n"));

	delete iStreamer;

	iStreamer = NULL;

	AllowLowPowerModes();

	TestMenu();

	}

void CAVTestApp::GAVDP_SecurityControlConfirm(const TDesC8& aResponseData)

	{

	// complete the operation

	iOperations->EndOperation(KTavsrcOpContentProtection, KErrNone);

	__LOG(_L("GAVDP:Security control complete\n"));

	__LOG(_L("GAVDP:Security control rsp=%S\n"), &aResponseData);

	TestMenu();

	}

void CAVTestApp::GAVDP_StartStreamsConfirm()

	{

	// complete the operation

	iOperations->EndOperation(KTavsrcOpStartStreams, KErrNone);

	__LOG(_L("GAVDP: StartStreamConfirm: now ready for use\n"));

	RThread().SetPriority(EPriorityRealTime);

	if (iLocalReconfigure)

		{

		iStreamer->ReStream();

		iStreamState = EStreaming;

		iOperations->EndOperation(KTavsrcOpStream, KErrNone);

		iLocalReconfigure = EFalse;

		}

	else if (iAutoStream)

		{

		//this maynot be true as SNK can be INT (but tavsrc only looks for remote SNKs)

		iStreamer->Stream(CurrentSEIDIsSink());

		iStreamState = EStreaming;

		iOperations->EndOperation(KTavsrcOpStream, KErrNone);

		}

	iAutoStream = EFalse;	// done

	iLocalReconfigure = EFalse;

	PreventLowPowerModes();

	TestMenu();

	}

void CAVTestApp::GAVDP_SuspendStreamsConfirm()

	{

	// complete the operation

	iOperations->EndOperation(KTavsrcOpSuspendStreams, KErrNone);

	iGavdpState = ESuspended;

	__LOG(_L("Suspending stream!\n"));

	iStreamer->Suspend();

	iStreamState = EPaused;

	// we might be doing a reconfigure due to a request from the streamer

	if (iLocalReconfigure)

		{

		GetCapabilities();

		}

	AllowLowPowerModes();

	TestMenu();

	}

void CAVTestApp::GAVDP_ConfigurationConfirm()

	{ 

	// complete the operation

	if (iRegisteringLocalSEP)

		{

		__LOG(_L("SEP [SEID %d]: Local Configuration complete\n"), iCurrentSEID.SEID());

		iOperations->EndOperation(KTavsrcOpRegisterSEP, KErrNone);

		iRegisteringLocalSEP = EFalse;

		// time to listen now SEP  registered, ignore error, logged in Listen()

		Listen();		

		}

	else

		{

		__LOG(_L("SEP [SEID %d]: Remote Configuration complete\n"), iCurrentSEID.SEID());

		iOperations->EndOperation(KTavsrcOpConfigureSEP, KErrNone);

		// we might be doing a reconfigure due to a request from the streamer	

		if (iLocalReconfigure)

			{

			StartStreams();

			}

		// if we;re doing autoCSR stuff we choose to go straight to open

		else if (iAutoStream)

			{

			CreateBearers();

			}

		}

	TestMenu();

	}

void CAVTestApp::GAVDP_Error(TInt aError, const TDesC8& /*aErrorData*/)

	{

	__LOG(_L("GAVDP: **Error**: %d:\n"), aError);

	// complete the outstanding operation with an error

	iOperations->EndOperation(0, aError);

	switch (aError)

		{

		case KErrAvdtpBaseError-KErrAvdtpRequestTimeout: 

			{

			__LOG(_L("AVDTP Request timed out\n"));

			break;

			}

		case -6305:

		case KErrDisconnected:

			{

			iPhy.Close();

			__LOG(_L("Closed iPhy\n"));

			__LOG(_L("Signalling disconnected\nTest code is going to Re-listen...\n"));

			aError = Listen();

			iAutoStream = EFalse;

			if (iStreamer)

				{

				iStreamer->Stop();

				}

			iStreamState = EStopped;

			// reset the state

			iOperations->EndOperation(KTavsrcOpDisconnectSrc, aError);

			break;

			}

		// Errors we can't match to a specific command

		case EAvdtpBadHeaderFormat:

		case EAvdtpBadLength:

		case EAvdtpBadACPSEID:

		case EAvdtpBadPayloadFormat:

		case EAvdtpNotSupportedCommand:

		case EAvdtpBadState:

			{

			__LOG(_L("Couldn't determine operation that caused error\n"));

			break;

			}

		// Errors on SetConfig/Reconfig

		case EAvdtpSEPInUse:

		case EAvdtpSepNotInUse:

		case EAvdtpBadServCategory:

		case EAvdtpInvalidCapabilities:

		case EAvdtpBadRecoveryType:	

		case EAvdtpBadMediaTransportFormat:	

		case EAvdtpBadReportingFormat:			

		case EAvdtpBadRecoveryFormat:

		case EAvdtpBadRohcFormat:

		case EAvdtpBadCpFormat:

		case EAvdtpBadMultiplexingFormat:

		case EAvdtpUnsupportedConfiguration:	

		case EGavdpBadService:	

		case EGavdpInsufficientResource:

		case EA2dpInvalidCodec:

		case EA2dpNotSupportedCodec:

		case EA2dpInvalidSamplingFrequency:

		case EA2dpNotSupportedSamplingFrequency:

		case EA2dpInvalidChannelMode:

		case EA2dpNotSupportedChannelMode:

		case EA2dpInvalidSubbands:

		case EA2dpNotSupportedSubbands:

		case EA2dpInvalidAllocationMethod:

		case EA2dpNotSupportedAllocationMethod:

		case EA2dpInvalidMinimumBitPoolValue:

		case EA2dpNotSupportedMinimumBitPoolValue:

		case EA2dpInvalidMaximumBitPoolValue:

		case EA2dpNotSupportedMaximumBitPoolValue:

		case EA2dpInvalidLayer:

		case EA2dpNotSupportedLayer:

		case EA2dpNotSupportedCRC:

		case EA2dpNotSupportedMPF:

		case EA2dpNotSupportedVBR:

		case EA2dpInvalidBitRate:

		case EA2dpNotSupportedBitRate:

		case EA2dpInvalidObjectType:

		case EA2dpNotSupportedObjectType:

		case EA2dpInvalidChannels:

		case EA2dpNotSupportedChannels:

		case EA2dpInvalidVersion:

		case EA2dpNotSupportedVersion:

		case EA2dpNotSupportedSUL:

		case EA2dpInvalidBlockLength:

		case EA2dpInvalidCPType:

		case EA2dpInvalidCPFormat:

			{

			__LOG(_L("Error setting configuration\n"));

			break;

			};

		}

	TestMenu();

	}

// passive gubbins

void CAVTestApp::GAVDP_ConfigurationStartIndication(TSEID aLocalSEID, TSEID aRemoteSEID)

	{

	// ah - remote is attempting to confuigure us

	// we need to set our state

	__LOG(_L("Remote SEP [SEID %d] is configuring Local SEP [SEID %d]\n"), aRemoteSEID.Value(), aLocalSEID.Value());