/*

* Copyright (c) 2002-2006 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:           The class for submitting synchronous requests via call

*                to asynchronous SendL of a certain MSenTransport instance

*                and making the ActiveScheduler to wait until a response

*                callback is received from the transport (typically a server

*                for certain networking stack).

*

*/

#ifndef SEN_SYNC_REQUESTER_H

#define SEN_SYNC_REQUESTER_H

//  INCLUDES

#include <e32base.h>

#include <e32std.h>

#include "msenservicesession.h"

#include "msenremoteserviceconsumer.h"

#include "MSenProperties.h"

// FORWARD DECLARATIONS

class MSenServiceSession;

class MSenRemoteServiceConsumer;

class MSenCoreServiceManager;

class MSenTransport;

class CSenGuidGen;

class MSenRemoteHostlet;

class MSenProperties;

// CLASS DECLARATION

/**

 * The class for submitting requests in a synchronous

 * *manner* using the async SendL implementation offered

 * by given MSenTransport reference.

 *

 * Any transport plug-in developer may wish to use this

 * class to implement SubmitL of her transport, using

 * the SendL method implementation of that transport.

 * In most of the cases, that is the most beneficial

 * way to implement SubmitL, blocking the caller's 

 * ActiveScheduler execution until a response is 

 * received.

 *

 * One can take a look of LocalTransportPlugin implementation

 * and use it as a reference of how this synchronous requester

 * class can be implemented.

 */

class CSenSyncRequester : public CBase,

                          public MSenServiceSession,

                          public MSenRemoteServiceConsumer

    {

    public:

        /**

         * Two-phased constructor.

         */

        IMPORT_C static CSenSyncRequester* NewL(MSenTransport& aTransport,

                                                MSenCoreServiceManager& iServiceManager);

        /**

         * Two-phased constructor.

         */

        IMPORT_C static CSenSyncRequester* NewLC(MSenTransport& aTransport,

                                                 MSenCoreServiceManager& iServiceManager);

        /**

         * Destructor.

         */

        IMPORT_C virtual ~CSenSyncRequester();

        /**

         * Submit a synchronous HTTP POST request to a given URI using

         * the - asynchronous - SendL method of the MSenTransport that

         * this class is "wrapping". Any transport plugin, which wishes

         * to implement SubmitL by calling and waiting SendL to complete,

         * can use this method to implement their synchronous SubmitL

         * function.

         *

         * @param aRequestUri service endpoint (URI) for the outgoing message.

         * @param aMessage outgoing message content.

         * @param aRequestTransportProperties outgoing message properties

         * @param aResponseContent incoming response message (content).

         * @param aStatusCode the status code of the response message,

         *        indicating whether or not an error occurred

         * @return a transaction id of the "wrapped" SendL, which is performed

         *         inside this method, or error code, negative integer, if

         *         sending of the message fails.

         */

        virtual TInt SubmitL(const TDesC8& aEndpointUri,

                     const TDesC8& aMessage,

                     const TDesC8& aRequestTransportProperties,

                     HBufC8*& apResponseTo);

        // Functions from base classes

        /**

        *   from MSenServiceSession

        */

        virtual TInt SendToConsumerL(HBufC8* apMessage,

                                     const TInt aTxnId,

                                     MSenRemoteServiceConsumer& aConsumer,

                                     MSenProperties* aResponseTransportProperties = NULL);

        virtual TInt SendErrorToConsumerL(const TInt aErrorCode,

                                          HBufC8* apError,

                                          const TInt aTxnId,

                                          MSenRemoteServiceConsumer& aConsumer,

                                          MSenProperties* aResponseTransportProperties = NULL);  

        virtual TInt HandleErrorL(const TInt aErrorCode,

                                  HBufC8* apError,

                                  const TInt aTxnId,

                                  MSenRemoteServiceConsumer& aConsumer,

                                  MSenProperties* aResponseTransportProperties = NULL);

        /**

        *   from MSenRemoteServiceConsumer

        */

        virtual const TDesC8& Id() const;

        virtual TInt SetSessionL(MSenRemoteServiceSession& aServiceSession);

        virtual TInt HandleMessageL(HBufC8* apMessage,

                                    const TInt aTxnId,

                                    MSenProperties* aResponseTransportProperties);

        virtual TInt HandleErrorL(HBufC8* aError,

                                  const TInt aErrorCode,

                                  const TInt aTxnId,

                                  MSenProperties* aResponseTransportProperties);

         virtual void SetStatusL(const TInt aStatus);

         virtual MSenTransport& TransportL();

         virtual CSenIdentifier& Identifier() const;  

         virtual TInt ChunkByTxnIdL(TInt aTxnId, CSenChunk*& aChunk);

         virtual MSenRemoteHostlet* CSenSyncRequester::Hostlet() const;

         virtual TInt SendToHostletL(MSenRemoteHostlet& aReceiver,

                                     const TDesC8& aMessage,

                                     const TInt aTxnId,

                                     MSenRemoteServiceConsumer& aFrom,

                                     MSenProperties* aProperties = NULL);

        virtual void FileProgress(TInt aTxnId, TBool aIncoming, TBool aIsSoap,

                const TDesC8& aSoapOrCid, TInt aProgress);

		virtual void SetDataTrafficDetails( TSenDataTrafficDetails& aDetails); 	

    protected:

        IMPORT_C CSenSyncRequester(MSenTransport& aTransport, 

                                   MSenCoreServiceManager& iServiceManager);

        IMPORT_C void BaseConstructL();

    private:  // Data

        MSenTransport& iTransport;

        MSenCoreServiceManager& iServiceManager; // for GUID generation API access etc

        CActiveSchedulerWait iSchedulerWait;

        CSenIdentifier* ipIdentifier;   // owned

        HBufC8* ipConsumerId;           // owned

        HBufC8* ipResponse;             // owned

        HBufC8* ipResponseProperties;   // owned, contains properties of the response

        MSenProperties::TSenPropertiesClassType         iResponsePropertiesType;

        TInt iStatusCode;               // contains KErrNone or some error

    };

#endif //SEN_SYNC_REQUESTER_H

// End of File