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

// BT socket active object helpers

// 

//

#ifndef BTSOCKETHELPERS_H

#define BTSOCKETHELPERS_H

#include <bluetooth/btbaseband.h>

//=============================================================================

//Active Objects

//

//CBluetoothSocket Active Objects...

NONSHARABLE_CLASS(CBTConnecter) : public CActive

	{

public:

	static CBTConnecter* NewL(CBluetoothSocket& aParent);

	void Connect(TBTSockAddr& aSockAddr);

	void Connect(TBTSockAddr& aSockAddr, const TDesC8& aConnectDataOut, TDes8& aConnectDataIn);

	~CBTConnecter();

private:

	CBTConnecter(CBluetoothSocket& aParent);

	void ConstructL();

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

	TInt BasebandAccessor();

	CBluetoothSocket& iParent;

	RBTBaseband iActiveModeRequester;

	};

NONSHARABLE_CLASS(CBTAccepter) : public CActive

	{

public:

	static CBTAccepter* NewL(CBluetoothSocket& aParent, CBluetoothSocket& aBlankSocket);

	void Accept(); 

	void Accept(TDes8& aConnectData); 

	~CBTAccepter();

	void SetActive(){CActive::SetActive();};

private:

	CBTAccepter(CBluetoothSocket& aParent, CBluetoothSocket& aBlankSocket);

	void ConstructL();

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

	void BasebandAccessor();

	CBluetoothSocket& iParent;

	CBluetoothSocket& iBlankSocket;

	};

NONSHARABLE_CLASS(CBTShutdowner) : public CActive

	{

public:

	static CBTShutdowner* NewL(CBluetoothSocket& aParent);

	void Shutdown(RSocket::TShutdown aHow,const TDesC8& aDisconnectDataOut,TDes8& aDisconnectDataIn);

	void Shutdown(RSocket::TShutdown aHow);

	void BasebandShutdown(/*TBTDevAddr aAddr*/);

	~CBTShutdowner();

private:

	CBTShutdowner(CBluetoothSocket& aParent);

	void ConstructL();

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

	CBluetoothSocket& iParent;

	};

NONSHARABLE_CLASS(CBTSender) : public CActive

	{

public:

	static CBTSender* NewL(CBluetoothSocket& aParent);

	~CBTSender();

	void Write(const TDesC8& aDesc);

	void Send(const TDesC8& aDesc,TUint someFlags);

	void Send(const TDesC8& aDesc,TUint someFlags,TSockXfrLength& aLen);

	void SendTo(const TDesC8& aDesc,TSockAddr& aAddr,TUint flags);

	void SendTo(const TDesC8& aDesc,TSockAddr& aAddr,TUint flags,TSockXfrLength& aLen);

private:

	enum TCurrentRequest

		{

		ENone,

		EWrite,

		ESend,

		};

	CBTSender(CBluetoothSocket& aParent);

	void ConstructL();

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

	CBluetoothSocket& iParent;

	TCurrentRequest iCurrentRequest;

	};

NONSHARABLE_CLASS(CBTReceiver) : public CActive

	{

public:

	static CBTReceiver* NewL(CBluetoothSocket& aParent);

	~CBTReceiver();

	void Read(TDes8& aDesc);

	void ReadSCOData(const TDesC8& aSCOData, TUint32 aPreferredPacket);

	void Recv(TDes8& aDesc,TUint flags);

	void Recv(TDes8& aDesc,TUint flags,TSockXfrLength& aLen);

	void RecvOneOrMore(TDes8& aDesc,TUint flags,TSockXfrLength& aLen);

	void RecvFrom(TDes8& aDesc,TSockAddr& aAddr,TUint flags);

	void RecvFrom(TDes8& aDesc,TSockAddr& aAddr,TUint flags,TSockXfrLength& aLen);

private:

	enum TCurrentRequest

		{

		ENone,

		ERead,

		ERecv,

		};

	CBTReceiver(CBluetoothSocket& aParent);

	void ConstructL();

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

	CBluetoothSocket& iParent;

	TCurrentRequest iCurrentRequest;

	};

NONSHARABLE_CLASS(CBTIoctler) : public CActive

	{

public:

	static CBTIoctler* NewL(CBluetoothSocket& aParent);

	~CBTIoctler();

	void Ioctl(TUint aCommand, TDes8* aDesc=NULL, TUint aLevel=KLevelUnspecified);

private:

	CBTIoctler(CBluetoothSocket& aParent);

	void ConstructL();

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

	CBluetoothSocket& iParent;

	};

NONSHARABLE_CLASS(MBTBasebandHandler)

	{

public:

	virtual RBTBaseband& MbbhBTBaseband() = 0;

	virtual void MbbhHandleActivateBasebandEventNotifierCompleteL(TInt aErr, TBTBasebandEventNotification& aEventNotification) = 0;

	virtual TInt MbbhOpen(RSocketServ& aSocketServ, RSocket& aSocket) = 0;

	virtual void MbbhClose() = 0;

	};

NONSHARABLE_CLASS(CBTBasebandChangeEventNotifier) : public CActive

	{

public:

	static CBTBasebandChangeEventNotifier* NewL(MBTBasebandHandler& aUser);

	~CBTBasebandChangeEventNotifier();

	void SetNotifyNextModeChange();

	void SetNotify(TUint32 aNotifications);

private:

	CBTBasebandChangeEventNotifier(MBTBasebandHandler& aUser);

	void ConstructL();

	//void SetNotify(TUint32 aNotifications);

	void RunL();

	TInt RunError(TInt aError);

	void DoCancel();

private:

	MBTBasebandHandler& iUser;

	TUint iCurrentRequest;

	TBTBasebandEvent iEvent;

	};

NONSHARABLE_CLASS(CAutoSniffDelayTimer) : 	public CTimer, 

											public MBTBasebandHandler

/**

	This class provides a timer which when it expires requests Sniff Mode.

**/

	{

public:

	static CAutoSniffDelayTimer* NewL(CBluetoothSocket& aParent, TInt aIdleSecondsBeforeSniffRequest);

	~CAutoSniffDelayTimer();

	void Start();

	void StartActive();

	virtual RBTBaseband& MbbhBTBaseband();

	virtual void MbbhHandleActivateBasebandEventNotifierCompleteL(TInt aErr, TBTBasebandEventNotification& aEventNotification);

	virtual TInt MbbhOpen(RSocketServ& aSocketServ, RSocket& aSocket);

	virtual void MbbhClose();

private:

	CAutoSniffDelayTimer(CBluetoothSocket& aParent, TInt aIdleSecondsBeforeSniffRequest);

	void ConstructL();

	void RunL();

	TInt MakeSniffRequest();

private:

	CBluetoothSocket& 				iParent;

	RBTBaseband 					iBTAutoSniffBaseband;

	CBTBasebandChangeEventNotifier* iBTAutoSniffBasebandChangeEventNotifier;

	TTimeIntervalMicroSeconds32		iAutoSniffDelay;

	TBool							iSniffModeRequested;

	};

NONSHARABLE_CLASS(CBTBasebandManager) : public CBase

/**

	This class manages all basebands in order to keep them in step.

**/

	{

public:

	static CBTBasebandManager* NewL();

	~CBTBasebandManager();

	TInt RegisterBTBaseband(MBTBasebandHandler& aBasebandHandler);

	TInt UnRegisterBTBaseband(MBTBasebandHandler& aBasebandHandler);

	TInt HandleConnectionUp(RSocketServ& aSocketServ, RSocket& aSocket);

	void HandleConnectionDown();

	TBool Connected() const;

private:

	void ConstructL();

	CBTBasebandManager();

	void CloseAllBasebands();

private:

	TBool		 					iConnected;

	RSocketServ*					iSocketServ;

	RSocket*						iSocket;

	// unowned

	RPointerArray<MBTBasebandHandler>	iBasebandHandlers;

	};

NONSHARABLE_CLASS(CBTBasebandChangeEventDelegate) : public CBase, 

													public MBTBasebandHandler

/**

	This class provides CBluetoothSocket a proxy to access virtual functions in MBTBasebandHandler

**/

	{

public:

	static CBTBasebandChangeEventDelegate* NewL(CBluetoothSocket& Parent);

	virtual RBTBaseband& MbbhBTBaseband();

	virtual void MbbhHandleActivateBasebandEventNotifierCompleteL(TInt aErr, TBTBasebandEventNotification& aEventNotification);

	virtual TInt MbbhOpen(RSocketServ& aSocketServ, RSocket& aSocket);

	virtual void MbbhClose();

private:

	CBTBasebandChangeEventDelegate(CBluetoothSocket& Parent);

	void ConstructL();

private:

	CBluetoothSocket& iParent;

	};

#endif