// Copyright (c) 2004-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:
// The base class for L2Cap Commands
// 
//

#ifndef L2CAPCOMMAND_H
#define L2CAPCOMMAND_H

#include <es_mbuf.h>
#include <bt_sock.h>

#include "l2util.h"
#include "l2constants.h"
#include "L2types.h"


class CL2CapSignalHandler;
class CL2CAPMux;

NONSHARABLE_CLASS(HL2CapCommand)
	{
public:
	// Message format lengths and offsets.
	const static TUint8 KCodeOffset					= 0;
	const static TUint8 KIdOffset					= 1;
	const static TUint8 KLengthOffset 				= 2;
	const static TUint8 KL2CapCommandHeaderLength 	= 4;		

	// RTX / ERTX Timer values.
	const static TUint8 KDefaultRTXTimerDuration	= 5;	// Second(s)
	const static TUint8 KDefaultERTXTimerDuration	= 120;	// Second(s)
	const static TUint8 KMinRTXTimerDuration		= 1;
	const static TUint8 KMinERTXTimerDuration		= 60;
	const static TUint8 KMaxRTXTimerDuration		= 60;
	const static TUint16 KMaxERTXTimerDuration		= 300;
	const static TUint8 KNumberOfRetransmissions	= 1;

	// Used to specify that the ID has not been set yet.
	const static TUint8 KUninitialisedID			= 0;

	enum TRTXTimerType
		{
		ERTXTimer,
		EERTXTimer,
		};
			
	static TInt DecodeCommand(RMBufChain& aCommandString, HL2CapCommand*& aCommand);

	virtual ~HL2CapCommand();
	HL2CapCommand(RMBufChain& aCommand, 
	              TUint8 aRTXTimerDuration = KDefaultRTXTimerDuration,
	              TUint16 aERTXTimerDuration = KDefaultERTXTimerDuration);

	// Pure virtual that is used to ensure that derived class have a mechanism to process themselves in
	// signal handler
	virtual	TBool ProcessCommand(CL2CapSignalHandler& aSignalHandler) = 0;

	// This is called to pull an outgoing L2CAP command.  This method will initialise
	// the CID if one has not yet been allocated. 
	TInt GetCommand(CL2CAPMux& aMuxer, RMBufChain& aBuffer);
	
	inline TBool IsRequest() const;

	inline TSignallingCommand Code() const;
	inline void SetCode(TSignallingCommand aCode);
	
	inline TUint8 ID() const;
	inline void SetID(TUint8 aID);

	inline TInt DataLength() const;
	inline void WriteDataLength();

	inline TInt CommandLength() const;

	void StartRTXTimer(TRTXTimerType aType, CL2CapSignalHandler& aSignalHandler);
	static TInt ResponseTimerExpired(TAny* aL2CapCommand);
	
	static void PutLittleEndian32(TUint32 aValue, TInt aOffset, RMBufChain& aCommand);
	static void PutLittleEndian16(TUint16 aValue,TInt aOffset, RMBufChain& aCommand);
	static void PutByte(TUint8 aByte, TInt aOffset, RMBufChain& aCommand);

	static TUint32 GetLittleEndian32(TInt aOffset, const RMBufChain& aCommand);
	static TUint16 GetLittleEndian16(TInt aOffset, const RMBufChain& aCommand);
	static TUint8 GetByte(TInt aOffset, const RMBufChain& aCommand);

	TBool StatefulResponse();
protected:
	// RTx / ERTx Timer methods.
	void CancelResponseTimer();
	void HandleResponseTimerExpiry();
	
//members	
public:
	//Link member so that CCFramePDU can hold a linked list of these commands
	TDblQueLink iLink;

protected:
	RMBufChain iCommand;
	TBool iResponseTimerRunning;
	TDeltaTimerEntry iResponseTimerEntry;
	CL2CapSignalHandler* iResponseSignalHandler;
	TUint8 iRetransmissionCounter;
	
	TUint8 iRTXTimerDuration;
	TUint16 iERTXTimerDuration;
	};


NONSHARABLE_CLASS(HInvalidCommand) : public HL2CapCommand
	{
public:
	HInvalidCommand(RMBufChain& aCommand);
	~HInvalidCommand();

	TBool ProcessCommand(CL2CapSignalHandler& aSignalHandler);
	};


inline TBool HL2CapCommand::IsRequest() const
	{
	// Every request command code has the LSB clear.
	return (!(Code() & 0x01));
	}

inline TSignallingCommand HL2CapCommand::Code() const
	{
	return TSignallingCommand(GetByte(KCodeOffset, iCommand));
	}
	
inline void HL2CapCommand::SetCode(TSignallingCommand aCode)
	{
	PutByte(static_cast<TUint8>(aCode), KCodeOffset, iCommand);
	}

inline TUint8 HL2CapCommand::ID() const
	{
	return GetByte(KIdOffset, iCommand);
	}
	
inline void HL2CapCommand::SetID(TUint8 aID)
	{
	PutByte(aID, KIdOffset, iCommand);
	}
	
inline TInt HL2CapCommand::DataLength() const
	{
	return GetLittleEndian16(KLengthOffset, iCommand);
	}

inline void HL2CapCommand::WriteDataLength()
	{
	PutLittleEndian16(static_cast<TUint16>(iCommand.Length() - KL2CapCommandHeaderLength), KLengthOffset, iCommand);
	}

inline TInt HL2CapCommand::CommandLength() const
	{
	return iCommand.Length();
	}
	

#endif