/*

* Copyright (c) 2002-2007 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:  

*     Class implementing transaction within WAP session

*

*/

#ifndef MMSTRANSACTION_H

#define MMSTRANSACTION_H

//  INCLUDES

#include    "mmsoperationtimer.h"

#include    "mmstransportobserver.h"

#include    "mmsbearerstatus.h"

#include    <e32base.h>

#include    <mentact.h>     // CMsgActive

#include    <http/thttpevent.h>

#include    <http/mhttptransactioncallback.h>

#include    <http/mhttpdatasupplier.h>

// CONSTANTS

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

class MMmsCodecDataSupplier;

class MMmsCodecDataSink;

// CLASS DECLARATION

/**

*  Class implementing transaction within WAP session

*/

NONSHARABLE_CLASS( CMmsTransaction ):public CMsgActive,

    public MMmsTransportObserver,

    public MHTTPTransactionCallback,

    public MHTTPDataSupplier

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CMmsTransaction* NewL();

        /**

        * Destructor.

        */

        virtual ~CMmsTransaction();

    public: // New functions

        /**

        * Start the state machine.

        * @param aHTTPSession Reference to HTTP session running in client

        * @param aTransferControl Object used to detect if transfer is cancelled

        * @param aUri Address to MMSC with message id 

        * @param aMethod The type of transaction (POST/GET)

        * @param aMessageBuffer An IN/OUT parameter. Includes the data to be sent to

        *        to WAP GW. If there should be data to be returned, this includes it.

        * @param aTransactionTimer Timer for transaction

        * @param aMaxReceiveSize upper limit for accepted message. 0 = anything goes.

        * @param aExpectedReceiveSize tells how large buffer will be allocated for the data

        * @param aDataSupplier The class that will serve as data supplier

        *        for chunked transfer.

        * @param aDataSink The class that will serve as data sink for chunked receive

        * @param aStatus Status of calling active object

        */

        void ExecuteL( 

            RHTTPSession&           aSession,    

            CMmsBearerStatus&       aTransferControl,

            const TDesC&            aUri,

            const TInt              aMethod,

            CBufFlat&               aMessageBuffer,

            const TInt              aTransactionTimer,

            TInt32                  aMaxReceiveSize,

            TInt32                  aExpectedReceiveSize,

            MMmsCodecDataSupplier&  aDataSupplier,

            MMmsCodecDataSink&      aDataSink,

            TRequestStatus&         aStatus );

    public: // Functions from base classes

        // from MHTTPTransactionCallback

        /** Called when the filter's registration conditions are satisfied for

        * events that occur on a transaction.

        * Note that this function is not allowed to leave if called with

        * certain events. @see THTTPEvent

        * @param aTransaction The transaction that the event has occurred on.

        * @param aEvent The event that has occurred.

        * @exception Any Leaves must be handled by the appropriate MHFRunError.

        */

        void MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent);

        /** Called when RunL leaves from a transaction event. This works in the same

        * way as CActve::RunError; return KErrNone if you have handled the error.

        * If you don't completely handle the error, a panic will occur.

        * @param aError The leave code that RunL left with.

        * @param aTransaction The transaction that was being processed.

        * @param aEvent The Event that was being processed.

        * @return KErrNone if the error has been cancelled or the code

        * of the continuing error otherwise.

        */

        TInt MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent);

        // from MHTTPDataSupplier

        /** Obtain a data part from the supplier.  The data is guaranteed

        * to survive until a call is made to ReleaseData().

        * @param aDataPart - the data part

        * @return ETrue if this is the last part. EFalse otherwise

        */

        TBool GetNextDataPart(TPtrC8& aDataPart);

        /** Release the current data part being held at the data

        * supplier.  This call indicates to the supplier that the part

        * is no longer needed, and another one can be supplied, if

        * appropriate.

        */

        void ReleaseData();

        /** Obtain the overall size of the data being supplied, if known

        * to the supplier.  Where a body of data is supplied in several

        * parts this size will be the sum of all the part sizes. If

        * the size is not known, KErrNotFound is returned; in this case

        * the client must use the return code of GetNextDataPart to find

        * out when the data is complete.

        * @return A size in bytes, or KErrNotFound if the size is not known.

        */

        TInt OverallDataSize();

        /** Reset the data supplier.  This indicates to the data supplier that it should

        * return to the first part of the data.  This could be used in a situation where

        * the data consumer has encountered an error and needs the data to be supplied

        * afresh.  Even if the last part has been supplied (i.e. GetNextDataPart has

        * returned ETrue), the data supplier should reset to the first part.

        * If the supplier cannot reset it should return an error code; otherwise it should

        * return KErrNone, where the reset will be assumed to have succeeded

        */

        TInt Reset();

        // from MMmsTransportObserver

        /**

        * Callback function for CMmsOperationtimer to notify

        * about timer expiration

        */

        void TimerExpired();

        /**

        * Callback function for CMmsBearerStatus to notify

        * about gprs suspend

        */

        void GprsSuspended();

        /**

        * Callback function for CMmsBearerStatus to notify

        * about gprs resume

        */

        void GprsResumed();

        /**

        * Callback function for CMmsBearerStatus to notify

        * about gprs resume

        */

        void TransferCancelled();

    protected:  // New functions

    protected:  // Functions from base classes

        /**

        * From CActive 

        */

        void DoCancel();

        /**

        * From CMsgActive: Active object completion

        * We must override this because the CMmsOperationTimer

        * and GPRS suspend information is delivered as an error.

        * This class DoRunL is not called if iStatus is error.

        */

        void RunL();

        /**

        * From CMsgActive 

        */

        void DoRunL();

    private:

        /**

        * C++ default constructor.

        */

        CMmsTransaction();

        /**

        * By default Symbian OS constructor is private.

        */

        void ConstructL();

        /**

        * From CMsgActive: Complete current operation.

        * Cancel all active operations (timer, bearer status)

        * @param aError Error code received by RunL

        */

        void DoComplete( TInt& aError );

        /**

        * Select next state for state machine

        */

        void SelectNextState();

        /**

        * Switch states

        */

        void ChangeStateL();

        /**

        * Send transaction request (POST/GET) to WAP GW

        */

        void MakeTransactionL();

        /**

        * Finalizing procedures

        */

        void FinishL();

        /**

        * Sets a transaction header

        * @param aHeaders the header collection where the new header is inserted

        * @param aHdrField enumeration of the header field

        * @param aHdsValue the string value of the header to be set

        */

        void SetHeaderL( RHTTPHeaders aHeaders, TInt aHdrField, const TDesC8& aHdrValue );

        /**

        * Sets the 'Host' transaction header

        * @param aHeaders the header collection where the new header is inserted

        */

        void SetHostHeaderL( RHTTPHeaders aHeaders );

    public:     // Data

    protected:  // Data

    private:    // Data

        enum TMmsTransactionStates

            {

            EMmsIdle,

            EMmsSendingTransactionRequest,

            EMmsFinished

            };

        TInt                iState;

        TInt                iError;        

        HBufC*              iUri;                  // URI

        CBufFlat*           iBuffer; 

        TInt                iMethod;

        RHTTPSession*       iHTTPSession;          // transport session

        THTTPEvent          iEvent;

        RHTTPTransaction    iTransaction;          // transaction

        // This is owned by caller

        CMmsOperationTimer* iTimer;

        CMmsBearerStatus*   iTransferControl;

        TInt                iTransactionTimeout;

        TBool               iRetryCount;

        TBool               iRequestOngoing;

        TBool               iSuspendOccurred;

        TBool               iGotBodyData;

        TBool               iDataChunkNumber;

        TInt                iMaxReceiveSize;       // used in case we don't allow big messages

        TInt                iExpectedReceiveSize;  // used for reserving correct size receive buffer

        TBool               iTransactionOpened;    // tells if transaction created successfully

        TBool               iGotResponseHeaders;   // did we get response headers

        // pointer to the class that will serve as data supplier for chunked transfer.

        // pointer is owned by caller - we don't delete it

        MMmsCodecDataSupplier*  iDataSupplier;

        // pointer to the class that will serve as data sink for chunked receive.

        // pointer is owned by caller - we don't delete it

        MMmsCodecDataSink*      iDataSink;

        TBool                iLastChunk; // keep track if we already got last chunk

        TInt                 iCumulativeSize; // the amound of data received or sent so far

        TInt                 iChunkSize; // remember last chunk

        // The size the buffer can be expanded to in chunked mode.

        // When buffer reaches this size the contents must be sent for decoding.

        TInt                 iBufferSize;

        // Position where the data will be written into buffer. There may be some old

        // unhandled data left.

        TInt                 iPosition;

    public:     // Friend classes

    protected:  // Friend classes

    private:    // Friend classes

    };

#endif      // MMSTRANSACTION_H   

// End of File