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

//

/**

 @internalComponent

*/

// System includes

#include "e32base.h"

#include "ptpippanic.h"

#include "e32property.h" 

// MTP includes

#include <mtp/mtpprotocolconstants.h>

#include <mtp/tmtptyperesponse.h>

// Plugin includes

#include "cptpipcommandhandler.h"

#include "cptpipeventhandler.h"

#include "cptpipconnection.h"

// File type constants.

const TInt KMTPNullChunkSize(0x00020000); // 100KB

const TUint32 KPTPIPDataHeaderSize = 12;  // Size of len, type and tran id. 

#define UNUSED_VAR(a) (a) = (a)

/**

 PTPIP device class connection factory method.

 @param aConnectionMgr The MTP connection manager interface.

 @return A pointer to an PTPIP device class connection. Ownership IS transfered.

 @leave One of the system wide error codes, if a processing failure occurs.

 */

CPTPIPConnection* CPTPIPConnection::NewL(MMTPConnectionMgr& aConnectionMgr )

	{

	CPTPIPConnection* self = new(ELeave) CPTPIPConnection(aConnectionMgr);

	CleanupStack::PushL (self );

	self->ConstructL ( );

	CleanupStack::Pop (self );

	return self;

	}

/**

 Destructor

 */

CPTPIPConnection::~CPTPIPConnection( )

	{

	StopConnection ( );

	// Delete all the handlers which will close the sockets.

	delete iCommandHandler;

	delete iEventHandler;

	delete iPTPIPCommandContainer;

	delete iPTPIPDataContainer;

	delete iPTPIPEventContainer;

        if (iProtocolLayer != NULL)

           {

           iProtocolLayer->Unbind(*this);

           }

	iNullBuffer.Close();

	}

/**

 Second phase constructor

 @leave One of the system wide error codes, if a processing failure occurs.

 */

void CPTPIPConnection::ConstructL( )

	{

	// Construct the Command and event handlers

	iCommandHandler = CPTPIPCommandHandler::NewL (*this );

	iEventHandler = CPTPIPEventHandler::NewL (*this );

	iPTPIPCommandContainer = CPTPIPGenericContainer::NewL ( );

	iPTPIPDataContainer = CPTPIPDataContainer::NewL ( );

	iPTPIPEventContainer = CPTPIPGenericContainer::NewL ( );

	// Transfer the sockets

	TransferSocketsL();

	SetConnectionState (EInitialising );

	CompleteSelf (KErrNone );

	}

/**

 Constructor

 */

CPTPIPConnection::CPTPIPConnection(MMTPConnectionMgr& aConnectionMgr ) :

									CActive(EPriorityStandard), 

									iConnectionMgr(&aConnectionMgr)

	{

	CActiveScheduler::Add (this );

	}

//

// MMTPTransportConnection functions

//

/**

 Binds the protocol layer. 

 @param aProtocol - The connectionProtocol provides the SPI or the observer

 for the communication to happen from the transport to the framework. 

 */

void CPTPIPConnection::BindL(MMTPConnectionProtocol& aProtocol )

	{

	iProtocolLayer = &aProtocol;

	}

/**

 Returns the protocol layer.

 @return The SPI or the observer protocol layer

 */

MMTPConnectionProtocol& CPTPIPConnection::BoundProtocolLayer( )

	{

	__ASSERT_ALWAYS(iProtocolLayer, Panic(EPTPIPBadState));

	return *iProtocolLayer;

	}

/**

 Close the connection, stop all data transfer activity and and wait for the host 

 to issue a Device Reset Request.

 */

void CPTPIPConnection::CloseConnection( )

	{

	StopConnection ( );

	}

/**

 A transaction is one set of request, data transfer and response phases. 

 The fw calls this to mark the end of an MTP transaction. 

 */

void CPTPIPConnection::TransactionCompleteL(const TMTPTypeRequest& /*aRequest*/)

	{

	SetTransactionPhase (EIdlePhase );

	// Clear the cancel flag.

	iCancelOnCommandState = ECancelNotReceived;

	iCancelOnEventState = ECancelNotReceived;

	// Again start listening for the command request. 

	InitiateCommandRequestPhaseL( );

	}

/**

 Called by the fw to indicate that protocol layer is not using this transport anymore 

 and so we will not have any callback/SPI funtions to the fw any more

 */

void CPTPIPConnection::Unbind(MMTPConnectionProtocol& /*aProtocol*/)

	{

	__ASSERT_DEBUG(iProtocolLayer, Panic(EPTPIPBadState));

	// Protocol will no longer be bound to the transport

	iProtocolLayer = NULL;

	}

/**

 Not used

 */

TAny* CPTPIPConnection::GetExtendedInterface(TUid /*aInterfaceUid*/)

	{

	return NULL;

	}

/*

 * return PTPIP transport implementation UID

 */

TUint CPTPIPConnection::GetImplementationUid()

    {

    return KMTPPTPIPTransportImplementationUid;

    }

//

// Active Object functions

//

/**

 Used to cancel the outstanding requests, and reset internal states as appropriate. 

 */

void CPTPIPConnection::DoCancel( )

	{

	iCommandHandler->Cancel( );

	iEventHandler->Cancel( );

	SetConnectionState(ECancelled );

	}

/**

The connection behaves as an active object during the PTPIP connection establishment phase.

Subsequently, it behaves as a normal object whose functions are invoked by the MTP framework

or by the SocketHandler on sending/ receiving data. 

Thus the runl is not hit after the initial connection establishment. 

 */

void CPTPIPConnection::RunL( )

	{

	if(iStatus != KErrNone )

		{

		CloseConnection( );

		}

	else 

		{

		switch(iState )

		{

		// ConstructL is complete, 

		// the PTPIP connection establishment will be complete after the init ack is sent.

		case EInitialising:

			SendInitAckL( );

			break;

			// Now the PTPIP connection has been established. 

		case EInitialisationComplete:

			SetConnectionState(EStartListening );

			CompleteSelf(KErrNone );

			break;

			// Start listeing for requests on the 2 channels

		case EStartListening:

			InitiateEventRequestPhaseL( );

			InitiateCommandRequestPhaseL( );

			break;

		default:

			Panic(EPTPIPBadState );

			break;

		}

		}

	}

/**

 Called when an error occurs in the RunL 

 */

TInt CPTPIPConnection::RunError(TInt aError )

	{

	// Cancel all the outstanding requests.

	Cancel( );

	// Stop the connection, if necessary.

	StopConnection( );

	return KErrNone;

	}

//

// Receive data functions

//

/**

 Called internally to recevive the commands over the command channel. 

 This will invoke the command handler 

 to listen on the socket and get the data into the buffers passed. 

 */

void CPTPIPConnection::InitiateCommandRequestPhaseL( )

	{

	// Set current state to request phase

	SetTransactionPhase(ERequestPhase );

	// The PTPIP data buffer is a member of connection.  

	// Since we are expecting a request now, set the payload to request type

	iPTPIPRequestPayload.Reset( );

	iPTPIPCommandContainer->SetPayloadL(&iPTPIPRequestPayload );

	// Call the CommandHandler to get the request in the container

	iCommandHandler->ReceiveCommandRequestL(*iPTPIPCommandContainer );

	}

/** 

 Called to indicate completion of receive of data started by InitiateCommandRequestPhaseL.

 There is no point in reporting the error up to the f/w since no transaction has started.

 USB does nothing at this stage. In PTP , the connection is closed.

 @param aError - The error if any, received from socket.

 */

void CPTPIPConnection::ReceiveCommandCompleteL(TInt aError )

	{

	if(KErrNone != aError )

		{

		CloseConnection( );

		}

	else if(ValidateTransactionPhase(ERequestPhase ) )

		{

		// Request block received.

		TPTPIPTypeRequestPayload* pRequest = static_cast<TPTPIPTypeRequestPayload*>(iPTPIPCommandContainer->Payload());

		TUint16 op(pRequest->Uint16(TPTPIPTypeRequestPayload::EOpCode ));

		TUint32	tran(pRequest->Uint32(TPTPIPTypeRequestPayload::ETransactionId ));

		TUint32 sessionId = KMTPSessionNone;

		// Reset the iMTPRequest.

		iMTPRequest.Reset( );

		// Setup the MTP request dataset buffer. Set Operation Code and TransactionID

		iMTPRequest.SetUint16(TMTPTypeRequest::ERequestOperationCode, op );

		iMTPRequest.SetUint32(TMTPTypeRequest::ERequestTransactionID, tran );

		// Set SessionID.

		if(op == EMTPOpCodeOpenSession )

			{

			}

		else if(op == EMTPOpCodeCloseSession || op == EMTPOpCodeResetDevice )

			{

			// Force CloseSession requests to be processed outside an active session. 

			// ResetDevice currently behaves the same way as CloseSession. 

			iMTPRequest.SetUint32(TMTPTypeRequest::ERequestParameter1,

					iMTPSessionId );

			}

		else

			{

			sessionId = iMTPSessionId;

			}

		iMTPRequest.SetUint32(TMTPTypeRequest::ERequestSessionID,sessionId );

		// Set Parameter 1 .. Parameter 5.

		pRequest->CopyOut(iMTPRequest, TMTPTypeRequest::ERequestParameter1,	TMTPTypeRequest::ERequestParameter5 );

		pRequest->Reset( );

		// Notify the protocol layer.

		BoundProtocolLayer().ReceivedRequestL(iMTPRequest );

		}

	}

/**

 Called to get data over the command channel,( in turn its called by f/ws ReceiveData)

 @param aData - The buffer provided by the F/w in which to receive data.

 */

void CPTPIPConnection::ReceiveCommandDataL(MMTPType& aData )

	{

	iRecvData = 0;

	iTotalRecvData = 0;

	// First we will receive a PTPIP start data packet which is stored in the commandContainer

	iPTPIPCommandContainer->SetPayloadL(&iPTPIPStartDataPayload );

	// The mtp buffer is passed from the framework and will be passed on as the payload.

	// in the next ptpip data packet.

	iPTPIPDataContainer->SetPayloadL(&aData );

	iCommandHandler->ReceiveCommandDataL(*iPTPIPCommandContainer );

	}

/**

 Called to indicate completion of receive of data started by ReceiveCommandDataL.

 Any errors received are sent back up to the framework. 

 */

void CPTPIPConnection::ReceiveCommandDataCompleteL(TInt aError )

	{

	if(ValidateTransactionPhase(EDataIToRPhase ) )

		{

		// Data block received, notify the protocol layer.

		iPTPIPDataContainer->SetUint32L(CPTPIPDataContainer::EPacketType, 0 );

		BoundProtocolLayer().ReceiveDataCompleteL(aError, *iPTPIPDataContainer->Payload(), iMTPRequest );

		}

	}

/**

 Called by the command handler to indicate completion of receive on the command channel.

 Now check whether it was commands or data completion and call the appropriate function. 

 */

void CPTPIPConnection::ReceiveCommandChannelCompleteL(TInt aError, MMTPType& /*aSource*/)

	{

	HandleTCPError(aError );

	TUint32	typeCommand = iPTPIPCommandContainer->Uint32L(CPTPIPGenericContainer::EPacketType );

	TUint32	typeData = iPTPIPDataContainer->Uint32L(CPTPIPGenericContainer::EPacketType );

	switch (typeCommand)

	{

	case EPTPIPPacketTypeOperationRequest:

		ReceiveCommandCompleteL(aError );

		break;

	case EPTPIPPacketTypeStartData:

		if(aError != KErrNone )

			{

			ReceiveCommandCompleteL(aError );

			}

		else

			{

			// Save the total data expected. 

			iTotalRecvData =(static_cast<TPTPIPTypeStartDataPayload*>(iPTPIPCommandContainer->Payload()))->Uint64(TPTPIPTypeStartDataPayload::ETotalSize );

			//reset the command container 

			iPTPIPCommandContainer->SetUint32L(CPTPIPGenericContainer::EPacketType, 0 );

			iCommandHandler->ReceiveCommandDataL(*iPTPIPDataContainer );

			}

		break;

	case EPTPIPPacketTypeCancel:

		{

		TMTPTypeInt32* pTransId;

		pTransId = static_cast<TMTPTypeInt32*>(iPTPIPCommandContainer->Payload());

		iCancelOnCommandState = ECancelCmdReceived;

		HandleCommandCancelL(pTransId->Value());

		}

		break;

	default:

		// No known types came on the command container, now check the data container.

		switch (typeData)

		{

		case EPTPIPPacketTypeData:

			// One PTPIP packet has been received. We will now continue getting the next PTPIP packets. 

			iRecvData += iPTPIPDataContainer->Uint32L(CPTPIPDataContainer::EPacketLength );

			iRecvData -= KPTPIPDataHeaderSize; // The header size is not included in the total size sent. 

			//If more data is expected,then set the flag to use the current offset

			//in the chunk

			if (iRecvData < iTotalRecvData)

			{

			iCommandHandler->iUseOffset = ETrue;	

			}

			if(iRecvData <= iTotalRecvData )

				{

				iCommandHandler->ReceiveCommandDataL(*iPTPIPDataContainer );

				}

			else