/*
* Copyright (c) 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:  Definition of CCommAdapter that uses media plugins to read
*        HTI messages and send new ones back. Because comm plug-in
*        interface define async functions, this class is AO.
*
*/


#ifndef MCOMMADAPTER_H__
#define MCOMMADAPTER_H__

#include <e32base.h>

//forward declaration
class CHtiDispatcher;
class CHTICommPluginInterface;
class CHtiMessage;

class CHtiCommAdapter: public CActive
    {
private:
    /**
    * Enum of different states depending on the current operation
    */
    enum TCommState
        {
        EIdle,
        EReceiving,
        EReceivingCont,
        ESending
        };

public:
    /**
    * Construct the object and adds it to CActiveScheduler.
    *
    * @param aCommPlugin communication plug-in
    * @param aDispatcher message dispatcher
    * @param aMaxMsgSize max size of an incoming message that will be
    *           accepted
    */
    static CHtiCommAdapter* NewL(CHTICommPluginInterface* aCommPlugin,
        CHtiDispatcher* aDispatcher,
        TInt aMaxMsgSize);

    /**
    * Construct the object and adds it to CActiveScheduler
    *
    * @param aCommPlugin communication plug-in
    * @param aDispatcher message dispatcher
    * @param aMaxMsgSize max size of an incoming message that will be
    *           accepted
    */
    static CHtiCommAdapter* NewLC(CHTICommPluginInterface* aCommPlugin,
        CHtiDispatcher* aDispatcher,
        TInt aMaxMsgSize);

    /**
    * Destructor
    */
    ~CHtiCommAdapter();

    /**
    * Issue an async request to receive whole HTI message and
    * pass it to the framework on complition.
    */
    void ReceiveMessage();

    /**
    * Send a HTI message via comm plug-in.
    * Ownership of aMessage is tranfered to CCommAdapter.
    * When message is sent, aMessage will be deleted.
    *
    * @param aMessage a HTI message to send
    */
    void SendMessage(CHtiMessage* aMessage);

    /**
    * Stop all ongoing operations and clean all internal buffers.
    */
    void Reset();

protected:

    CHtiCommAdapter(CHtiDispatcher* aDispatcher,
                 CHTICommPluginInterface* aCommPlugin,
                TInt aMaxMsgSize);

    void ConstructL();


    /**
    * Issue request to receive the next packet.
    * If aContinue = ETrue than iState is set to EReceivingCont
    * Otherwise it set to EReceiving.
    * iState set to EReceivingCont after message beginning was received
    * and its continuation is expected
    *
    * @param aContinue continuation flag
    */
    void ReceiveMessage(TBool aContinue);

    /**
    * Handle received data from buffer and reissue request
    */
    void HandleReceiveL();
    void HandleReceiveContL();

    /**
    * Reissue request to send message
    */
    void HandleSend();


protected: //from CActive
    void RunL();
    void DoCancel();
    TInt RunError(TInt aError);

private: //data members

    /**
    * Current communication state
    */
    TCommState iState;

    /**
    * Pointer to message dispatcher.
    */
    CHtiDispatcher* iDispatcher;

    /**
    * Communication ECom plug-in
    */
    CHTICommPluginInterface* iCommPlugin;

    /**
    * Buffer for receiving data. It'is allocated once and used for
    * all subsequent receiving operation. Data from this buffer copied
    * to iMsgToReceive buffer that than passed to the framework for
    * processing
    */
    HBufC8* iBuffer;

    /**
    * Pointer to the buffer for receiveing data
    */
    TPtr8 iBufferPtr;

    /**
    * HTI incoming message. It's passed to the framework
    * when whole message is received
    */
    CHtiMessage* iMsgToReceive;

    /**
    * Small buffer used when there is some data left in iBuffer that
    * cannot be processed (less than min header size)
    */
    HBufC8* iLeftovers;

    /**
    * Keep message passed in SendMessage() between calls to comm. plugin
    * and deleted when sending is complete
    */
    CHtiMessage* iMsgToSend;

    /**
    * Pointer to the part of iMsgToSend started from iMsgToSendOffset
    * that is being sent via current comm. plug-in
    */
    TPtrC8 iMsgToSendPtr; //ptr to msg part passed to plug-ins

    /**
    * Offset in iMsgToSend of a part that is being sent
    */
    TInt iMsgToSendOffset;

    /**
    * Amount of receving bytes to skip.
    * It's ussed when there is no memory for incoming message or
    * its size too big.
    */
    TInt iSkipLength;

    /**
    * Max message size to accept
    */
    const TInt iMaxMessageSize;
    };

#endif