// Copyright (c) 2008-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:
// ceventhandler.cpp
// 
//

/**
 @internalComponent
*/

#include "cptpipeventhandler.h"
#include "tptpipinitevtack.h"
#include "ptpippanic.h"

__FLOG_STMT(_LIT8(KComponent,"CEventHandler");) 

/**
Creates the channel for commands. The base class constructl is called. 
*/
CPTPIPEventHandler* CPTPIPEventHandler::NewL(CPTPIPConnection& aConnection)
	{
	
	CPTPIPEventHandler* self = new(ELeave) CPTPIPEventHandler(aConnection);
	CleanupStack::PushL(self);
#ifdef __FLOG_ACTIVE    
    self->ConstructL(KComponent);
#else
    self->ConstructL();
#endif
	CleanupStack::Pop();
	return self;
	}

/**
Destructor
*/
CPTPIPEventHandler::~CPTPIPEventHandler()
	{
	__FLOG(_L8("Destructor - Entry"));
	__FLOG(_L8("Destructor - Exit"));
	}

/**
Constructor
*/
CPTPIPEventHandler::CPTPIPEventHandler(CPTPIPConnection& aConnection): 
	CPTPIPSocketHandlerBase(aConnection, CActive::EPriorityUserInput )
	{
	}

/**
Sends the init ack packet, which is created in the connection class. 
@param aEvtAck The packet containing the event acknowledgement to be sent to initiator.
*/
void CPTPIPEventHandler::SendInitAck(CPTPIPGenericContainer* aEvtAck)
	{
	__FLOG(_L8("SendInitAck - Entry"));
	iChunkStatus = aEvtAck->FirstReadChunk(iSendChunkData);
	iSendData.Set(iSendChunkData);
	iSocket.Send(iSendData,0,iStatus);
	SetState(EInitSendInProgress);
	SetActive();
	__FLOG(_L8("SendInitAck - Exit"));
	}

/**
Initiates the sending of the event data over the event channel. The base class
 implements the handling of the socket to send the actual data. 
@param aData The buffer containing the event which is created by the framework to send to the initiator
*/
void CPTPIPEventHandler::SendEventL(const MMTPType& aEvent)
    {
	__FLOG(_L8("SendEventL - Entry"));
	
	// We need to stop listening, and send the event. 
	Cancel();
	
    SendDataL(aEvent, 0);
	__FLOG(_L8("SendEventL - Exit"));
    }

/**
Signals the completion of sending data over the socket, which was started by 
SendEventL. It is called by the base sockethandler and in turn informs the 
connection.
@param aError - The error if any returned by the sockethandler. (KErrNone if no errors)
@param aSource - The event buffer which had been given by the framework to send to initiator.
*/
void CPTPIPEventHandler::SendDataCompleteL(TInt aError, const MMTPType& aSource)
    {
	__FLOG(_L8("SendDataCompleteL - Entry"));
    Connection().SendEventCompleteL(aError, aSource);
	__FLOG(_L8("SendDataCompleteL - Exit"));
    }

/**
Initiates the receiving of the event data on the event channel. 
@param aEvent The buffer containing the event received from the initiator
*/
void CPTPIPEventHandler::ReceiveEventL(MMTPType& aEvent)
    {
	__FLOG(_L8("ReceiveEventL - Entry"));
    ReceiveDataL(aEvent);
	__FLOG(_L8("ReceiveEventL - Exit"));
    }

/**
Marks the completion of receiving data over the event channel, which was started 
by ReceiveEventL. It is called by the base sockethandler and in turn informs the
connection.
@param aError - The error if any returned by the sockethandler. (KErrNone if no errors)
@param aSink - The event buffer in which an event has been received from the initiator
*/
void CPTPIPEventHandler::ReceiveDataCompleteL(TInt aError, MMTPType& aSink)
    {
	__FLOG(_L8("ReceiveDataCompleteL - Entry"));
    Connection().ReceiveEventCompleteL(aError, aSink); 
	__FLOG(_L8("ReceiveDataCompleteL - Exit"));
    }

/**
Parses the PTPIP header, gets and validates that the packet type is correct 
and sets the value of the packet length.
@return Type The PTPIP packet type received ie event or cancel. In case of invalid type, it returns 0
*/   
TInt CPTPIPEventHandler::ParsePTPIPHeaderL()
	{
	__FLOG(_L8("ParsePTPIPHeaderL - Entry"));
	
	TUint32 type = Connection().ValidateAndSetEventPayloadL();
	iPTPPacketLength = Connection().EventContainer()->Uint32L(CPTPIPGenericContainer::EPacketLength);
	
	__FLOG(_L8("ParsePTPIPHeaderL - Exit"));
	return type;
	}

/**
Called during the PTP connection establishment phase to mark the completion 
of sending the init ack to the initiator
@return Flag stating that the ini has been sent successfully.
*/
TBool CPTPIPEventHandler::HandleInitAck()
	{
	__FLOG(_L8("HandleInitAck - Entry"));
	TBool isHandled(EFalse);
	
	if (iState == EInitSendInProgress)
		{
		//Now signal the connection, set its state and set it to active.
		Connection().SetConnectionState(CPTPIPConnection::EInitialisationComplete);
		Connection().CompleteSelf(iStatus.Int());
		iState = EIdle;
		isHandled = ETrue;
		}
	__FLOG(_L8("HandleInitAck - Exit"));
	return isHandled;
	}