/*

* 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 SEN_SERVICE_SESSION_H

#define SEN_SERVICE_SESSION_H

//  INCLUDES

#include <e32base.h>

#include <e32des8.h>

#include <e32std.h>

#include "senwsdescription.h"

#include <SenFacet.h>

#include "msenremoteservicesession.h"

#include "msenservicesession.h"

#include "msenserviceinvocationframework.h"

#include "MSenServiceConsumer.h"

#include "msenremoteserviceconsumer.h"

#include "msencoreservicemanager.h"

// CONSTANTS

_LIT8(KMessageThread, "urn:com.nokia.serene.facet.message-thread");

// DATA TYPES

typedef RPointerArray<MSenRemoteServiceConsumer> RServiceConsumerArray;

// FORWARD DECLARATIONS

class CSIF;

class CSenTransportBase;

class MSenRemoteHostlet;

// CLASS DECLARATION

class CSenServiceSession :  public CSenWSDescription,

                            public MSenRemoteServiceSession,

                            public MSenServiceSession

    {

    public:

        // New functions

        IMPORT_C virtual TInt InitializeFromL(MSenServiceDescription& aServiceDescription);

        /**

        * Parse the service session related information out of a message

        * sent by the service. Default is to do nothing.

        * Subclasses should override this.

        * @param    aString containing a message received from a service.

        * @param    String with parsed data

        * @return TInt - a KErrNone or error

        */

        IMPORT_C virtual TInt ParseResponseL(const TDesC8& aInput,

                                             HBufC8*& aOutput);

        /**

         * Ask the core service manager to save this service session into

         * XML DAO database.

         *

         * This convenience method can be called from within other methods of

         * this class or subclass, or by some service invocation framework

         * implementations.

         * Leave codes: Symbian system-wide error codes.

         */

        IMPORT_C virtual void SaveL();

        /**

        * This getter method does not trigger any execution, it just returns

        * the current status of this session.

        * @return  TInt the status of this service session.

        */

        IMPORT_C virtual TInt StatusL();

        /**

        * Compute the status of the ServiceSession. If the status

        * changes to (or from) of "KSenConnectionStatusReady"

        * the service consumers are notified. Internally, method

        * calls ComputeStatusL().

        * @return TInt status code indicating the current status,

        *  which may have changed when this method was executed.

        *  

        */

        IMPORT_C virtual TInt SetStatusL();

        /**

        * Method computes the current status of this service session.

        * Subclasses typically override this. Method does NOT set

        * the internal status variable of this class and so it NEITHER

        * notifies consumer(s) about the computed result.

        * @return integer (TInt), which indicates current, but only 

        * computed status of this service session.

        */

        IMPORT_C virtual TInt ComputeStatusL();

        /**

        * Adds a service consumer for this session.

        *

        * This service consumer will be notified of service responses

        * (to it's own queries) and of all status changes.

        * This method needs to be implemented -- often some 

        * service invocation framework specific subclass.

        * @param aConsumer is the service consumer object that exposes 

        * the MSenRemoteServiceConsumer interface. Typically some 

        * Symbian server-side session, which represents "remote"

        * consumer application, separate process behind IPC boundary.

        * @return KErrNone or some system-wide error code

        */

        virtual TInt AddConsumerL(MSenRemoteServiceConsumer& aConsumer) = 0;

        // from MSenRemoteServiceSession

        IMPORT_C TInt RemoveConsumerL(MSenRemoteServiceConsumer& aConsumer);

        /**

        * Return a iterator over a list with the consumers (clients) of this

        * ServiceSession.

        * This method is called from within several other methods of the abstract

        * ServiceSession class.

        * This method should be implemented by a subclass

        * specific to a ServiceInvocationFramework implementation.

        * Ownership of the aConsumers is NOT transfered to the caller.

        * @param    aConsumers  List of the current consumers.

        *           Owned by ServiceSession.

        * @return  TInt - a KErrNone or error

        */

        virtual TInt Consumers(RServiceConsumerArray& aConsumers) const = 0;

        // Functions from base classes

        // from MSenRemoteServiceSession

        IMPORT_C virtual TInt SetTransportPropertiesL(const TDesC8& aProperties,

                                                      MSenRemoteServiceConsumer& aConsumer);

        IMPORT_C virtual TInt TransportPropertiesL(HBufC8*& aProperties,

                                                   MSenRemoteServiceConsumer& aConsumer);

        IMPORT_C virtual TInt SubmitL(const TDesC8& aMessage, 

                                      const TDesC8& aTransportProperties,

                                      MSenRemoteServiceConsumer& aConsumer,

                                      HBufC8*& aResponse);

        IMPORT_C virtual TInt SendL( const TDesC8& aMessage, 

                                     const TDesC8& aTransportProperties,

                                     MSenRemoteServiceConsumer& aConsumer,

                                     TInt& aTxnId,

                                     HBufC8*& aRevalidationError );

        virtual TInt SubmitSoapL(const TDesC8& aSoapMessage, 

                                 const TDesC8& aTransportProperties,

                                 MSenRemoteServiceConsumer& aConsumer,

                                 HBufC8*& aResponse) = 0;

        virtual TInt SendSoapL( const TDesC8& aSoapMessage, 

                                const TDesC8& aTransportProperties,

                                MSenRemoteServiceConsumer& aConsumer,

                                TInt& aTxnId,

                                HBufC8*& aRevalidationError ) = 0;

        // from MSenServiceDescription

        IMPORT_C virtual TBool Matches(MSenServiceDescription& aPattern);

        IMPORT_C virtual TInt HasFacetL(const TDesC8& aURI, TBool& aHasFacet);

        IMPORT_C virtual TInt FacetValue(TDesC8& aURI, HBufC8*& aValueTo);

        IMPORT_C virtual TInt AddFacetL(const CSenFacet& aFacet);

        IMPORT_C virtual TInt SetFacetL(const CSenFacet& aFacet);

        IMPORT_C virtual TInt RemoveFacet(const TDesC8& aURI);

        IMPORT_C virtual TInt FacetsL(RFacetArray& aFacetArray);

        IMPORT_C virtual TInt ScoreMatchL(MSenServiceDescription& aPattern);

        // from MSenRemoteServiceSession

        IMPORT_C virtual TBool IsReadyL(); // This method equals with isValid() in Java ref-impl

        IMPORT_C virtual TInt CompleteServerMessagesOnOffL(const TBool& aCompleteOnOff);

        // from CSenWSDescription (overrides)

        virtual void SetContractL(const TDesC8& aContract) = 0;

        virtual void SetEndPointL(const TDesC8& aEndPoint) = 0;

        virtual TPtrC8 FrameworkVersion() = 0;

        // implement the MSenRemoteServiceSession:

        IMPORT_C virtual TPtrC8 Endpoint();

        IMPORT_C virtual TPtrC8 Contract();

        IMPORT_C TPtrC8 FrameworkId();

        IMPORT_C virtual MSenRemoteServiceConsumer* RemoteConsumerL(const TDesC8& aSenderID);

        IMPORT_C virtual void WriteExtensionsAsXMLToL(RWriteStream& aWriteStream);

        IMPORT_C MSenServiceDescription::TDescriptionClassType DescriptionClassType();

        IMPORT_C MSenServiceDescription& AsServiceDescription();

        IMPORT_C void SetTransportL(CSenTransportBase* aTransport);

        IMPORT_C MSenTransport* Transport() const;

        IMPORT_C MSenTransport& TransportL(MSenRemoteServiceConsumer& aRequestor);

        // Destructor

        IMPORT_C virtual ~CSenServiceSession();

        // From MSenServiceSession:

        virtual TInt SendToConsumerL(HBufC8* apMessage,

                                     const TInt aTxnId,

                                     MSenRemoteServiceConsumer& aConsumer,

                                     MSenProperties* aResponseTransportProperties = NULL) = 0; 

        virtual TInt SendErrorToConsumerL(const TInt aErrorCode,

                                          HBufC8* apError,

                                          const TInt aTxnId,

                                          MSenRemoteServiceConsumer& aConsumer,

                                          MSenProperties* aResponseTransportProperties = NULL) = 0; 

        /**

        * In addition of meeting the MSenServiceSession interface, service session

        * extends this method to be available for the sessions (frameworks) themselves:

        * any session class implementation should override this method in order to 

        * provide a possibility for the service invocation framework to recover from 

        * particular (SOAP and other) errors.

        *

        * @param aErrorCode is the error code identifying this error

        * @param aError is the error message - actual response from service

        * @param aConsumer is the consumer of the service. It could

        * be CSenClientSession or some subclass of CSenInternalConsumer

        * (like in Liberty ID-WSF it could be authentication service client

        * or discovery service client).

        * @param aTxnId is the transaction id of this async responsed error.

        * @param aResponseTransportProperties includes the response properties

        * from transport

        * @return KErrNone if error message was successfully delivered to 

        *         consumer(s). Otherwise, some system-wide error code.

        */

        virtual TInt HandleErrorL(const TInt aErrorCode,

                                  HBufC8* apError,

                                  const TInt aTxnId,

                                  MSenRemoteServiceConsumer& aConsumer,

                                  MSenProperties* aResponseTransportProperties = NULL) = 0; 

        // from MSenRemoteHostlet:

        IMPORT_C TInt SetHostletL(MSenRemoteHostlet* aHostlet);

        IMPORT_C MSenRemoteHostlet* Hostlet() const;

        // From MSenServiceSession:

        IMPORT_C virtual TInt SendToHostletL(MSenRemoteHostlet& aReceiver,

                                             const TDesC8& aMessage,

                                             const TInt aTxnId,

                                             MSenRemoteServiceConsumer& aFrom,

                                             MSenProperties* aProperties);

        IMPORT_C virtual TInt ProvideHostletResponseL( MSenRemoteHostlet& aProvider,

                                                       const TInt aTxnId,

                                                       const TInt aServiceCode,

                                                       const TDesC8& aRecipientsConsumerId,

                                                       CSenChunk& aMessageChunk );

        // From CSenWSDescription:

        IMPORT_C virtual TBool HasSuperClass( TDescriptionClassType aType );

        IMPORT_C virtual TInt SetTransportCueL(const TDesC8& aCue);

        IMPORT_C virtual TPtrC8 TransportCue();

//new

        IMPORT_C virtual TInt RefreshMTL(HBufC8*& aRevalidationError);

    protected: 

        /**

        * C++ default constructor.

        */

        IMPORT_C CSenServiceSession(TDescriptionClassType aType, MSIF& aFramework);

        /**

        * BaseConstructL is made available for subclasses, since they should call

        * it in their own ConstructL or BaseConstructL method.

        */

        IMPORT_C void BaseConstructL();

        // Filelogging method:

        IMPORT_C RFileLogger* Log() const;

        /**

        * Note that this non-virtual method allows subclasses to notify about following

        * *pre-state* kind of status codes ONLY (from SenServiceConnection.h):

        *

        * const TInt KSenConnectionStatusAuthentication       =   3; // pre-state

        * const TInt KSenConnectionStatusDiscovery            =   4; // pre-state

        * const TInt KSenConnectionStatusMetadataExchange     =   5; // pre-state

        *

        * In other words, this method cannot be used in credential state notfications (valid / expired).

        */

        //void SendStatusToConsumersL(const TInt aStatus);

        TInt                    iStatus;

    protected: // Data

        MSIF&                   iFramework;     // Not owned

        RServiceConsumerArray   iConsumerList;  

        MSenRemoteHostlet*      ipHostlet;      // Not owned

    private: // Data

        //TInt                    iStatus;

        RFacetArray             iFacets;        // Owned 

        CSenTransportBase*      ipTransport;     // Owned

        TBool                   iTransportOwned;

    };

#endif // SEN_SERVICE_SESSION_H

// End of File