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

// cptpipsockethandler.cpp

// 

//

/**

 @internalComponent

*/

#include "cptpipsockhandlerbase.h"

#include "cptpipconnection.h"

#include "ptpippanic.h"

const TUint32 KPTPIPHeaderSize = 8;

const TUint KMaxPacketSixe   = 16;

const TUint64 KMaxPTPIPPacketSize = 0x18FF4; // 100 KB - 12

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

/**

Constructor 

*/

CPTPIPSocketHandlerBase::CPTPIPSocketHandlerBase(CPTPIPConnection& aConnection, TPriority priority ) : 

						CActive(priority),

						iChunkStatus(0),

						iSendChunkData(NULL, 0),

						iSendData(NULL, 0),

						iReceiveChunkData(NULL, 0),

						iPTPPacketLength(0),

						iState(EIdle),

						iPacketBuffer(NULL),

						iPacketSizeMax(NULL),

						iReceiveData(NULL, 0),

						iIsFirstChunk(EFalse),

						iPTPPacketLengthReceived(0),

						iReceiveDataCommit(EFalse),

						iSendHeaderData(NULL, 0),

						iPTPIPDataHeader(NULL),

						iConnection(aConnection),

						iReceiveDataSink(NULL),

						iSendDataSource(NULL),

						iCurrentChunkData(NULL,0,0)

	{

	CActiveScheduler::Add(this);

	}

/**

Second phase constructor.

*/

void CPTPIPSocketHandlerBase::ConstructL()

    {

    iPacketSizeMax = KMaxPacketSixe; 

    iPacketBuffer.ReAllocL(iPacketSizeMax);

    iPTPIPDataHeader = CPTPIPDataContainer::NewL();

    }

 /**

 Destructor

 */  

 CPTPIPSocketHandlerBase::~CPTPIPSocketHandlerBase()

 {

    Cancel();

    iPacketBuffer.Close();

    iSocket.Close();

    delete iPTPIPDataHeader;

 }

//

// CActive Functions

//

/**

 This will be called after every chunk is sent or received over the socket. 

*/

void CPTPIPSocketHandlerBase::RunL()

	{

	switch ( DataStreamDirection() )

		{

	case EReceivingState:

        if (iState == EReceiveFastInProgress)

        	{

        	InitiateFirstChunkReceiveL(); 

        	}

        else if (iStatus != KErrNone)

            {

            // Abnormal completion.

            SetState(EReceiveComplete);

            }

        else if (iState != EReceiveComplete)

            {

	        // Update the chunk data length. We use the iReceiveData variable with the socket 

	        // so only its length gets updated on receive. 

	        // However during remaining processing we use iReceiveChunkData, so update its len.

            iReceiveChunkData.SetLength(iReceiveChunkData.Length() + iReceiveData.Length());

            if (iIsFirstChunk)

	            {

	            // process the first chunk.

	            ProcessFirstReceivedChunkL();  

	            }

	        else

		        {

		        ResumeReceiveDataStreamL(); 

		        }

            }

        if (iState == EReceiveComplete)

            {             

            // Save the pointer to the last populated location on the current chunk            

            iCurrentChunkData.Set(iReceiveChunkData);             

            // Reset the receive data stream and notify the connection.

            MMTPType& data(*iReceiveDataSink);

            ResetReceiveDataStream();

            TRAPD(err, ReceiveDataCompleteL(iStatus.Int(), data));

            if (err != KErrNone)

            	{

            	ReceiveDataCompleteL(err, data);

            	}

            }

        break;

	case ESendingState:

		// Special case for handling the sending of init ack, handled in the derived class.

		if (HandleInitAck())

			{

			ResetSendDataStream();

			break;

			}

        if (iStatus != KErrNone)

            {

            // Abnormal completion.

            SetState(ESendComplete);

            }

		else

			{

            ProcessSendDataL(); 

            }

         if (iState == ESendComplete)

            {

            // Reset the send data stream and notify the connection.

            const MMTPType& data(*iSendDataSource);

            ResetSendDataStream();

            TRAPD(err, SendDataCompleteL(iStatus.Int(), data));

            if (err != KErrNone)

            	{

            	SendDataCompleteL(err, data);

            	}

            }

        break;

	case ESendDataState:

		if (iStatus != KErrNone)

            {

            // Abnormal completion.

            SetState(ESendDataComplete);

            }

 		else if (iState == ESendingDataHeader)

			{

			SetState(ESendingDataPacket);	

			}

		else if (iState == ESendingDataPacket)

			{

			SetState(ESendingDataHeader);		

			}

		else if (iState == ESendDataPacketCompleting)

			{

			SetState(ESendDataComplete);	

			}

		if (iState == ESendDataComplete || iState == ESendDataCancelled)

            {

            // Reset the send data stream and notify the connection.

            const MMTPType& data(*iSendDataSource);

            ResetSendDataStream();

            SendDataCompleteL(iStatus.Int(), data);

            }

   		else

	        {

	        CreateAndSendDataPacketsL();	

	        }

		break;

	default:

        Panic(EPTPIPBadState);

		break;

		}// switch

	}

/**

Tell the Asynchronous Service provider to cancel all outstanding operations. 

*/

void CPTPIPSocketHandlerBase::DoCancel()

	{

    switch (iState & EStateDirection)

        {

    case EReceivingState:

        iSocket.CancelRecv();

        ResetReceiveDataStream();

        break;

    case ESendingState:    

        iSocket.CancelSend();

        ResetSendDataStream();

        break;

    case ESendDataState:

	    iSocket.CancelSend();

	    ResetSendDataStream();

	    break;

    default:

        break;

		}

	}

/**

This is invoked when a panic occurs during RunL. 

To handle this , all operations are cancelled, and if we were processing

a send or recv operation, we complete it with the error code. 

@param - The error code with which RunL left

*/

TInt CPTPIPSocketHandlerBase::RunError(TInt aError)

	{

    // Cancel any outstanding request.

    Cancel();  

    // Notify the protocol layer of the error.

    TInt32 streamDirection = DataStreamDirection();

    if (streamDirection == EReceivingState)

	    {

        // Notify the connection and reset the receive data stream.

        MMTPType& data(*iReceiveDataSink);

        ResetReceiveDataStream();

        TRAPD(err, ReceiveDataCompleteL(aError, data));

        UNUSED_VAR(err);

	    }

	else if (streamDirection == ESendingState || (streamDirection == ESendDataState))

		{

        // Notify the connection and reset the send data stream.

        const MMTPType& data(*iSendDataSource);

        ResetSendDataStream();

        TRAPD(err, SendDataCompleteL(aError, data));

        UNUSED_VAR(err);

		}

    // We are neither in sending nor receiving state, the error in RunL

    // must have originated from the MTP framework, tell the connection 

    // to stop.

	else 

		{

		Connection().HandleError(aError);

		}

	return KErrNone;

	}

//

// Send Data Functions

//

/**

This sends the data over the socket. The buffer is provided by the MTP fw.

@param aData - The data buffer to be sent

@param aTransactionId - The id of the current onging transaction. This is needed 

 in case the data in R to I phase has to be split into multiple PTPIP data packets

 In such a case the PTPIP Data packet header needs to be created which contains the tran id. 

*/

void CPTPIPSocketHandlerBase::SendDataL(const MMTPType& aData, TUint32 aTransactionId )

	{

    iSendDataSource = &aData;

	TUint64 size = iSendDataSource->Size();

	// if the data is less than KMaxPTPIPPacketSize then it can be sent in a shot, 

	// Currently the ptp ip packet has the end data packet already, so it can be sent directly. 

	if ( size < KMaxPTPIPPacketSize)

		{

	    SetState(ESendInitialising);

		ProcessSendDataL();

		}

	// if the data is greater than KMaxPTPIPPacketSize then it needs to be split into 

	// multiple packets. The PTPIP header will be locally created , and sent

	// and then one chunk will be sent as one PTPIP packet.

	else 

		{

		iPTPIPDataHeader->SetUint32L(CPTPIPDataContainer::ETransactionId, aTransactionId);

		iPTPIPDataHeader->SetPayloadL(NULL);

		// We can ignore this header, since we create our own while sending each packet.

		iChunkStatus = iSendDataSource->FirstReadChunk(iSendChunkData);

		SetState(ESendingDataHeader);

		CreateAndSendDataPacketsL();

		}

	}

/**

Using the same algo as the USB send, to buffer into a local buffer, and sending 

only when buffer exceeds the max socket send size, or all chunks have been buffered. 

*/

void CPTPIPSocketHandlerBase::ProcessSendDataL()

	{

    iSendData.Set(KNullDesC8);

    TUint chunkAvailableLen(iSendChunkData.Length());

    if (!chunkAvailableLen)

        {    

        // Fetch the next read data chunk. 

        switch (iState)

            {

        case ESendInitialising:

            iChunkStatus = iSendDataSource->FirstReadChunk(iSendChunkData);

            iPacketBuffer.Zero();

            break;

        case ESendInProgress:

            iChunkStatus = iSendDataSource->NextReadChunk(iSendChunkData);

            break;

        case ESendCompleting:

            break;            

        case EIdle:

        default:

            Panic(EPTPIPBadState);

            break;

            }

        // Fetch the new chunk data size available.

        chunkAvailableLen = iSendChunkData.Length();

        // Update data stream state.

        switch (iChunkStatus)

            {

        case KErrNone:

            SetState(ESendInProgress);

            break;

        case KMTPChunkSequenceCompletion:

            if (iState == ESendCompleting)

                {

                SetState(ESendComplete);

                }

            else

                {

                SetState(ESendCompleting);

                }

            break;

          case KErrNotFound:// CMTPTypeFile returns this when it has zero length

        	if( 0 == iSendChunkData.Length() )

        		{

                if (iState == ESendCompleting)

                {

                SetState(ESendComplete);

                }

            else

                {

                SetState(ESendCompleting);

                }

                }  

                break;

        default:

            break;

            }          

        }

    // Process the buffered residual and/or available chunk data.

    TUint bufferedLen(iPacketBuffer.Length());

    TUint chunkIntegralLen((chunkAvailableLen / iPacketSizeMax) * iPacketSizeMax);

    TUint chunkResidualLen(chunkAvailableLen % iPacketSizeMax);

    if (bufferedLen)

        {

        // Data is buffered in the packet buffer. Fill the available packet buffer space.

        if (chunkAvailableLen)

            {

            // Fill the packet buffer.

            TUint consumedLen(0);

            TUint unconsumedLen(0);

            TUint capacity(iPacketBuffer.MaxLength() - iPacketBuffer.Length());

            if (chunkAvailableLen > capacity)

                {

                consumedLen     = capacity;

                unconsumedLen   = (chunkAvailableLen - consumedLen);              

                }

            else

                {

                consumedLen = chunkAvailableLen;

                }

            iPacketBuffer.Append(iSendChunkData.Left(consumedLen));

            // Update the available chunk data to reflect only the unconsumed portion.

            if (unconsumedLen)

                {

                iSendChunkData.Set(iSendChunkData.Right(unconsumedLen));

                }

            else

                {

                iSendChunkData.Set(NULL, 0);                    

                }

            }