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

//

#ifndef BTTESTCONSOLE_H_

#define BTTESTCONSOLE_H_

#include <e32std.h>

#include <e32cons.h>

#include <e32base.h>

#include <e32test.h>

#include <es_sock.h>

#include <bttypes.h>

#include <bluetooth/pairing.h> 

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <bthci.h>

#endif

#include <bluetooth/btpowercontrol.h>

#include "BTTestHelpers.h"

const TInt KExplicitActiveMode = 0x123456;

class CBTTestConnection;

class CActiveConsole;

class TBTDevAddr;

class TBTTestBuffer

	{

public:

	enum

		{

		EMaxBufferSize = 20,

		};

	TBTTestBuffer();

	void Reset();

	TInt Length() { return iLength; }

	TBool DecGetValue(TInt64 & aValue);

	TBool HexGetValue(TInt64 & aValue);

	TBool Add(TChar aKey, TInt aMaxLength = EMaxBufferSize);

	TBool AddNumber(TChar aKey, TInt aMaxLength = EMaxBufferSize);

	TBool AddHexNumber(TChar aKey, TInt aMaxLength = EMaxBufferSize);

	void SetValue(TInt64 aValue) { iValue1 = aValue; };

	TInt64 Value() const { return iValue1; };

	void SetValue2(TInt64 aValue) { iValue2 = aValue; };

	TInt64 Value2() const { return iValue2; };

	TChar At(TInt aIndex);

	void RemoveChar();

	void WriteIntToBuffer(TInt64 aValue);

	void WriteTDesC8ToBuffer(const TDesC8& aDes);

	void PrintBuffer(CConsoleBase& aConsole);

private:

	TChar iInputBuffer[20];

	TInt iLength;

	TInt64 iValue1;

	TInt64 iValue2;

	};

class MMenuUser

	{

public:

	virtual TBool ChildMenuClosed() = 0;

	};

class TInputProcessorBase : public MMenuUser

	{

public:

	enum InputState

		{

		EMenuContinue,

		EMenuComplete,

		};

	virtual ~TInputProcessorBase() {};

	static TInt HandleKeyPress(TAny* aInstance);

	TBool MenuClosed();

	TBool ChildMenuClosed();

	virtual TInt ProcessKey(TChar aKey) = 0;

	virtual void ProcessChildMenuClosed() = 0;

	virtual void Draw() = 0;

	TChar GetKey();

	CConsoleBase& iConsole;

protected:

	TInputProcessorBase(MMenuUser& aParent, TCallBack& aCb, CConsoleBase& aConsole);

	MMenuUser& iParent;

	TCallBack& iCb;

	};

class TInputBTConnDetails;

class XInputMainMenu : public TInputProcessorBase

	{

	public:

		enum SubMenus

			{

			ENone,

			EConnect,

			EListen,

			EBAPConnect,

			ESCOConnect,

			EEchoRequest,

			EPacketTypes,

			EL2CapAPIConfig,

			EListEvents,

			EDebugMenu,

			EDataMenu,

			ERFCommMenu,

			EPhysicalLinkMenu,

			EeSCOConnect,

			EHciServer

			};

	XInputMainMenu(CBTTestConsole & aTestConsole, TCallBack & aCb, CConsoleBase & aConsole);

	~XInputMainMenu();

	TInt ProcessKey(TChar aKey);

	void Draw();

	TInt GetSelectedConn() const { return iSelectedConnection; };

	void SetSelectedConn(TInt aConnIx) { iSelectedConnection = aConnIx; };

	TBool SelectConnection(TInt aConnIx);

	void ProcessChildMenuClosed();

private:

	void DeleteSubMenuIfAppropriate();

	TInt ProcessKeyL(TChar aKey);

private:

	CBTTestConsole & iConsoleApp;

	TInt iSelectedConnection;

	SubMenus iCurrentSubMenu;

	TInputProcessorBase* iSubMenu;

	// Pointers to store previous connection details in a (slightly) extensible way.

	// If more are needed then follow the special handling pattern in the destructor

	// and DeleteSubMenuIfAppropriate().

	TInputBTConnDetails* iLastConnectDetails;

	TInputBTConnDetails* iLastLegacyConnectDetails;

	TInputBTConnDetails* iLastListenDetails;

	TInputBTConnDetails* iLastLegacyListenDetails;

	TInputBTConnDetails* iLastBapDetails;

	TInputBTConnDetails* iLastEScoDetails;

	TInputBTConnDetails* iLastScoDetails;

	};

class TInputPacketTypes : public TInputProcessorBase

	{

public:

	TInputPacketTypes(TInputProcessorBase & aParent, TCallBack & aCb, CConsoleBase & aConsole);

	TInt ProcessKey(TChar aKey);

	void ProcessChildMenuClosed() {};

	void Draw();

	TUint16 GetPacketTypes();

private:

	TBool iTypes[6];

	TInt iCurrentType;

	};

class TSubMenu : public TInputProcessorBase

	{

public:

	TSubMenu(TInputProcessorBase& aParent, TCallBack& aCb, CConsoleBase& aConsole);

	void ProcessChildMenuClosed() {};

	TInt ProcessKey(TChar aKey);

	TUint16 GetInfoType() const;

	TUint16 GetBasicValue() const;

	virtual TInt SubMenuProcessKey(TChar aKey) = 0;	

protected:

	enum TSubMenuState

		{

		EBasicMenu,

		EGetBasicValue,

		//Ready to get a choice from user

		EChoiceValue,

		//Get a choice from user

		EGetChoiceValue,

		};

	TUint16 iInfoType;

private:

	TSubMenuState iState;

	TUint16 iValue;

	TBTTestBuffer iBuffer;

	};

class TDataMenu : public TSubMenu

	{

public:

	enum TDataMenuType

		{

		EInvalidDataMenuType,

		ESetIncomingMTU,

		ESetOutgoingMTU,

		ERecvOneShotData,

		ESendOneShotData,

		EDataDlgRecv,

		EDataDlgSend,

		ESendData,

		ERecvData,

		ERecvAnyData,

		ESimultanousSendReceiveData,

		ERecvContinuationData,

		ERTXTimer,

		EERTXTimer,

		EPretendSduQFullOn,

		EPretendSduQFullOff,

		EGetChannelMode,

		EGetLocalPSM

		};

	TDataMenu(TInputProcessorBase& aParent, TCallBack& aCb, CConsoleBase& aConsole);

	TInt SubMenuProcessKey(TChar aKey);

	void Draw();

	};

class TRFCommMenu : public TSubMenu

	{

public:

	enum TRFCommMenuType

		{

		EInvalidRFCommMenuType,

		ERequestRFCommConfChgInd,

		ESetLocalModemStatus,

		};

	TRFCommMenu(TInputProcessorBase& aParent, TCallBack& aCb, CConsoleBase& aConsole);

	TInt SubMenuProcessKey(TChar aKey);

	void Draw();

	};

class TPhysicalLinkMenu : public TSubMenu

	{

public:

	enum TPhysicalLinkMenuType

		{

		EInvalidPhysicalLinkMenuType,

		EActiveRequest,

		ESniffRequest,

		EParkRequest,

		EToggleSniffModeAllowed,

		EToggleParkModeAllowed,

		EToggleHoldModeAllowed,

		ERequestMasterRole,

		ERequestSlaveRole,

		EToggleRoleSwitchAllowed,

		EKillAllLinks,

		EKillLink,

		EGetConnectedLinks,

		EToggleLPMRequestsIfActive,

		EAuthenticationRequest,

		EToggleAutoSniff,

		EExplicitActiveRequest,

		EPhysicalLinkMetricsDisplay,

		EPhysicalLinkMetricsCancel,

		};

	TPhysicalLinkMenu(TInputProcessorBase& aParent, TCallBack& aCb, CConsoleBase& aConsole);

	TInt SubMenuProcessKey(TChar aKey);

	void Draw();

	};

#ifdef _DEBUG

class TDebugMenu : public TSubMenu

	{

public:

	enum TDebugMenuType

		{

		EInvalidDebugType,

		EAllocations,

		ESetPDUTimerCID,

		EGetPDUTimers,

		EGetFlushCounters,

		EIssueManualFlush,

		EGetCurrentDataIndex,

		ECurrentMemoryInfo,

		EDebugMark,

		EDebugMarkEnd,

		EDataPlaneConfig,

		};

	TDebugMenu(TInputProcessorBase& aParent, TCallBack& aCb, CConsoleBase& aConsole);

	TInt SubMenuProcessKey(TChar aKey);

	void Draw();

	};

#endif

class TInputAPIL2CapConfig : public TInputProcessorBase

	{

public:

	TInputAPIL2CapConfig(TInputProcessorBase & aParent, TCallBack & aCb, CConsoleBase & aConsole);

	TInt ProcessKey(TChar aKey);

	void ProcessChildMenuClosed() {};

	void Draw();

	TL2CapConfig& GetL2CapConfig();

private:

	enum TL2CapConfigInputState

		{

		ETransmitMTU,

		ETransmitMinMTU,

		EReceiveMTU,

		EReceiveMinMTU,

		EChannelPriority,

		EChannelReliability,

		EReliabilityTimer,

		ESDUFlushTimer,

		};

	void UpdateReliabilityTimer(TUint16 aTimer);

	void UpdateObsolescenceTimer(TUint16 aTimer);

	TUint8 iInputState;

	TBTTestBuffer iBuffer;

	TL2CapConfig iL2CapConfig;

	};

class TInputListEvents : public TInputProcessorBase

	{

public:

	enum

		{

		EEventsPerPage = 10,

		};

	TInputListEvents(CBTTestConnection & aConn, TInputProcessorBase & aParent, TCallBack & aCb, CConsoleBase & aConsole);

	TInt ProcessKey(TChar aKey);

	void ProcessChildMenuClosed() {};

	void Draw();

	TUint16 GetPacketTypes();

private:

	CBTTestConnection & iConn;

	TInt iCurrentEvent;

	TBool iComplete;

	};

class TInputEchoRequest : public TInputProcessorBase

	{

public:

	TInputEchoRequest(TInputProcessorBase & aParent, TCallBack & aCb, CConsoleBase & aConsole);

	TInt ProcessKey(TChar aKey);

	void ProcessChildMenuClosed() {}

	void Draw();

	TInt GetEchoRequestLength()			{ return iEchoRequestLength; }

private:	

	TInt NextInput();

	TBTTestBuffer iBuffer;	

	TInt iEchoRequestLength;

	};

class TInputBTConnDetails : public TInputProcessorBase

	{

public:

	enum RequiredDetails

		{

		EDone			= 0,

		EPortNumber		= 0x01,

		EProtocol		= 0x02,

		EAddress		= 0x04,

		ESecurity		= 0x08,

		EL2CAPConfig	= 0x10,

		ELegacySecurity	= 0x20,

		EMaxDetails		= 7

		};

	TInputBTConnDetails(TUint aRequiredDetails, TInputProcessorBase & aParent, TCallBack & aCb, CConsoleBase & aConsole, TInputBTConnDetails* aPreviousDetails);

	TInt ProcessKey(TChar aKey);

	void ProcessChildMenuClosed() {}

	void Draw();

	TUint16 GetPort() const				{ return iPort;				};

	TChar GetProtocol() const			{ return iProtocol;			};

	TBTDevAddr& GetAddress()			{ return iAddress;			};

	TBTServiceSecurity& GetSecurity()	{ return iSecurity;			};

	TBool UseDefaultConfig() const		{ return iUseDefaultConfig;	};

private:

	enum TSecuritySetting

		{

		EAuthenticate,

		EAuthorised,

		EEncrypt,

		EDenied,

		EPasskeyMinLength,

		};

	void PrintUserPrompt();

	TInt CollectPortNumber(TChar aKey);

	TInt CollectProtocol(TChar aKey);

	TInt CollectAddress(TChar aKey);

	TInt CollectSecurity(TChar aKey);

	TInt CollectPasskeyMinLength(TChar aKey);

	TInt CollectConfig(TChar aKey);

	TBool UpdateSecurity(TChar aSetting);

	TInt NextInput();

	void SetupAnyPreviousValues();

	TBool HandleBackspace(TChar aKey);

	void ConsoleBackspace(TUint aNumberOfChars);

	TChar GetSecurityDefault();

	void PrintSecurityDefault();

	TBTTestBuffer iBuffer;

	TChar iProtocol;

	TUint16 iPort;

	TBTDevAddr iAddress;

	TBTServiceSecurity iSecurity;

	TBool iUseDefaultConfig;

	TBool iUseLegacySecurity;

	TBool iUsePreviousDetails;

	TChar iPreviousProtocol;

	TUint16 iPreviousPort;

	TBTDevAddr iPreviousAddress;

	TBTServiceSecurity iPreviousSecurity;

	TBool iPreviousUseDefaultConfig;

	TUint iRequiredDetails[EMaxDetails];

	TUint iCurrentDetail;

	TUint iCurrentSecuritySetting;

	};

class THciServerDetails : public TInputProcessorBase

	{

public:

	THciServerDetails(TInputProcessorBase & aParent, TCallBack & aCb, CConsoleBase & aConsole);

	~THciServerDetails();

	TInt ProcessKey(TChar aKey);

	void ProcessChildMenuClosed() {}

	void Draw();

private:

	void FormatVendorCmd(TDes8& aCmd);

private:

	RBTPowerControl iPowerControl;

	RHCIDirectAccess iHCIDirectAccess;

	TBuf8<255> iVendorCommand;

	TInt iMenuPos;

	};

class CBTTestConsole : public CBase, public MMenuUser

	{

public:

	static CBTTestConsole* NewL();

	static CBTTestConsole* NewLC();

	CBTTestConsole();

	virtual ~CBTTestConsole();

	void Start();

	void StartL();

	TBool ChildMenuClosed();

	CBTTestConnection* GetConn(TInt aIndex);

	TInt NewConnection();

	TInt NumberOfConnections();

	TBool IsActiveConnection(TInt aIx);

	TBool ConnInState(TInt aIx, TConnProfile::TConnState aState);

	TBool IsConnSocketBased(TInt aIx);

	void CreatePhyRecord(const TBTDevAddr & aBTAddr);

	TConnProfile* FindPhyRecord(const TBTDevAddr & aBTAddr);

	void Draw();

	void DrawAddress();

	void DrawConnections();

	void DrawConnection(TInt aIx);

	TBool ProcessKey();

	// MAIN MENU METHODS

	TInt Connect(TBTDevAddr aAddr, TUint16 aPort, TChar aProtocol, TBTServiceSecurity & aSecurity, TBool aUseDefaultConfig);

	TInt BAPConnect(TBTDevAddr aAddr);

	TInt Listen(TUint16 aPort, TChar aProtocol, TBTServiceSecurity & aSecurity, TBool aUseDefaultConfig);

	TInt Accept(TInt aConnIx);

	TInt SendEchoRequest(TInt aPayloadSize);

	TInt ChangePacketTypes(TUint16 aPacketTypes);

	TInt AllowEDRPackets(TBool aEnable);

	TInt SetL2CapAPIConfig(TL2CapConfig& aL2CapAPIConfig);

	TL2CapConfig& L2CapAPIConfig();

	TInt ConfigureLink(TBool aUseIoctl);

	TInt SetEncryption(TBool aOn);

	TInt Authenticate();