/*
* 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:           CSenServiceConnection offers public API for
*                service consumers to access invocable services, 
*                as a part of the Web Services Framework (WSF).
*
*/












#ifndef SEN_SERVICE_CONNECTION_H
#define SEN_SERVICE_CONNECTION_H

//  INCLUDES
#include <e32base.h> // for CActive
#include <MSenServiceConsumer.h>
#include <MSenServiceDescription.h>

#include <MSenAuthenticationProvider.h>

#include <SenSoapMessage.h>
#include <SenSoapMessage2.h>
//#include <SenAtomEntry.h>


#include <MSenMessage.h>

// CONSTANTS
const TInt KErrSenNotInitialized                    =   -30291;
const TInt KErrSenServiceConnectionBusy             =   -30292;
const TInt KErrConnectionInitializing               =   -30293;
const TInt KErrConnectionExpired                    =   -30294;
const TInt KErrSubmitting                           =   -30295;
const TInt KErrSenSoapFault                         =   -30296; 
const TInt KErrSenInternal                          =   -30297;
const TInt KErrSenNoEndpoint                        =   -30298;
const TInt KErrSenNoContract                        =   -30299;

const TInt KErrSenProviderIdInUseByAnotherEndpoint  =   -30305;
const TInt KErrSenNoContractNoEndPoint              =   -30306;

const TInt KErrSenBrokenSoapEnvelope                =   -30307;
const TInt KErrSenBrokenSoapFault                   =   -30308;
const TInt KErrSenCancelled                         =   -30309;


// HTTP transport error codes:
const TInt KErrSenNoHttpResponseBody                =   -30310;
const TInt KErrSenNoHttpContentType                 =   -30311;
const TInt KErrSenHttpRedirectRequiresConfirmation  =   -30312;

// SOAP message verification error codes:
const TInt KErrSenNoSoapBody                        =   -30313;
const TInt KErrSenNoSoapHeader                      =   -30314;
const TInt KErrSenNoPermission                      =   -30315; 

const TInt KErrSenHostNotAvailable                  =   -30318;

const TInt KErrSenAuthenticationFault               =   -30319;
const TInt KErrSenNoEndUserPermission               =   -30321;
const TInt KErrSenBrandNotSupported                 =   -30322;

const TInt KSenConnectionStatusCreateFailed         =  -1; // post-state
const TInt KSenConnectionStatusNew                  =   0; // post-state
const TInt KSenConnectionStatusReady                =   1; // post-state
const TInt KSenConnectionStatusExpired              =   2; // post-state
const TInt KSenConnectionStatusAuthentication       =   3; // pre-state
const TInt KSenConnectionStatusDiscovery            =   4; // pre-state
const TInt KSenConnectionStatusMetadataExchange     =   5; // pre-state

_LIT8(KDefaultBasicWebServicesFrameworkID,          "WS-I");
_LIT8(KDefaultIdWsfFrameworkID,                     "ID-WSF"); 
_LIT8(KDefaultRestServicesFrameworkID,              "REST");
_LIT8(KDefaultWSStarFrameworkID,                    "WS-STAR");
_LIT8(KDefaultAtomPubFrameworkID,                   "ATOM-PUB");
_LIT8(KDefaultOviFrameworkID,                       "OVI");

const TInt KSenTransportStatusCodeOffsetBaseHttp = 1000;
const TInt KSenTransportStatusCodeOffsetBaseVtcp = 2000;

const TInt KSenTransportStatusCodeVtcpInit =        2001; // KSenTransportStatusCodeOffsetBaseVtcp +1 
const TInt KSenTransportStatusCodeVtcpActive =      2002; // KSenTransportStatusCodeOffsetBaseVtcp +2 
const TInt KSenTransportStatusCodeVtcpSuspended =   2003; // KSenTransportStatusCodeOffsetBaseVtcp +3 
const TInt KSenTransportStatusCodeVtcpInactive =    2004; // KSenTransportStatusCodeOffsetBaseVtcp +4
const TInt KSenTransportStatusCodeVtcpUnavailable = 2005; // KSenTransportStatusCodeOffsetBaseVtcp +5

// FORWARD DECLARATIONS
class CSenServicePattern;
class CSenIdentityProvider;

struct TSenDataTrafficDetails 
{
public:
   	
   	TSenDataTrafficDetails():iTotalBytesSent(0),
   							 iTotalBytesRecieved(0)
	{
	}   						
	
	TBool operator==(TSenDataTrafficDetails& rhs)
	{
		if( (this->iTotalBytesSent == rhs.iTotalBytesSent) &&
			(this->iTotalBytesRecieved == rhs.iTotalBytesRecieved) )
			return ETrue;
		else
			return EFalse;
	}
	
	TSenDataTrafficDetails& operator=(TSenDataTrafficDetails& rhs)
	{
		if(*this == rhs)
			return *this;
		this->iTotalBytesSent = rhs.iTotalBytesSent;
		this->iTotalBytesRecieved = rhs.iTotalBytesRecieved;
		return *this;
	}
	
	TSenDataTrafficDetails& operator+=(TSenDataTrafficDetails& rhs)	
	{
		this->iTotalBytesSent += rhs.iTotalBytesSent;
		this->iTotalBytesRecieved += rhs.iTotalBytesRecieved;
		return *this;
	}
   	
   	TUint iTotalBytesSent ; 
   	TUint iTotalBytesRecieved ; 
private:	   
   	TAny* iReserved;
};

struct TSenDataTrafficOperations 
{
public:
	TSenDataTrafficOperations(): iReset(EFalse)
	{
	}
   	TBool iReset;
private:   	
   	TAny* iReserved;
};

// CLASS DECLARATION

/**
  * The class for connecting to service providers
  * through Web Services Framework (WSF). 
  *
  * The class offers asynchronous construction of a
  * service connection. Further, there are asynchronous
  * and synchronous interaction methods for e.g. sending 
  * and receiving data from (possibly remote) service.
  * 
  * WSF offers two default frameworks:
  *
  *   1. Identity Based Web Services Framework
  *      (ID-WSF). The framework ID for this is 
  *      KDefaultIdWsfFrameworkID ("ID-WSF").
  * 
  *   2. Basic Web Services Framework. Framework
  *      ID is KDefaultBasicWebServicesFrameworkID
  *      ("WS-I").
  * 
  * The most typical use of CSenServiceConnection
  * is to interact with a service of certain type
  * through some invocable framework and submitting
  * and receiving messages.
  *
  * In case of WebServices, the actual service is remote
  * and submitted messages are SOAP envelopes. However,
  * CSenServiceConnection supports accessing any
  * ServiceInvocationFramework which ECOM plug-in
  * implementation is present. These plug-ins may
  * further communicate with some service, including
  * local services. 
  * 
  * The link between CSenServiceConnection and any plug-in
  * implementation interacting with some service is the
  * framework ID, which is a property of ServiceDescription (SD)
  * and accessible via MSenServiceDescription interface, which
  * each SD class must implement. 
  * 
  * When creating a connection, one offers predefined SD as
  * an argument for asynchronous constructor. Or, optionally 
  * only a Liberty Alliance ID-WSF specific contract string 
  * - typically some URN. If only contract is offered, then
  * the created connection defaults to ID-WSF service and 
  * ID-WSF framework (ID) will be used.
  * 
  * The WSF further uses the offered framework ID while looking
  * up any matching framework plug-in implementation. As a
  * result the SD might be offered to several plug-ins.
* 
* @lib SenServConn.lib
*  @since Series60 3.0
*/

class CSenServiceConnection : public CActive, public MSenFragment
    {
    public: // Constructors and destructor

        /**
        * Two-phased constructor intended for Identity based service 
        * consumers (like ID-WSF). The pointer is left on the cleanup stack.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is performed
        * with a status value KSenConnectionStatusReady (1).
        * Contract of the service (typically some URN) is provided.
        * Authentication for the Web Service Provider (WSP) connection 
        * is resolved using one of the identity providers which have 
        * been associated with this contract (typically an URN).
        *
        * This constructor is ASYNCHRONOUS and the actual state of newly
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, a SetStatus call-back with value
        * KSenConnectionStatusReady (1) is executed.
        * If some error occurs, HandleErrorL() will be called to inform the
        * creator of this connection (service consumer application)
        *
        *    For example, if service is not found, a system wide error
        *    code of -1 is deliver via HandleErrorL() to WSC.
        *
        *    Second example: server response HTTP 501 means, that this error
        *    code. 501 will be delivered via HandleErrorL() to WSC.
        *    This can happen in ID-WSF connection being initialized, if
        *    either Authentication Service (AS) or Discovery Service (DS)
        *    cannot be reached.
        *
        * @param aConsumer      (web) service consumer (for call-backs)
        * @param aContract      contract of the service, typically an URI.
        * @return a pointer to a CSenServiceConnection instance.
        *
        */
        IMPORT_C static CSenServiceConnection* NewL(MSenServiceConsumer& aConsumer,
                                                    const TDesC8& aContract);

        /**
        * Two-phased constructor intended for Identity based service 
        * consumers (like ID-WSF). 
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is performed
        * with a status value KSenConnectionStatusReady (1).
        * Contract of the service (typically some URN) is provided.
        * Authentication for the Web Service Provider (WSP) connection 
        * is resolved using one of the identity providers which have 
        * been associated with this contract (typically an URN).
        * This constructor is ASYNCHRONOUS and the actual state of newly
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, a SetStatus call-back with value
        * KSenConnectionStatusReady (1) is executed.
        * If some error occurs, HandleErrorL() will be called to inform the
        * creator of this connection (service consumer application)
        *
        *    For example, if service is not found, a system wide error
        *    code of -1 is deliver via HandleErrorL() to WSC.
        *
        *    Second example: server response HTTP 501 means, that this error
        *    code. 501 will be delivered via HandleErrorL() to WSC.
        *    This can happen in ID-WSF connection being initialized, if
        *    either Authentication Service (AS) or Discovery Service (DS)
        *    cannot be reached.
        *
        * @param aConsumer      (web) service consumer (for call-backs)
        * @param aContract      contract of the service, typically an URI.
        * @return a pointer to a CSenServiceConnection instance.
        *                       The pointer is left on the cleanup stack.
        */
        IMPORT_C static CSenServiceConnection* NewLC(MSenServiceConsumer& aObserver,
                                                     const TDesC8& aContract);

        /**
        * Two-phased constructor using a service description.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aObserver connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection.
        * @return   a pointer to a CSenServiceConnection instance.
        */
        IMPORT_C static CSenServiceConnection* NewL(MSenServiceConsumer& aObserver,
                                                    MSenServiceDescription& aServiceDescription);

        /**
        * Two-phased constructor using a service description. The pointer
        * is left on the cleanup stack.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aObserver connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection.
        * @return   a pointer to a CSenServiceConnection instance.
        *               The pointer is left on the cleanup stack.
        */
        IMPORT_C static CSenServiceConnection* NewLC(MSenServiceConsumer& aObserver,
                                                     MSenServiceDescription& aServiceDescription);

        /*
        * The ServicePattern version of two phased constructor. 
        * Note, that this method is intended to be used by service consumers
        * wishing to initialize connection in specific context called
        * consumer policy. In consumer policy, certain properties 
        * can be set to further define what kind of connection is acceptable
        * and how the connection interacts with transport (for example, which
        * Internet Access Point (IAP) will be used).
        * However, any ConsumerPolicy feature is applicable in 
        * one-policy-per-client scope and not used as a common policy.
        * To set permanent information about known WSP, please use the
        * CSenXmlServiceDescription, which implements MSenProviderPolicy
        * interface.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aObserver connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection. 
        * @return   a pointer to a CSenServiceConnection instance.
        */
        IMPORT_C static CSenServiceConnection* NewL(MSenServiceConsumer& aObserver,
                                                    CSenServicePattern& aServicePattern);
    
        /*
        * The ServicePattern version of two phased constructor. 
        * Note, that this method is intended to be used by service consumers
        * wishing to initialize connection in specific context called
        * consumer policy. In consumer policy, certain properties 
        * can be set to further define what kind of connection is acceptable
        * and how the connection interacts with transport (for example, which
        * Internet Access Point (IAP) will be used).
        * However, any ConsumerPolicy feature is applicable in 
        * one-policy-per-client scope and not used as a common policy.
        * To set permanent information about known WSP, please use the
        * CSenXmlServiceDescription, which implements MSenProviderPolicy
        * interface.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aObserver connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection. 
        * @return   a pointer to a CSenServiceConnection instance.
        *               The pointer is left on the cleanup stack.
        */
        IMPORT_C static CSenServiceConnection* NewLC(MSenServiceConsumer& aObserver,
                                                     CSenServicePattern& aServicePattern);
        
        /**
        * Two-phased constructor intended for Identity based service 
        * consumers (like ID-WSF). The pointer is left on the cleanup stack.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is performed
        * with a status value KSenConnectionStatusReady (1).
        * Contract of the service (typically some URN) is provided.
        * Authentication for the Web Service Provider (WSP) connection 
        * is resolved using one of the identity providers which have 
        * been associated with this contract (typically an URN).
        *
        * This constructor is ASYNCHRONOUS and the actual state of newly
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, a SetStatus call-back with value
        * KSenConnectionStatusReady (1) is executed.
        * If some error occurs, HandleErrorL() will be called to inform the
        * creator of this connection (service consumer application)
        *
        *    For example, if service is not found, a system wide error
        *    code of -1 is deliver via HandleErrorL() to WSC.
        *
        *    Second example: server response HTTP 501 means, that this error
        *    code. 501 will be delivered via HandleErrorL() to WSC.
        *    This can happen in ID-WSF connection being initialized, if
        *    either Authentication Service (AS) or Discovery Service (DS)
        *    cannot be reached.
        *
        * @param aConsumer      (web) service consumer (for call-backs)
        * @param aContract      contract of the service, typically an URI.
        * @return a pointer to a CSenServiceConnection instance.
        * @param aAuthProvider      Authentication Provider
        */        
        IMPORT_C static CSenServiceConnection* NewL(MSenServiceConsumer& aConsumer,
                                                    const TDesC8& aContract,
                                                    MSenExtendedConsumerInterface& aExtendedConsumer);
        /**
        * Two-phased constructor intended for Identity based service 
        * consumers (like ID-WSF). 
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is performed
        * with a status value KSenConnectionStatusReady (1).
        * Contract of the service (typically some URN) is provided.
        * Authentication for the Web Service Provider (WSP) connection 
        * is resolved using one of the identity providers which have 
        * been associated with this contract (typically an URN).
        * This constructor is ASYNCHRONOUS and the actual state of newly
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, a SetStatus call-back with value
        * KSenConnectionStatusReady (1) is executed.
        * If some error occurs, HandleErrorL() will be called to inform the
        * creator of this connection (service consumer application)
        *
        *    For example, if service is not found, a system wide error
        *    code of -1 is deliver via HandleErrorL() to WSC.
        *
        *    Second example: server response HTTP 501 means, that this error
        *    code. 501 will be delivered via HandleErrorL() to WSC.
        *    This can happen in ID-WSF connection being initialized, if
        *    either Authentication Service (AS) or Discovery Service (DS)
        *    cannot be reached.
        *
        * @param aConsumer      (web) service consumer (for call-backs)
        * @param aContract      contract of the service, typically an URI.
        * @param aAuthProvider      Authentication Provider        
        * @return a pointer to a CSenServiceConnection instance.
        *                       The pointer is left on the cleanup stack.
        */    
        IMPORT_C static CSenServiceConnection* NewLC(MSenServiceConsumer& aConsumer,
                                                     const TDesC8& aContract,
                                                     MSenExtendedConsumerInterface& aExtendedConsumer);
    
        /**
        * Two-phased constructor using a service description.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aConsumer connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection.
        * @param 	aAuthProvider      Authentication Provider                
        * @return   a pointer to a CSenServiceConnection instance.
        */    
        IMPORT_C static CSenServiceConnection* NewL(MSenServiceConsumer& aConsumer,
                                                    MSenServiceDescription& aServiceDescription,
                                                    MSenExtendedConsumerInterface& aExtendedConsumer);
    
        /**
        * Two-phased constructor using a service description. The pointer
        * is left on the cleanup stack.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() AND
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aConsumer connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection.
        * @param 	aAuthProvider      Authentication Provider                        
        * @return   a pointer to a CSenServiceConnection instance.
        *               The pointer is left on the cleanup stack.
        */    
        IMPORT_C static CSenServiceConnection* NewLC(MSenServiceConsumer& aConsumer,
                                                     MSenServiceDescription& aServiceDescription,
                                                     MSenExtendedConsumerInterface& aExtendedConsumer);
    
        /*
        * The ServicePattern version of two phased constructor. 
        * Note, that this method is intended to be used by service consumers
        * wishing to initialize connection in specific context called
        * consumer policy. In consumer policy, certain properties 
        * can be set to further define what kind of connection is acceptable
        * and how the connection interacts with transport (for example, which
        * Internet Access Point (IAP) will be used).
        * However, any ConsumerPolicy feature is applicable in 
        * one-policy-per-client scope and not used as a common policy.
        * To set permanent information about known WSP, please use the
        * CSenXmlServiceDescription, which implements MSenProviderPolicy
        * interface.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aConsumer connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection.
        * @param 	aAuthProvider      Authentication Provider                                 
        * @return   a pointer to a CSenServiceConnection instance.
        */    
        IMPORT_C static CSenServiceConnection* NewL(MSenServiceConsumer& aConsumer,
                                                    CSenServicePattern& aServicePattern,
                                                    MSenExtendedConsumerInterface& aExtendedConsumer);

        /*
        * The ServicePattern version of two phased constructor. 
        * Note, that this method is intended to be used by service consumers
        * wishing to initialize connection in specific context called
        * consumer policy. In consumer policy, certain properties 
        * can be set to further define what kind of connection is acceptable
        * and how the connection interacts with transport (for example, which
        * Internet Access Point (IAP) will be used).
        * However, any ConsumerPolicy feature is applicable in 
        * one-policy-per-client scope and not used as a common policy.
        * To set permanent information about known WSP, please use the
        * CSenXmlServiceDescription, which implements MSenProviderPolicy
        * interface.
        * This constructor is ASYNCHRONOUS and the actual state of
        * created connection has to be observed from SetStatus() and
        * HandleErrorL() functions.
        * If service is found, the SetStatus() call-back is executed
        * with a status value KSenConnectionStatusReady (1)
        * For ID-WSF connections, the authentication for the Web Service
        * Provider (WSP) connection is resolved using one of the identity 
        * providers which have been associated with the contract found in 
        * the SD. At minimum, the contract of the service (typically some URN)
        * has to provided in the SD.
        * Basic Web Service consumers instantiate a SD where an endpoint
        * and framework ID KDefaultBasicWebServicesFrameworkID are defined.
        * @param    aConsumer connection observer.
        * @param    aServiceDescription is the description used to
        *               obtain a service connection.
        * @param 	aAuthProvider      Authentication Provider                                          
        * @return   a pointer to a CSenServiceConnection instance.
        *               The pointer is left on the cleanup stack.
        */
        IMPORT_C static CSenServiceConnection* NewLC(MSenServiceConsumer& aConsumer,
                                                     CSenServicePattern& aServicePattern,
                                                     MSenExtendedConsumerInterface& aExtendedConsumer);

        // New functions

        /**
        * Send an ASYNCHRONOUS request to a service.
        * In ID-WSF, the request data is a SOAP Body.
        * Response message is received either via 
        * HandleMessageL() or HandleErrorL() callback.
        * There are two default frameworks available - 
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that Basic Web Services framework does NOT support this method.
        * Instead, one should send complete SOAP envelopes using SendL(CSenSoapEnvelope&).
        * So, currently this method is supported only in ID-WSF.
        * @param aRequest outgoing request message.
        * @return Transaction ID (positive integer) or error code, if method fails.
        * Transaction ids:
        * Positive integers                 SendL returns transaction ID of the request,
        *                                   which can be later on utilized inside
        *                                   HandleMessageL and HandleErrorL methods,
        *                                   in order to map request and its response
        *                                   together.
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Credential for the connection is 
        *                                   expired and needs to be renewed. 
        *                                   This can be done by instantiating a new
        *                                   ServiceConnection.
        * KErrSubmitting                    An error occurred
        * KErrNoMemory                      Not enough memory to process the message.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SendL(const TDesC8& aRequest) = 0;


        /**
        * Submit a synchronous request to a service
        * (in ID-WSF, the SOAP message Body) and receive a response as XML.
        * There are two default frameworks available -
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that Basic Web Services framework does NOT support this method.
        * Instead, one must send complete SOAP envelopes using SubmitL(CSenSoapEnvelope&).
        * So, currently this method is supported only in ID-WSF.
        * @param aRequest outgoing request message.
        * @param aResponse the resolved response message.
        *        The ownership of the aResponse is transfered to the caller.
        *        The response is service specific part of the response. 
        *        For ID-WSF services response contents is the SOAP Body, or complete SOAP 
        *        envelope as XML, depending on the complete server messages on/off setting 
        *       (default is off).
        * @return status/error code.
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Credential for the connection is 
        *                                   expired and needs to be renewed. 
        *                                   This can be done by instantiating a new
        *                                   ServiceConnection.
        * KErrSubmitting                    An internal error occurred.
        * KErrSenInternal                   Internal state is invalid.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SubmitL(const TDesC8& aRequest, HBufC8*& aResponse) = 0;

        
        /**
        * Consumer application can use this method to check that 
        * service connection is in ready state.
        * In ID-WSF, this means that WSF interprets that credentials 
        * for the service connection are valid (not expired).
        * @param aReady indicates that the connection is ready to be used.
        * @return           status/error code.
        * Status codes:
        * KErrNone               ok
        * Error codes are system-wide Symbian error codes.
        */
        virtual TInt IsReady(TBool& aReady) = 0;


        /**
        * Check if the underlying service connection has a certain characteristic
        * called a facet.
        * Currently, only ID-WSF framework supports facets.
        * For example, if consumer application is interested to resolve if 
        * initialized service connection has a facet indicating that service
        * is free of charge (for e.g. "urn:framework.com.free:cost"), the 
        * method used to check this would be:
        * _LIT8(KFacetOfFreeService, "urn:some.service.free:cost");
        * int err = HasFacetL(KFacetOfFreeService, hasFacet);
        *
        * In the service session of initialed connection, this would be the form 
        * of the facet element:
        * <Facet name="urn:framework.com.free:cost"/>
        *
        * If there is no facet in the service connection then the element is not
        * present.
        * @param aURI           the name of the facet
        * @param aHasFacet      will indicate if underlying service has a certain
        *                       characteristic.
        * @return status/error code.
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrBadDescriptor                 The aUri parameter was an invalid
        *                                   descriptor.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt HasFacetL(const TDesC8& aURI, TBool& aHasFacet) = 0;


        /**
        * Consumer application can use this method to set flag which defines
        * whether or not the consumer wishes to receive complete SOAP envelope 
        * from the service.
        * If complete server messages mode is off, then only the <Body> element
        * is received from the SOAP envelope, otherwise full SOAP envelope.
        * Note: Calling this function must not be done before connection is 
        * initialized (the observer's SetStatus() has been called with value 
        * KSenConnectionStatusReady).
        * Calling this function should be done before sending or submitting
        * anything.
        * @param aCompleteOnOff defines the content of HandleMessageL() callback.   
        *              If set to ETrue (ON), then complete SOAP envelopes are
        *              received, including <Header> element.
        *              If set to EFalse (OFF), only the service specific
        *              content - SOAP envelope <Body> element - is received.
        *              In WSF frameworks the default settings are:
        *              1. In ID-WSF, the complete server messages is OFF.
        *              2. In Basic Web Services, the default is ON.
        * @return status/error code.
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt CompleteServerMessagesOnOff(const TBool& aCompleteOnOff) = 0;


        /*
        * Sends a SOAP message to the service. The SOAP envelope may contain
        * proprietary headers. The system will augment the message with the
        * appropriate headers specified in the service invocation framework,
        * so a client application should add only non-standard headers; and
        * if it doesn't need to set such headers it is strongly recommended
        * to use SendL(TDesC8&), which is meant for that.
        * This is an asynchronous function, that returns immediately.
        * When the service responds, the SOAP envelope content will
        * be received via HandleMessageL() callback. In case of an
        * error - like a SOAP fault - HandleErrorL() will be called
        * with appropriate error code.
        * There are two default frameworks available -
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that ID-WSF does NOT support this method. 
        * Instead, one should send SOAP envelope Bodies using 
        * SendL(const TDesC8&).
        * So, currently this method is supported only in Basic Web Services framework.
        * @param aMessage  The service specific message - a full SOAP envelope 
        * @return Transaction ID (positive integer) or error code, if method fails.
        * Transaction ids:
        * Positive integers                 SendL returns transaction ID of the request,
        *                                   which can be later on utilized inside
        *                                   HandleMessageL and HandleErrorL methods,
        *                                   in order to map request and its response
        *                                   together.
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SendL(CSenSoapEnvelope& aMessage) = 0;


        /*
        * Submits a SOAP message to the service. This is a synchronous call,
        * returning  a SOAP envelope that was received from the service.
        * There are two default frameworks available:
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that ID-WSF does NOT support this method. 
        * Instead, one should send SOAP envelope Bodies using SendL(const TDesC8&).
        * So, currently this method is supported only in Basic Web Services framework.
        * @param    aMessage SOAPEnvelope with the service specific message
        *                    without any framework wrapping
        * @param    aResponseTo  This is a ref-to-pointer where response 
        *                        from the service will be allocated. If the
        *                        complete server messages mode is set to OFF,
        *                        then only <Body> element will be returned, 
        *                        otherwise a complete SOAP envelope.
        *                        The ownership of aResponse is transfered to 
        *                        the caller.
        * @return status/error code
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * KErrSenInternal                   Internal state is invalid.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SubmitL(CSenSoapEnvelope& aMessage, HBufC8*& aResponseTo) = 0;


        /**
        * Gets service description of current connection.
        * @param aServiceDescription Contains the service description on return
        * @return status/error code.
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrUnderFlow                     Server side returned invalid service
        *                                   description.
        * KErrUnknown                       Client-Server request mismatch.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt ServiceDescriptionL(HBufC8*& aServiceDescription) = 0;


        /**
        * Starts an application level transaction. The consumer may now start 
        * to communicate with some service withing a chain of correlated messages.
        * When responding to a certain SOAP message inside a transaction, the last
        * received message ID is used as "refToMessageId". 
        * From default frameworks, only ID-WSF supports transactions.
        * @return   KErrNone if no errors occur.
        *           Other error codes are system-wide Symbian error codes.
        */
        virtual TInt StartTransaction() = 0;


        /**
        * Stops application level transaction by resetting the "refToMessageId".
        * After stopping a transaction the next message will have no 
        * "refToMessageId"
        * @return   KErrNone if no errors occur.
        *           Other error codes are system-wide Symbian error codes.
        */
        virtual TInt TransactionCompleted() = 0;


        /*
        * Returns the transasction ID of this message or error. Id is guaranteed
        * to return unique ID  when called from inside HandleMessageL() or 
        * HandleErrorL callback. This transasction ID may be used to map the 
        * response with the preceedeing SendL() call (a request).
        * @return TInt transaction ID, or KErrNotFound, if no transaction is
        * on-going.
        */
        virtual TInt TxnId() = 0;


        /**
        * Sets transport specific properties which apply as long as this connection
        * is alive (session). Furthermore, the properties are effective for this session
        * in cumulative manner: each property has unique key (name) which is associated
        * to the actual value of that property. When SetTransportPropertiesL method is 
        * called multiple times - in sequence - the last value for each key overrides any
        * previous definitions. If any latter call introduces new keys (property names),
        * they are appended to the list of currently effective properties. 
        * Also note, that it is also possible to set message specific properties when making
        * a SendL/SubmitL call. If such transport properties for message are provided, and
        * those include updates to some properties, the new ones are effective only for that
        * certain message, i.e. those are transaction specific. For any following message,
        * that is sent over a service connection, the session specific properties apply,
        * assuming that the new message does not (again) override some of the property values.
        * @param aProperties contains the transport properties in serialized (UTF-8) form.
        * With HTTP, this descriptor is typically created by utilizing CSenHttpProperties class.
        * @return KErrNone if successful or otherwise some system-wide error code.
        */
        virtual TInt SetTransportPropertiesL(const TDesC8& aProperties) = 0;


        /*
        * Method returns currently effective transport properties as a serialized
        * descriptor. With HTTP, one may utilize CSenHttpProperities class in
        * order to read this data into properties object. Note that returned 
        * list of properties also includes properties, which are defined as default
        * for certain transport in the webservice framework.
        */
        virtual TInt TransportPropertiesL(HBufC8*& aProperties) = 0;


        /**
        * Send an ASYNCHRONOUS request to a service.
        * In ID-WSF, the request data is a SOAP Body.
        * Response message is received either via 
        * HandleMessageL() or HandleErrorL() callback.
        * There are two default frameworks available - 
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that Basic Web Services framework does NOT support this method.
        * Instead, one should send complete SOAP envelopes using SendL(CSenSoapEnvelope&).
        * So, currently this method is supported only in ID-WSF.
        * @param aRequest outgoing request message.
        * @param aProperties contains transport spesific properties, serialized
        * into descriptor. With HTTP, one can create this by utilizing specialized
        * CSenHttpProperties class.
        * @return Transaction ID (positive integer) or error code, if method fails.
        * Transaction ids:
        * Positive integers                 SendL returns transaction ID of the request,
        *                                   which can be later on utilized inside
        *                                   HandleMessageL and HandleErrorL methods,
        *                                   in order to map request and its response
        *                                   together.
        * Error codes
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Credential for the connection is 
        *                                   expired and needs to be renewed. 
        *                                   This can be done by instantiating a new
        *                                   ServiceConnection.
        * KErrSubmitting                    An error occurred
        * KErrNoMemory                      Not enough memory to process the message.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SendL(const TDesC8& aRequest, const TDesC8& aProperties) = 0;

        
        /**
        * Submit a request via SYNCHRONOUS call to a service
        * (in ID-WSF, the SOAP message Body) and receive a response as XML.
        * There are two default frameworks available -
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that Basic Web Services framework does NOT support this method.
        * Instead, one must send complete SOAP envelopes using SubmitL(CSenSoapEnvelope&).
        * So, currently this method is supported only in ID-WSF.
        * @param aRequest outgoing request message.
        * @param aResponse the resolved response message.
        *        The ownership of the aResponse is transfered to the caller.
        *        The response is service specific part of the response. 
        *        For ID-WSF services response contents is the SOAP Body, or complete SOAP 
        *        envelope as XML, depending on the complete server messages on/off setting 
        *       (default is off).
        * @param aProperties contains transport spesific properties, serialized
        * into descriptor. With HTTP, one can create this by utilizing specialized
        * CSenHttpProperties class.
        * @return status/error code.
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Credential for the connection is 
        *                                   expired and needs to be renewed. 
        *                                   This can be done by instantiating a new
        *                                   ServiceConnection.
        * KErrSubmitting                    An internal error occurred.
        * KErrSenInternal                   Internal state is invalid.
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SubmitL(const TDesC8& aRequest, const TDesC8& aProperties, HBufC8*& aResponse) = 0;


        /*
        * Sends a SOAP message to the service. The SOAP envelope may contain
        * proprietary headers. The system will augment the message with the
        * appropriate headers specified in the service invocation framework,
        * so a client application should add only non-standard headers; and
        * if it doesn't need to set such headers it is strongly recommended
        * to use SendL(TDesC8&), which is meant for this.
        * This is an asynchronous function, that returns immediately.
        * When the service responds, the SOAP envelope content will
        * be received via HandleMessageL() callback. In case of an
        * error - like a SOAP fault - HandleErrorL() will be called
        * with appropriate error code.
        * There are two default frameworks available -
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that ID-WSF does NOT support this method. 
        * Instead, one should send SOAP envelope Bodies using 
        * SendL(const TDesC8&).
        * So, currently this method is supported only in Basic Web Services framework.
        *
        * NOTE:
        * Message is send as serialized XML or Soap message to SendL 
        * aProperties could be "HTTP GET" or "HTTP DELETE"  
        * HTTP GET or HTTP DELETE transport property has been enabled via CSenHttpTransportProperties. 
        * This scenario is not supported  
        *
        * @param aMessage  The service specific message - a full SOAP envelope 
        * @param aProperties contains transport spesific properties, serialized
        * into descriptor. With HTTP, one can create this by utilizing specialized
        * CSenHttpProperties class.
        * @return Transaction ID (positive integer) or error code, if method fails.
        * Transaction ids:
        * Positive integers                 SendL returns transaction ID of the request,
        *                                   which can be later on utilized inside
        *                                   HandleMessageL and HandleErrorL methods,
        *                                   in order to map request and its response
        *                                   together.
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * KErrNotSupported					HTTP GET or HTTP DELETE is enabled        
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SendL(CSenSoapEnvelope& aMessage, const TDesC8& aProperties) = 0;

        /*
        * Submits a SOAP message to the service. This is a synchronous call,
        * returning  a SOAP envelope that was received from the service.
        * There are two default frameworks available:
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that ID-WSF does NOT support this method. 
        * Instead, one should send SOAP envelope Bodies using SendL(const TDesC8&).
        * So, currently this method is supported only in Basic Web Services framework.
        *
        * NOTE:
        * Message is send as serialized XML or Soap message to SubmitL 
        * aProperties could be "HTTP GET" or "HTTP DELETE"  
        * HTTP GET or HTTP DELETE transport property has been enabled via CSenHttpTransportProperties. 
        * This scenario is not supported
        *
        * @param aMessage SOAPEnvelope with the service specific message
        * without any framework wrapping
        * @param aProperties contains transport spesific properties, serialized
        * into descriptor. With HTTP, one can create this by utilizing specialized
        * CSenHttpProperties class.
        * @param    aResponseTo  This is a ref-to-pointer where response 
        *                        from the service will be allocated. If the
        *                        complete server messages mode is set to OFF,
        *                        then only <Body> element will be returned, 
        *                        otherwise a complete SOAP envelope.
        *                        The ownership of aResponse is transfered to 
        *                        the caller.
        * @return status/error code
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * KErrSenInternal                   Internal state is invalid.
        * KErrNotSupported					HTTP GET or HTTP DELETE is enabled        
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SubmitL(CSenSoapEnvelope& aMessage, const TDesC8& aProperties, HBufC8*& aResponseTo) = 0;

        /*
        * Sends a SOAP message to the service. The SOAP envelope may contain
        * proprietary headers. The system will augment the message with the
        * appropriate headers specified in the service invocation framework,
        * so a client application should add only non-standard headers.
        * This is an asynchronous function, that returns immediately.
        * When the service responds, the SOAP envelope content will
        * be received via HandleMessageL() callback. In case of an
        * error - like a SOAP fault - HandleErrorL() will be called
        * with appropriate error code.
        * There are two default frameworks available -
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that ID-WSF does NOT support this method. 
        * Instead, one should send SOAP envelope Bodies using 
        * SendL(const TDesC8&).
        * So, currently this method is supported only in Basic Web Services framework.
        *
        * @param aMessage  The service specific message - a full SOAP envelope 
        * @return Transaction ID (positive integer) or error code, if method fails.
        * Transaction ids:
        * Positive integers                 SendL returns transaction ID of the request,
        *                                   which can be later on utilized inside
        *                                   HandleMessageL and HandleErrorL methods,
        *                                   in order to map request and its response
        *                                   together.
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * KErrNotSupported					HTTP GET or HTTP DELETE is enabled
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SendL(MSenMessage& aMessage) = 0;

        /*
        * Submits a SOAP message to the service. This is a synchronous call,
        * returning  a SOAP envelope that was received from the service.
        * There are two default frameworks available:
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that ID-WSF does NOT support this method. 
        * Instead, one should send SOAP envelope Bodies using SendL(const TDesC8&).
        * So, currently this method is supported only in Basic Web Services framework.
        *
        * @param aMessage SOAPEnvelope with the service specific message
        * without any framework wrapping
        * @param    aResponseTo  This is a ref-to-pointer where response 
        *                        from the service will be allocated. If the
        *                        complete server messages mode is set to OFF,
        *                        then only <Body> element will be returned, 
        *                        otherwise a complete SOAP envelope.
        *                        The ownership of aResponse is transfered to 
        *                        the caller.
        * @return status/error code
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * KErrSenInternal                   Internal state is invalid.
        * KErrNotSupported					HTTP GET or HTTP DELETE is enabled
        * Other error codes are system-wide Symbian error codes.
        */
        virtual TInt SubmitL(MSenMessage& aMessage, CSenSoapEnvelope2*& aResponseTo) = 0;
        
        /**
        * Getter for currently active transaction (service response) that is
        * being handled by the service consumer.
        * @return a pointer to currently active transaction (service response).
        *         It is guarenteed, that the method returns a pointer to
        *         transaction only when called inside HandleMessageL or
        *         HandleErrorL callback methods of MSenServiceConsumer,
        *         otherwise it will return NULL.
        */
        virtual MSenMessage* Response() = 0;
        
        /**
        * Cancels any active request, if pending transaction 
        * (txn) can be found with given txn ID.
        * @param aTransactionID is the transaction ID to be cancelled. This id has earlier been
        * acquired from a call to some of the asynchronous SendL variants.

        * @return KErrNone on success
        *         KErrNotFound, if there is no pending transaction (active request),
        *         or some of the system-wide error codes otheriwise.
        */
        virtual TInt CancelTransaction(TInt aTransactionID) = 0;
        
        /**
        * Getter for the identity provider (XML) service description. 
        * @param apIdentityProvider will point to a new IDP instance,
        * if such is associated with this connection (and this connection
        * was ready before calling this method), or NULL otherwise.
        * @return KErrNone if IDP description can be found, or some
        * of the system wide error code otherwise.
        */
        virtual TInt IdentityProviderL(CSenIdentityProvider*& apIdentityProvider) = 0;

        /**
        * Getter for the identifier  of this connection.
        * @return the identifier as integer.
        */
        virtual TInt Identifier() = 0;
        
        /**
        * Registers observer of BLOBs transfer progress.
        *
        * @param aFilesObserver Implementation of transfer progress observer.
        */
    
		virtual void DataTrafficDetails(TSenDataTrafficDetails& aDetails,
    									TSenDataTrafficOperations& aOperations) = 0;     
		
        /**
        * Service Consumer can call this method to acquire a new interface,
        * which is identified by unique ID (UID).
        * @param aUID is the UID of the interface being requested
        * @return TAny* pointer to the interface, or if no interface to 
        * given UID exists, function returns NULL. In typical cases, returned
        * pointer should be cast to some preknown M-class pointer (the actual
        * new interface).
        *
        * List of currently supported interfaces:
        * KSenInterfaceUidAlrServiceConnection      => MSenAlrServiceConnection
        */    
	    virtual TAny* InterfaceByUid( TUid aUID ) = 0;
		
        /*
        * Sends a RFile Handle to the service. 
        * the Identity Based Web Service Framework (which ID is "ID-WSF") 
        * and the Basic Web Services Framework (which ID is "WS-I"). 
        * Please note, that ID-WSF does NOT support this method. 
				* SendL(const TDesC8&).
        * So, currently this method is supported only in Basic Web Services framework.
        * @param aMessage  The service specific message - a full SOAP envelope 
        * @return Transaction ID (positive integer) or error code, if method fails.
        * Transaction ids:
        * Positive integers                 SendL returns transaction ID of the request,
        *                                   which can be later on utilized inside
        *                                   HandleMessageL and HandleErrorL methods,
        *                                   in order to map request and its response
        *                                   together.
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrArgument                      RFile handle is NULL ( Specified file doesnot exist)
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * Other error codes are system-wide Symbian error codes.
        */
				virtual TInt SendL(RFile& aFileHandle) = 0;
				
				/*
        * Submits a RFile Handle to the service. This is a synchronous call,
        * returning  a SOAP envelope that was received from the service.
        * There are two default frameworks available:
        * @param    aResponseTo  This is a ref-to-pointer where response 
        *                        from the service will be allocated. If the
        *                        complete server messages mode is set to OFF,
        *                        then only <Body> element will be returned, 
        *                        otherwise a complete SOAP envelope.
        *                        The ownership of aResponse is transfered to 
        *                        the caller.
        * @return status/error code
        * Status codes:
        * KErrNone                          ok
        * Error codes:
        * KErrSenNotInitialized             Connection has not been initialized.
        * KErrSenServiceConnectionBusy      Connection is already busy with another
        *                                   request.
        * KErrConnectionInitializing        Connection is still initializing and
        *                                   cannot yet process commands.
        * KErrConnectionExpired             Connection is expired and needs to be
        *                                   renewed.
        * KErrSubmitting                    An internal error has occurred.
        * KErrNoMemory                      Not enough memory to process the 
        *                                   message.
        * KErrArgument                      RFile handle is NULL ( Specified file doesnot exist)
        * KErrSenInternal                   Internal state is invalid.
        * Other error codes are system-wide Symbian error codes.
        */
		virtual TInt SubmitL(RFile& aFileHandle, HBufC8*& aResponseTo) = 0;
		   
    protected:
        
        /**
        * C++ default constructor.
        */
        CSenServiceConnection();
    
    };

#endif //SEN_SERVICE_CONNECTION_H

// End of File

