// Copyright (c) 2006-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:

//

/**

 @file

 @internalComponent

*/

#ifndef CMTPUSBEPBASE_H

#define CMTPUSBEPBASE_H

#include <e32std.h>

#include <e32base.h>

#include <d32usbc.h>

#include "mtpdebug.h"

class CMTPUsbConnection;

/**

Defines the USB MTP device class endpoint data transfer controller base class.

@internalComponent

*/

class CMTPUsbEpBase : public CActive

    {

public:

    virtual ~CMTPUsbEpBase();

    TEndpointNumber EndpointNumber() const;

    TUint Id() const;

    void SetMaxPacketSizeL(TUint aSize);

    void Stall();

    void StallClear();

    TBool Stalled() const;

    static TInt LinearOrder(const CMTPUsbEpBase& aL, const CMTPUsbEpBase& aR);

    void ResumeReceiveDataL(MMTPType& aSink);    

    void CancelReceiveL(TInt aReason);

    void CancelSendL(TInt aReason);

    void FlushRxDataL();

    void FlushBufferedRxDataL();

protected:

    CMTPUsbEpBase(TUint aId, TPriority aPriority, CMTPUsbConnection& aConnection);

#ifdef __FLOG_ACTIVE    

    virtual void ConstructL(const TDesC8& aComponentName);

#else

    virtual void ConstructL();

#endif  

    CMTPUsbConnection& Connection() const;

    void ReceiveDataL(MMTPType& aSink);

    virtual void ReceiveDataCompleteL(TInt aError, MMTPType& aSink);

    void SendDataL(const MMTPType& aSource);

    virtual void SendDataCompleteL(TInt aError, const MMTPType& aSource);

protected: // From CActive

   	void DoCancel();

private: // From CActive

    TInt RunError(TInt aError);

    void RunL();

private:

    TInt32 DataStreamDirection() const;

    void ResetReceiveDataStream();

    void ResetSendDataStream();

    void ResumeReceiveDataStreamL();

    void ProcessSendDataStreamL();

    void SetStreamState(TInt aState);

    TBool ValidateUSBHeaderL();

    void InitiateFirstChunkReceiveL();

    void ProcessFirstReceivedChunkL();

protected: // Owned

    /**

    FLOGGER debug trace member variable.

    */

    __FLOG_DECLARATION_MEMBER_MUTABLE;

private: // Owned

    /**

    The data stream states.

    */

    enum TState

        {

        /**

        Both send and receive data streams are inactive.

        */

        EIdle                   = 0x00000000,

        /**

        Both send and receive data streams are stalled.

        */

        EStalled                = 0x0F000000,

        /**

        The receive data stream is active.

        */

        EReceivingState         = 0x40000000,

        EReceiveInitialising    = 0x40000001,

        EReceiveInProgress      = 0x40000002,

        EReceiveCompleting      = 0x40000003,

        EReceiveComplete        = 0x40000004,

        /**

        The send data stream is active.

        */

        ESendingState           = 0x80000000,

        ESendInitialising       = 0x80000001,

        ESendInProgress         = 0x80000002,

        ESendCompleting         = 0x80000003,

        ESendComplete           = 0x80000004,

        EStateDirection         = 0xF0000000

        }; 

    /**

    The active data stream chunk status.

    */

    TInt                iChunkStatus;

    /**

    The internal endpoint identifier.

    */

    TUint               iId;

    /**

    The residual packet data buffer.

    */

    RBuf8               iPacketBuffer;

    /**

    The maximum bulk-in endpoint size.

    */

    TUint               iPacketSizeMax;

    /** 

    The receive data stream commit flag.

    */

    TBool               iReceiveDataCommit;

    /**

    The receive data stream chunk data buffer.

    */

    TPtr8               iReceiveChunkData;

    /**

    The receive data stream data pointer.

    */

    TPtr8               iReceiveData;

    /**

    The send data stream chunk data.

    */

    TPtrC8              iSendChunkData;

    /**

    The send data stream data pointer.

    */

    TPtrC8              iSendData;

    /**

    The data stream state variable.

    */

    TInt32              iState;   

    /**

    A flag to tell if the receive stream is the first chunk.

    */			

    TBool 				iIsFirstChunk;

    /**

    The amount of data received.

    */

    TUint64 			iDataCounter;

    /**

    The amount of data expected.

    */    

    TUint64 			iDataLength;

private: // Not owned

    /**

    The MTP USB device class transport connection which controls the endpoint.

    */

    CMTPUsbConnection&  iConnection;

    /**

    The receive data stream sink buffer

    */

    MMTPType*           iReceiveDataSink;

    /**

    The send data stream source buffer

    */

    const MMTPType*     iSendDataSource;

    };

#endif // CMTPUSBEPBASE_H