/*
* Copyright (c) 2010 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:
* implementation for read and write data from share chunk LDD 
*
*/


/**
@internalComponent
*/

#include "ncmcommunicationinterface.h"
#include "ncmengine.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "ncmcomminterfacesenderandreceiverTraces.h"
#endif



// ======== MEMBER FUNCTIONS ========
//

CNcmCommInterfaceSenderAndReceiver::CNcmCommInterfaceSenderAndReceiver(RDevUsbcScClient& aPort, CNcmCommunicationInterface& aComm) 
    : CActive(CActive::EPriorityStandard),
    iPort(aPort),
    iCommInterface(aComm),
    iState(EUnInit)
    {
    CActiveScheduler::Add(this);
    }

CNcmCommInterfaceSenderAndReceiver* CNcmCommInterfaceSenderAndReceiver::NewL(RDevUsbcScClient& aPort, CNcmCommunicationInterface& aComm)
    {
    return new(ELeave) CNcmCommInterfaceSenderAndReceiver(aPort, aComm);
    }

CNcmCommInterfaceSenderAndReceiver::~CNcmCommInterfaceSenderAndReceiver()
    {
    Stop();
    }

void CNcmCommInterfaceSenderAndReceiver::Start()
    {
    OstTraceFunctionEntry1( CNCMCOMMINTERFACESENDERANDRECEIVER_START_ENTRY, this );
    
    TInt ret = iPort.OpenEndpoint(iEp0Buffer, KEp0Number);
    if (ret != KErrNone)
        {
        OstTrace1( TRACE_FATAL, CNCMCOMMINTERFACESENDERANDRECEIVER_START1, "OpenEndpoint error %d", ret);
        iCommInterface.ControlMsgError(EInternalError);
        OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_START_EXIT, this );
        return;
        }
    iState = EIdle;
    OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_START_EXIT_DUP1, this );
    }

void CNcmCommInterfaceSenderAndReceiver::Stop()
    {
    OstTraceFunctionEntry0( CNCMCOMMINTERFACESENDERANDRECEIVER_STOP_ENTRY );
    
    iState = EIdle;
    Cancel();    
    iEp0Buffer.Close();
    OstTraceFunctionExit0( CNCMCOMMINTERFACESENDERANDRECEIVER_STOP_EXIT );
    }


//
//Read data of aLength from LDD
//

TInt CNcmCommInterfaceSenderAndReceiver::Read(TRequestStatus& aStatus, TDes8& aBuf, TInt aLength)
    {
    OstTraceFunctionEntry1( CNCMCOMMINTERFACESENDERANDRECEIVER_READ_ENTRY, this );   
    OstTrace1( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_READ, "CNcmCommInterfaceSenderAndReceiver::Read length %d", aLength );
        
    iCompleteStatus = &aStatus;
    *iCompleteStatus = KRequestPending;
    if (iState != EIdle)
        {
        OstTrace0( TRACE_FATAL, CNCMCOMMINTERFACESENDERANDRECEIVER_READ_DUP1, "CNcmCommInterfaceSenderAndReceiver Read In Use" );
        OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_READ_EXIT, this );
        return KErrInUse;
        }
    iReceiveBuf = &aBuf;
    iReceiveBuf->Zero();
    iToReceiveLength = aLength;
    iState = EReceiving;
    ReadData();
    OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_READ_EXIT_DUP1, this );
    return KErrNone;
    }

//
//write aLength data to ldd
//
TInt CNcmCommInterfaceSenderAndReceiver::Write(TRequestStatus& aStatus, TDesC8& aBuf, TInt aLength)
    {
    OstTraceFunctionEntry1( CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE_ENTRY, this );
    OstTrace1( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE, "CNcmCommInterfaceSenderAndReceiver::Write length %d", aLength );

    iCompleteStatus = &aStatus;
    *iCompleteStatus = KRequestPending;

    if (iState != EIdle)
        {
        OstTrace0( TRACE_FATAL, CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE1, "CNcmCommInterfaceSenderAndReceiver::Write in Use" );        
        OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE_EXIT, this );
        return KErrInUse;
        }

    TAny *buf;
    TUint size;
    TInt ret = iEp0Buffer.GetInBufferRange(buf, size);
    if (ret != KErrNone)
        {
        OstTrace0( TRACE_FATAL, CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE2, "CNcmCommInterfaceSenderAndReceiver::Write in Use" );        
        OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE_EXIT_DUP1, this );
        return ret;
        }
    else if (size < aLength)
        {
        OstTrace0( TRACE_FATAL, CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE3, "write data is bigger than ldd buffer size" );        
        OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE_EXIT_DUP2, this );
        return KErrArgument;
        }

    TPtr8 writeBuf((TUint8 *)buf, size);
    writeBuf.Copy(aBuf.Ptr(), aLength);    
    ret = iEp0Buffer.WriteBuffer(buf, writeBuf.Size(), ETrue, iStatus);
    if (ret != KErrNone)
        {
        OstTrace1( TRACE_FATAL, CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE4, "WriteBuffer error %d", ret );
        OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE_EXIT_DUP3, this );
        return ret;
        }
    iState = ESending;
    SetActive();
    OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_WRITE_EXIT_DUP4, this );
    return KErrNone;
    }



//
//Read data from USB share chunk LDD
//
void CNcmCommInterfaceSenderAndReceiver::ReadData()
    {
    OstTraceFunctionEntry1( CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA_ENTRY, this );
    TInt ret;
    TAny* buf;
    TUint8* receivebuf; 
    TUint receiveLen;
    TBool zlp;

    FOREVER
        {
        ret = iEp0Buffer.GetBuffer(buf, receiveLen, zlp, iStatus, iToReceiveLength);
        receivebuf = (TUint8*)buf; 
        if (ret == TEndpointBuffer::KStateChange)
            {
            OstTrace0( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA, "receive state change, discard it" );
            continue;
            }

        else if (ret == KErrCompletion)
            {
            OstTrace1( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA1, "read data length %d from ldd", receiveLen );
            if (receiveLen > iToReceiveLength)
                {
                User::RequestComplete(iCompleteStatus, KErrOverflow);
                iState = EIdle;
                OstTrace0( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA2,"data from ldd is bigger than receive buffer" );
                OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA_EXIT, this );
                return;
                }
            
            iReceiveBuf->Append(receivebuf, receiveLen);
            iToReceiveLength -= receiveLen;
            if (!iToReceiveLength)
                {        
                User::RequestComplete(iCompleteStatus, KErrNone);
                iState = EIdle;
                OstTrace0( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA3,"Complete read request" );
                OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA_EXIT_DUP1, this );
                return;
                }
            continue;
            }
        else if (ret == KErrNone)
            {
            break;
            }
        else
            {
            OstTrace1( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA4, "GetBuffer error %d", ret);
            User::RequestComplete(iCompleteStatus, KErrNone);
            iState = EIdle;
            OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA_EXIT_DUP2, this );
            return;
            }
        }
    SetActive();
    OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_READDATA_EXIT_DUP3, this );
    }

//
//RunL, looply receive data from share chunk LDD until receive all required data
//
void CNcmCommInterfaceSenderAndReceiver::RunL()
    {
    OstTraceFunctionEntry1( CNCMCOMMINTERFACESENDERANDRECEIVER_RUNL_ENTRY, this );
    if(iStatus.Int() != KErrNone)
        {
        if (KErrCancel == iStatus.Int() )
            {
            OstTrace0( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_RUNL,"CNcmCommInterfaceSenderAndReceiver, control channel is cancelled" );
            }
        else
            {
            OstTrace1( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_RUNL1, "CNcmCommInterfaceSenderAndReceiver::RunL error %d", iStatus.Int());
            }
        User::RequestComplete(iCompleteStatus, iStatus.Int());
        }
    else
        {
        if (iState == EReceiving)
            {
            ReadData();
            }
        else if (iState == ESending)
            {
            User::RequestComplete(iCompleteStatus, KErrNone);
            iState = EIdle;
            OstTrace0( TRACE_NORMAL, CNCMCOMMINTERFACESENDERANDRECEIVER_RUNL2,"Complete write request" );
            }
        }
    OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_RUNL_EXIT, this );
    }

//
//Cancel the outgoing read request
//
void CNcmCommInterfaceSenderAndReceiver::DoCancel()
    {    
    OstTraceFunctionEntry1( CNCMCOMMINTERFACESENDERANDRECEIVER_DOCANCEL_ENTRY, this );
    iPort.ReadCancel(KUsbcScEndpointZero);
    iPort.WriteCancel(KUsbcScEndpointZero);
    OstTraceFunctionExit1( CNCMCOMMINTERFACESENDERANDRECEIVER_DOCANCEL_EXIT, this );
    }