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

#include <bluetooth/logger.h>

#include "l2capSigPacketEcho.h"
#include "l2capSignalHandler.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);
#endif

//                   ECHO REQUEST COMMAND 
//For outgoing echo requests driven by an L2Cap IOCTL

HEchoRequest::HEchoRequest(RMBufChain& aCommand,
		  	               TUint8 aRTXTimerDuration,
	                       TUint16 aERTXTimerDuration)
 : HL2CapCommand(aCommand, aRTXTimerDuration, aERTXTimerDuration),
   iEchoResponseHandler(NULL)
	{
	LOG_FUNC
	}

/*static*/ HEchoRequest* HEchoRequest::New(RMBufChain& aData,
		  	                               TUint8 aRTXTimerDuration,
	                                       TUint16 aERTXTimerDuration)
	{
	LOG_STATIC_FUNC
	HEchoRequest* cmd = NULL;
	RMBufChain buf;
	buf.Assign(aData);
	TRAPD(rerr, buf.PrependL(KEchoRequestEmptyLength));
	
	if(rerr == KErrNone)
		{
		cmd = new HEchoRequest(buf, aRTXTimerDuration, aERTXTimerDuration);
		if(cmd)
			{
			// Setup message contents.
			cmd->SetCode(EEchoRequest);
			cmd->SetID(KUninitialisedID);
			cmd->WriteDataLength();
			}
		else
			{
			// Free the allocated buffer.
			buf.Free();
			}
		}
	return cmd;
	}		

/*static*/ HEchoRequest* HEchoRequest::New(TUint8 aRTXTimerDuration,
	                                       TUint16 aERTXTimerDuration)
	{
	LOG_STATIC_FUNC
	HEchoRequest* cmd = NULL;
	RMBufChain buf;
	TRAPD(rerr, buf.AllocL(KEchoRequestEmptyLength));
	
	if(rerr == KErrNone)
		{
		cmd = new HEchoRequest(buf, aRTXTimerDuration, aERTXTimerDuration);
		if(cmd)
			{
			// Setup message contents.
			cmd->SetCode(EEchoRequest);
			cmd->SetID(KUninitialisedID);
			cmd->WriteDataLength();
			}
		else
			{
			// Free the allocated buffer.
			buf.Free();
			}
		}
	return cmd;
	}	
	
/**
Verifies that the buffer contains a structurally correct command. 
This does not ensure that the content of the command is semantically valid.

@param aCommmand A new HL2CapCommand if the buffer contains a structurally valid command.
@param aBuffer The buffer containing the command
@return KErrNone if the command if created.
		KErrNoMemory if the command structure is valid but cannot be created.
		KErrCorrupt if the command structure is invalid.
*/
TInt HEchoRequest::NewCommandIfValid(RMBufChain& aBuffer, HL2CapCommand*& aCommand)
	{
	LOG_STATIC_FUNC
	// Firstly align the MBufChain.  The maximum size we can align the 
	// MBufChain to is the maximum MBuf size
	__ASSERT_COMPILE(KEchoRequestEmptyLength <= KMBufSmallSize);
	
	// We don't align the data as that way we don't need to worry about it being 
	// larger than one MBuf in size.  It doesn't need to be aligned anyway as the
	// only way the data is accessed is by being copied out.
	TInt length = aBuffer.Length();
	if(length >= KEchoRequestEmptyLength)
		{
		// Don't need to check result as we know that the MBufChain contains
		// at least length bytes as we asked first.
		(void)aBuffer.Align(KEchoRequestEmptyLength);
		aCommand = new HEchoRequest(aBuffer);
		if(aCommand)
			{
			return KErrNone;
			}
		else
			{
			return KErrNoMemory;
			}
		}
	else
		{
		// Dodge length!
		return KErrCorrupt;
		}	
	}
	
HEchoRequest::~HEchoRequest()
	{
	LOG_FUNC
	}

TBool HEchoRequest::ProcessCommand(CL2CapSignalHandler& aSignalHandler)
	{
	LOG_FUNC
	if(aSignalHandler.HandleEchoRequest(this))
		{
		// The command has been handled.  Delete it.
		delete this;
		return ETrue;
		}
	else
		{
		return EFalse;
		}
	}

TInt HEchoRequest::GetData(RMBufChain& aData) const
	{
	LOG_FUNC
	TInt rerr = KErrNone;
	if(DataLength() > KEchoRequestEmptyLength)
		{
		TRAP(rerr, iCommand.CopyL(aData, KEchoRequestEmptyLength));
		}
	else
		{
		rerr = KErrNotFound;
		}
	return rerr;
	}


//					ECHO RESPONSE COMMAND 
//Constructor to deal command coming in from remote side
HEchoResponse::HEchoResponse(RMBufChain& aCommand) 
 : HL2CapCommand(aCommand)
	{
	LOG_FUNC
	}

/*static*/ HEchoResponse* HEchoResponse::New(RMBufChain& aData, TUint8 aId)
	{
	LOG_STATIC_FUNC
	HEchoResponse* cmd = NULL;
	RMBufChain buf;
	buf.Assign(aData);
	TRAPD(rerr, buf.PrependL(KEchoResponseEmptyLength));
	
	if(rerr == KErrNone)
		{
		cmd = new HEchoResponse(buf);
		if(cmd)
			{
			// Setup message contents.
			cmd->SetCode(EEchoResponse);
			cmd->SetID(aId);
			cmd->WriteDataLength();
			}
		else
			{
			// Free the allocated buffer.
			buf.Free();
			}
		}
	return cmd;
	}		

/*static*/ HEchoResponse* HEchoResponse::New(TUint8 aId)
	{
	LOG_STATIC_FUNC
	HEchoResponse* cmd = NULL;
	RMBufChain buf;
	TRAPD(rerr, buf.AllocL(KEchoResponseEmptyLength));
	
	if(rerr == KErrNone)
		{
		cmd = new HEchoResponse(buf);
		if(cmd)
			{
			// Setup message contents.
			cmd->SetCode(EEchoResponse);
			cmd->SetID(aId);
			cmd->WriteDataLength();
			}
		else
			{
			// Free the allocated buffer.
			buf.Free();
			}
		}
	return cmd;
	}		

/**
Verifies that the buffer contains a structurally correct command. 
This does not ensure that the content of the command is semantically valid.

@param aCommmand A new HL2CapCommand if the buffer contains a structurally valid command.
@param aBuffer The buffer containing the command
@return KErrNone if the command if created.
		KErrNoMemory if the command structure is valid but cannot be created.
		KErrCorrupt if the command structure is invalid.
*/
TInt HEchoResponse::NewCommandIfValid(RMBufChain& aBuffer, HL2CapCommand*& aCommand)
	{
	LOG_STATIC_FUNC
	// Firstly align the MBufChain.  The maximum size we can align the 
	// MBufChain to is the maximum MBuf size
	__ASSERT_COMPILE(KEchoResponseEmptyLength <= KMBufSmallSize);
	
	// We don't align the data as that way we don't need to worry about it being 
	// larger than one MBuf in size.  It doesn't need to be aligned anyway as the
	// only way the data is accessed is by being copied out.
	TInt length = aBuffer.Length();
	if(length >= KEchoResponseEmptyLength)
		{
		// Don't need to check result as we know that the MBufChain contains
		// at least length bytes as we asked first.
		(void)aBuffer.Align(KEchoResponseEmptyLength);
		aCommand = new HEchoResponse(aBuffer);
		if(aCommand)
			{
			return KErrNone;
			}
		else
			{
			return KErrNoMemory;
			}
		}
	else
		{
		// Dodge length!
		return KErrCorrupt;
		}	
	}

HEchoResponse::~HEchoResponse()
	{
	LOG_FUNC
	}


TBool HEchoResponse::ProcessCommand(CL2CapSignalHandler& aSignalHandler)	// Handle incoming echo response
	{
	LOG_FUNC
	if(aSignalHandler.HandleEchoResponse(this))
		{
		// The command has been handled.  Delete it.
		delete this;
		return ETrue;
		}
	else
		{
		return EFalse;
		}
	}
	
TInt HEchoResponse::GetData(RMBufChain& aData) const
	{
	LOG_FUNC
	TInt rerr = KErrNone;
	if(DataLength() > KEchoResponseEmptyLength)
		{
		TRAP(rerr, iCommand.CopyL(aData, KEchoResponseEmptyLength));
		}
	else
		{
		rerr = KErrNotFound;
		}
	return rerr;
	}