/*

* Copyright (c) 2002-2005 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:    Header declaration

*

*/

#ifndef M_SEN_TRANSPORT_H

#define M_SEN_TRANSPORT_H

// INCLUDES

#include <e32std.h>

#include "msenservicesession.h"

#include "msenremoteserviceconsumer.h"

#include "msenlayeredproperties.h"

#include "MSenElement.h"

// CONSTANTS

const TInt KErrSenTransactionComplete = 20;

// FORWARD DECLARATIONS

class CSenFragment;

class CSenTransportProperties;

// DATA TYPES

typedef RPointerArray<CSenFragment> RTransportProperties;

// CLASS DECLARATION

class MSenTransport

    {

    public:

        // New functions

        /**

        * Method for sending synchronous  request to a known endpoint (URI). This method

        * will block the current ActiveScheduler until the response from service is received.

        *

        * @param aEndpoint is the endpoint, typically an URI of the service being invoked

        * @param aMessage is the actual message to the service behind known endpoint

        * @param aTransportProperties containts the transport related request properties

        * @param aResponse will contain the response after this synchronous call returns.

        * @param aConsumer is the underlying caller invoking this request.

        * @return KErrSenNoEndpoint if aEndpoint lenght is zero or negative.

        */

        virtual TInt SubmitL(const TDesC8& aEndpoint,

                             const TDesC8& aMessage,

                             const TDesC8& aTransportProperties,

                             HBufC8*& aResponse,

                             MSenRemoteServiceConsumer& aConsumer) = 0;  

        /**

        * Method for sending asynchronous request to a known endpoint (URI).

        * @param aEndpoint is the endpoint, typically an URI of the service being invoked

        * @param aMessage is the actual message to the service behind known endpoint

        * @param aTransportProperties containts the transport related request properties

        * @param aReplyTo is the session session performing this request for the caller 

        * @param aConsumer is the underlying caller invoking this request (addressee)

        * @param aTxnId will be set to refer to the new transaction id of this request

        * @return KErrNone or some error, if the method fails. Error code can be either some

        * system-wide constnat, or a WSF specific KErrSenNoEndpoint if aEndpoint lenght is zero

        * or negative.

        */

        virtual TInt SendL(const TDesC8& aEndpoint,

                           const TDesC8& aMessage,

                           const TDesC8& aTransportProperties,

                           MSenServiceSession& aReplyTo,

                           MSenRemoteServiceConsumer& aConsumer,

                           TInt& aTxnId) = 0;

        /**

        * Method parses and applies the given properties on top of current properties 

        * (state) of the transport. This means, that all spesified property entries 

        * override existing ones 

        */

        virtual TInt SetPropertiesL(const TDesC8& aProperties,

                                    MSenLayeredProperties::TSenPropertiesLayer aTargetLayer,

                                    MSenRemoteServiceConsumer* aConsumer) = 0;

        virtual TInt PropertiesL(HBufC8*& aProperties) = 0;

        /**

        * Cancels the transaction from the transport, removing interested pending

        * consumers from list of response receivers, preventing any callbacks

        * being performed even though transport itself may still receive response

        * from some (network stack) server.

        * @return KErrNone, if cancel was performed

        *         KErrNotFound if transaction was not found 

        */

        virtual TInt CancelTransaction(const TInt aTxnId) = 0;

        /**

        * Method requests the transport plug-in implementation to complete

        * a pending transaction. Typically, service provider sessions

        * (like MSenRemoteHostlet) implementations call this method to

        * signalize, that certain pending, asynchronous transaction

        * issued earlier by some consumer has been completed.

        * @param aTxnId is the id of the transaction to be completed

        * @param aStatus is an optional, additinal status code, which

        * transport plug-in should pass to the "addressee", the consumer,

        * who originated this transaction.

        * @return KErrNone if transaction was completed successfully

        *         KErrNotFound if pending transaction, matching with

        *         given aTxnId was not found.

        */

        virtual TInt CompleteTransaction(const TInt aTxnId,

                                         const TInt aStatus = KErrNone) = 0;

        /**

        * Getter for the URI scheme of this transport plug-in implementation,

        * Examples of such scheme are: http, tcp, udp and local.

        * @return the scheme of this transport

        */

        virtual TPtrC8 UriSchemeL() = 0;

        virtual MSenProperties& PropertiesL() = 0;

        inline virtual TInt SubscribeEventListenerL(MSenRemoteServiceConsumer& /*aConsumer*/) 

            {

            return KErrNotSupported;

            }

        inline virtual TInt UnsubscribeEventListenerL(MSenRemoteServiceConsumer& /*aConsumer*/)

            {

            return KErrNotSupported;

            }

    };

#endif // SEN_MTRANSPORT_H

// End of File