/*
* Copyright (c) 2002-2004 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: Classes used to describe IMSP CSP session.
*              Major for Imps Session.
*/


#ifndef CImpsSession_H
#define CImpsSession_H

//  INCLUDES
#include <e32base.h>
#include "impsclientsrv.h"

// FORWARD DECLARATIONS
class CImpsServer;
class CImpsSubSession;
class CImpsVariant;

// CLASS DECLARATION

/**
*  Common event for all client session types
*/
class CWvEvent : public CBase    // a notify event
    {
    public:
        CWvEvent( TImpsEventType aType );
        ~CWvEvent();
        void Destroy();

        TImpsEventType      iType;      // notification type, see impsconst.h
        TImpsServRequest    iRequestType;
        TImpsMessageType    iMessageType;  // response message
        TInt                iReqMesType;   // request type
        TBool               iSent;      // sent to client
        TInt                iOpCode;    // op-id
        TInt                iStatus;
        TInt                iAux;       // auxiliary for small data
        HBufC8*             iPackedMessage;
        TDblQueLink         iLink;
    };

/**
*  Common request data for all service session types
*/
class CRequest : public CBase
    {
    public:
        CRequest(
            const TDesC& aTID,
            TInt aOpId,
            TImpsServRequest aRequestType,
            TTime aExpiry,
            TImpsMessageType aMessageType );
        ~CRequest();
        void Destroy();

        TBuf<KImpsMaxTID> iTID;          // CSP TID
        TInt             iOpId;
        TImpsServRequest iRequestType;
        TImpsMessageType iMessageType;
        TTime            iExpiry;
        TDblQueLink      iLink;
    };


/**
*  SOS Client-server framework session for WV engine
*/
class CImpsSession : public CSession2
    {
    public:  // Constructors and destructor

        /**
        * C++ default constructor.
        * @param aClient client thread
        */
        CImpsSession( RMessage2& aMsg );

        /**
        * Destructor.
        */
        virtual ~CImpsSession();

    public: // New functions

        /**
        * Handles a client request; tests the opcode and gives
        * service according to that. ServiceL calls this.
        * @param aMessage service request from client
        */
        void DispatchMessageL( const RMessage2& aMessage );

        /**
        * Search pending request using CSP transaction-id
        * @param aTid transaction-id
        * @param aOpId op-id if matching one found (OUT)
        * @param aRequestType request type if found (OUT)
        * @param aReqMsgType request CSP primitive if found (OUT)
        * @param aCSP CSP connection id
        * @return subsession handle if search match
        */
        TUint CheckRequests(
            const TDesC& aTid,
            TInt& aOpId,
            TImpsServRequest& aRequestType,
            TImpsMessageType& aReqMsgType,
            TImpsSessIdent aCSP );

        /**
        * Discard expired pending requests and send error event to client
        * @param aExpiryTime expiry time interval
        * @param aServiceType service type considered
        * @param aSess CSP session entity
        */
        void DiscardRequests(
            TTime aExpiryTime,
            TImpsEventType aServiceType,
            TImpsSessIdent aCSP,
            MImpsCSPSession* aSess );

        /**
        * Discard expired pending requests and send error event to client
        * @param aError error code to be sent
        * @param aServiceType service type considered
        * @param aSess CSP session entity
        */
        void DiscardRequests(
            TInt aError,
            TImpsEventType aServiceType,
            TImpsSessIdent aCSP,
            MImpsCSPSession* aSess );

        /**
        * Discard a pending request and send an error event to client
        * @param aTid transaction-id
        * @param aServiceType service type considered
        * @param aCode error code
        * @param aSess CSP session entity
        * @return ETrue if request found and deleted
        */
        TBool DiscardRequest(
            const TDesC& aTid,
            TImpsEventType aServiceType,
            TInt aCode,
            TImpsSessIdent aCSP );

        /**
        * Minimum expiry time accessor
        * @return expiry time of subsession in seconds
        */
        TInt ExpiryTime();


        /**
        * Send or buffer new event to client
        * @param aFields data to be sent
        * @param aOpId corresponding op-id
        * @param aRequestType request type
        * @param aReqMsgType requesting CSP primitive starting
        *        transaction if this client has initiated it.
        * @param aHandle subsession handle
        */
        void SendEvent(
            CImpsFields* aFields,
            TInt aOpId,
            TImpsServRequest aRequestType,
            TImpsMessageType aReqMsgType,
            TUint aHandle );

        /**
        * Send Logout event only for Access clients (=session type)
        * @param aRespStatus response status caused this
        * @param aOpId op-id, optional
        * @param aSub subsession that is ignored.
        * @param aHandle subsession that is handled only.
        */
        void SendLogoutEvent(
            TInt aRespStatus,
            TInt aOpId,
            CImpsSubSession* aSub,
            TUint aHandle );

        /**
        * Send or buffer new status event to client
        * @param aStatus new status
        */
        void SendEvent(
            EImpsInternalStatus aStatus );

        /**
        * Check if notification should be sent when TID not given
        * This means usually SAP originated transaction.
        * @param aFields data received from SAP.
        * @param aCSP CSP connection id
        * @return ETrue if matching client found (client-id and
        * media type ok)
        */
        TBool CheckNotifications( CImpsFields* aFields, TImpsSessIdent aCSP );

        /**
        * Check all orphan messages from engine
        */
        void HandleAllOrphans();

        /**
        * Close the session
        */
        void CloseSession();

        /**
        * Delete all waiting client requests.
        */
        void DeleteAllRequests( );

        /**
        * Delete all waiting client requests.
        * @param aCSP CSP connection indetification
        */
        void DeleteAllRequests( TImpsSessIdent* aCSP );

        /**
        * Delete a specified client request
        * @param aOpId corresponding op-id
        * @param aSubHandle subsession handle
        */
        void DeleteRequest( TInt aOpId, TUint aSubHandle );

        /**
        * ApplicationId accessor
        * @return ApplicationId
        */
        TPtrC ApplicationId();

        /**
        * Complete the pending message and set the session status
        * @param aStatus completation status
        */
        void CompleteMe( TInt aStatus );

        /**
        * Reads the 8-bit data from client to the buffer
        * @param aIndex pointer to the message index
        * @param aBuffer target buffer in server memory.
        *        Buffer is reallocated if necessary.
        * @return ETrue if new buffer is allocated
        */
        TBool ReadBuffer8L(
            TInt aIndex,
            HBufC8*& aBuffer );

        /**
        * Delete a subsession
        * @param aHandle subsession id
        */
        void DeleteSubSession( TUint aHandle );

        /**
        * Check if CSP session connection matches
        * @param aCSP CSP connection indetification
        * @return aTrue if matches
        */
        TBool MatchSession( TImpsSessIdent aCSP );

        /**
        * Indicate that the message request has been completed
        */
        inline void SetCompleted();

        /**
        * Server accessor, wrapper for CSharableSession::Server()
        * @return current server instance
        */
        inline CImpsServer* CImpsSession::Server();  //lint !e1511

        /**
        * Get current message of this session
        * That's for CImpsServer only
        * @return last data sent by client API
        */
        inline CImpsFields* ImpsFields() const;

        /**
        * Get buffer for streamed message
        * @return buffer
        */
        inline HBufC8* StreamBuf() const;

        /**
        * Get buffer for streamed message
        * @return buffer
        */
        inline HBufC8** StreamBufAddr();

        /**
        * Create new data structure without deleting old one.
        * That's for a server if it has to queue current request.
        */
        void NewFieldsL();

        /**
        * Is this CIR watcher session
        * @return ETrue this is CIR watcher session.
        */
        inline TBool IsCIRWatcherSession() const;

        /**
        * Subsession (service) types of this session
        * @return event type bit mask
        */
        inline TInt Types() const;

        /**
        * Number of subsessions
        */
        inline TInt NbrSubs() const;

        /**
        * Current message
        */
        inline RMessagePtr2 Message() const;

        // multi:
        /**
        * user-id mutator
        * @param aId user-id
        */
        void SetUserIdL( const TDesC& aId );

        /**
        * Clean CSP session-id
        */
        void CleanSID();

        /**
        * CSP Session-id mutator
        * @param aSID session-id
        */
        void ModifySIDL( const TDesC& aSID );

        /**
        * CSP Session-id accessor
        * @return aId user-id
        */
        inline TPtrC SID( ) const;

        /**
        * client-id accessor
        * @return aId user-id
        */
        inline TPtrC UserId( ) const;

        /**
        * SAP mutator
        * @param aId SAP address
        */
        void SetSAPL( const TDesC& aId );

        /**
        * SAP accessor
        * @return aId user-id
        */
        inline TPtrC SAP( ) const;

        /**
        * Is this session logged in
        */
        inline TBool IsThisLogged() const;


    public: // Functions from base classes

        /**
         * From CSharableSession (pure virtual)
         * Handles service request messages from clients.
         * @param aMessage message from client
         */
        void ServiceL( const RMessage2& aMessage );

    protected:  // Functions from base classes

        /**
        * From CSharableSession::CreateL
        * @param aServer WV engine server core and soul
        */
        // void CreateL( const CServer& aServer );
        void CreateL();

    private: // New functions

        /**
        * New subsession creation
        * @param aType subsession type
        * @param aMessage client request
        */
        void NewSubSessionL(
            TImpsEventType aType,
            const RMessage2& aMessage );

        /**
        * Subsession handle accessor
        * @param aHandle 4th client-server parameter
        * @return Subsession entity
        */
        CImpsSubSession* ConnectionFromHandle( TUint aHandle );

        /**
        * Panics the client thread
        * @param aPanic panic reason
        */
        void PanicClient( TImpsPanic aPanic ) const;

        /**
        * Current service tree
        * Sends current negotiated service tree to a client thread.
        */
        void CurrentServicesL();

        /**
        * Push message generation
        */
        void PushMessageL();

        /**
        * set this client session inactive, i.e. messages should not be sent
        * Login request makes this session active again althogh creation
        * of new session is preferred way to make a new CSP login.
        */
        void SetThisInactive();

        /**
        * Assign the application id
        */
        void AssignIdL();

        // By default, prohibit copy constructor
        CImpsSession( const CImpsSession& );
        // Prohibit assigment operator
        CImpsSession& operator= ( const CImpsSession& );

        /**
        * Is this client session active, i.e. messages should be sent
        * @return ETrue if this is active
        */
        inline TBool IsThisActive() const;

        /**
        * CSP session specific client-server session counter
        * @return number of sessions
        */
        TInt NbrOfSessionsL( );


    private:    // Data
        TBool               iCanceled;

        HBufC*              iApplicationId;  // application id
        HBufC*              iSID;       // CSP Session-id
        HBufC*              iSAP;
        HBufC*              iUserId;    // CSP user-id

        TBuf<KImpsMaxTID>   iLogoutTID;

        HBufC8*             iStream;   // message stream between client->server
        CImpsFields*        iFields;   // current message in unpacked form
        TBool               iMessageCompleted;  // if the session is not active

        TBool               iCIRSess;   // Is this CIR watcher session

        CObjectIx*          iSubSessions; // object index which stores subsessions
        CObjectCon*         iContainer;   // object container for this session
        TInt                iResourceCount;
        TUint               iTypes; // bit mask of supported services

        RMessagePtr2        iMsgR;      // current client-server request
    };

#include "ImpsSession.inl"

#endif

// End of File