/*

* Copyright (c) 2002 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:  One Session manager of the presence server

* 				 Handles all management concerning one network session

*  				 Opening, closing, ownership handling, updating

*  				 of Session related data to network

*

*/

#ifndef __CPENGCSPSESSMANAGER_H__

#define __CPENGCSPSESSMANAGER_H__

//  INCLUDES

#include	<e32base.h>

#include	"MPEngRequestHandlerObserver.h"

#include	"MPEngSessionStatusObserver.h"

#include	"PEngPresenceEngineConsts2.h"

#include	"RPEngStorageAdminSubClient.h"

// FORWARD DECLARATIONS

class	MPEngRequestHandler;

class	CPEngIncomingDataHandler;

class	MPEngServer;

class	CPEngSessionSlotId;

class	CPEngAppAccessContainer;

class	MPEngSubSession;

class	MPEngTransactionFactory;

class   RPEngStorageAdminClient;

class   MPEngAccessHandler;

class   MPEngPureDataHandler;

class   RPEngMessage;

// CLASS DECLARATION

/**

 *  One Session manager of the presence server

 *  Handles all management concerning one network session

 *  Opening, closing, ownership handling, updating

 *  of Session related data to network

 *

 *  @lib PEngServer2

 *  @since 3.0

 */

NONSHARABLE_CLASS( CPEngCSPSessManager ):

        public CBase,

        public MPEngRequestHandlerObserver,

        public MPEngSessionStatusObserver

    {

public:  // Constructors and destructor

    /**

     * Two-phased constructor.

     */

    static CPEngCSPSessManager* NewLC( MPEngServer& aServer,

    const CPEngSessionSlotId& aSessId,

    RPEngStorageAdminClient& aAdmin );

    /**

     * Destructor.

     */

    ~CPEngCSPSessManager();

private: // new function of MPEngRequestHandlerObserver

    /**

     *  Remove calling request handler from array of pending requests

     *

     *  @see <MPEngRequestHandlerObserver.h>

     *  @since 3.0

     */

    void CompleteRequestHandler(

        MPEngRequestHandler* aRequestHandler );

    /**

     *  Set Session slot state to open

     *

     *  @see <MPEngRequestHandlerObserver.h>

     *  @since 3.0

     */

    void SetCSPSessionOpenedL();

private: // ne functions from MPEngSessionStatusObserver

    /**

     *	Handle Session status change

     *

     *  @since 3.0

     *

     *  @param new session slot state

     *  @param session slot event

     */

    void StatusChangedL( TPEngNWSessionSlotState aNewState,

                         TPEngNWSessionSlotEvent aNewEvent );

public: // Slot management support

    /**

     *  Open method for clean up stack support

     *

     *  @since 3.0

     */

    void Open();

    /**

     *  Close method for clean up stack support

     *

     *  @since 3.0

     */

    void Close();

    /**

     *  Open method for sub-sessions

     *	Reference to the Sub-session is stored

     *	for future notifications

     *

     *  @since 3.0

     *	@param aServSubSession server sub-session

     */

    void OpenL( MPEngSubSession& aServSubSession );

    /**

     *  Close method for the sub-session

     *

     *  @since 3.0

     * 	@param aServSubSession server sub-session

     */

    void Close( MPEngSubSession* aServSubSession );

    /**

     *	Open reference to the session manager by the app Id

     *

     *  @since 3.0

     *  @param aAppId application Id to open reference

     */

    void AttachAppIdL( const TDesC& aAppId );

    /**

     *	Close reference to the session manager by the app Id

     *

     *  @since 3.0

     *  @param aAppId application Id to open reference

     */

    void DetachAppId( const TDesC& aAppId );

    /**

     *  Check if application Id is active

     *

     *  @since 3.0

     *  @param aAppId application Id

     */

    void AppIdActiveL( const TDesC& aAppId );

    /**

     *	Reserve Session slot for Process Id

     *

     *  @since 3.0

     *  @param aAppId application Id

     *  @param aProcessId process Id to reserve

     */

    void ReserveProcessL( const TDesC& aAppId,

                          const TDesC& aProcessId );

    /**

     *	Activate Process id

     *  Function leaves if there is not such a combination of

     *  process Id and application id registered

     *

     *  @since 3.0

     *  @param aAppId application Id

     *  @param aProcessId process Id to activate

     */

    void ActivateProcessL( const TDesC& aAppId,

                           const TDesC& aProcessId );

    /**

     *  Session slot Id

     *

     *  @since 3.0

     *  @return session slot Id

     */

    const CPEngSessionSlotId& SessionId() const;

public: // Request handling

    /**

     *  Handle asynchronous request

     *

     *  @since 3.0

     *  @param aMessage RPEngMessage of the request

     *  @param aServSubSession server sub-session

     *  @param aServSessionId server session Id

     *  @param aServSubSessionId server sub-session Id of the request

     */

    void HandleAsynchronousRequestL(

        const RPEngMessage& aMessage,

        MPEngSubSession& aServSubSession,

        TInt32 aServSessionId,

        TInt   aServSubSessionId );

    /**

     *  Handle synchronous request

     *

     *  @since 3.0

     *  @param aMessage RPEngMessage of the request

     *  @param aServSessionId server session Id

     *  @param aServSubSessionId server sub-session Id of the request

     */

    void HandleSynchronousRequestL(

        const RPEngMessage& aMessage,

        TInt32 aServSessionId,

        TInt   aServSubSessionId );

    /**

     *	Handle Log In Request

     *

     *	@since 3.0

     *  @param aMessage RPEngMessage of the request

     *  @param aServSubSession server sub-session

     *  @param aServSessionId server session Id

     *  @param aServSubSessionId server sub-session Id of the request

     */

    void HandleLogInRequestL(	const RPEngMessage& aMessage,

                              MPEngSubSession& aSubSession,

                              TInt32 aServSessionId,

                              TInt   aServSubSessionId );

    /**

     *	Handle Log Oout Request

     *

     *	@since 3.0

     *  @param aMessage RPEngMessage of the request

     *  @param aServSubSession server sub-session

     *  @param aServSessionId server session Id

     *  @param aServSubSessionId server sub-session Id of the request

     */

    void HandleForceLogOutRequestL( const RPEngMessage& aMessage,

                                    MPEngSubSession& aSubSession,

                                    TInt32 aServSessionId,

                                    TInt   aServSubSessionId );

    /**

     *  Close reference to the session manager by the app Id

     *	Asynchronous version

     *

     *  @since 3.0

     *  @param aMessage RPEngMessage of the request

     *  @param aServSubSession server sub-session

     *  @param aServSessionId server session Id

     *  @param aServSubSessionId server sub-session Id of the request

     */

    void HandleDetachAppIdL( const RPEngMessage& aMessage,

                             MPEngSubSession& aSubSession,

                             TInt32 aServSessionId,

                             TInt   aServSubSessionId );

    /**

     *  Cancel particular asynchronous request

     *	Cancel all asynchronous request from the Server Session

     *  Cancel all asynchronous request from the Server Sub-session

     *

     *  @since 3.0

     *  @param aMessage RPEngMessage of the request

     *  @param aServSessionId server session Id

     *  @param aServSubSessionId server sub-session Id of the request

     */

    void CancelAsynchronousRequest(

        const RPEngMessage& aMessage,

        TInt32 aServSessionId,

        TInt   aServSubSessionId );

    void CancelAllSessionRequests(

        TInt32 aServSessionId );

    void CancelAllSubSessionRquests(

        TInt32 aServSessionId,

        TInt   aServSubSessionId );

private:	// Function for handling of resources

    /**

     *  Load resources for the online state of the session

     *

     *  @since 3.0

     */

    void LoadResourcesL();

    /**

     *  Unloads resources for the offline state of Session slot

     *

     *  @since 3.0

     */

    void UnloadResources();

private:	// request management

    /**

     *  Check if request is allowed

     *

     *

     *  @since 3.0

     *  @param aRequestFunction request function

     *  @param aServSessionId server session Id of the request

     *	@param aServSubSessionId server sub-session Id of the request

     */

    void CheckRequestValidityL (

        TInt aRequestFunction,

        TInt32 aServSessionId,

        TInt   aServSubSessionId );

    /**

     *  Find defined request in session manager

     *

     *  @since 3.0

     *  @param aRequestFunction request function to find

     *  @param aServSessionId session to look in

     *  @param aServSubSessionId sub-session to look in

     *  @return index or KerrNotFound

     */

    TInt FindRequest( TInt aRequestFunction );

    TInt FindRequestInSession(

        TInt aRequestFunction,

        TInt32 aServSessionId );

    TInt FindRequestInSubSession(

        TInt aRequestFunction,

        TInt32 aServSessionId,

        TInt   aServSubSessionId );

    /**

     *	Handle Send new data Request

     *

     *	@since 3.0

     *	@param aMessage RPEngMessage from Client

     *	@param aServSubSession server sub-session

     *	@param aServSessionId server session id

     *	@param aServSubSessionId server sub-session Id

     */

    void HandleUpdateDataRequestL( const RPEngMessage& aMessage,

                                   MPEngSubSession& aServSubSession,

                                   TInt32 aServSessionId,

                                   TInt   aServSubSessionId );

    /**

     *  Do Log In to the CSP session

     *

     *  @since 3.0

     *	@param aMessage RPEngMessage from Client

     *	@param aServSubSession server sub-session

     *	@param aServSessionId server session id

     *	@param aServSubSessionId server sub-session Id

     */

    void DoLogInL( const RPEngMessage& aMessage,

                   MPEngSubSession& aServSubSession,

                   TInt32 aServSessionId,

                   TInt   aServSubSessionId );

    /**

     *  Do log out from the CSP session

     *

     *  @since 3.0

     *	@param aMessage RPEngMessage from Client

     *	@param aServSubSession server sub-session

     *	@param aServSessionId server session id

     *	@param aServSubSessionId server sub-session Id

     */

    void DoLogOutL( const RPEngMessage& aMessage,

                    MPEngSubSession& aServSubSession,

                    TInt32 aServSessionId,

                    TInt   aServSubSessionId );

private: // Helping functions

    /**

     *  Find Access counter

     *

     *  @since 3.0

     *  @param aAppId application Id

     *  @return pointer to access counter if found, NULL if not found

     */

    CPEngAppAccessContainer* AccessCounter( const TDesC& aAppId );

    /**

     *  Check reference counter and delete this object if needed

     *  @since 3.0

     */

    void CheckReferenceAccessD();

    /**

     *  Unload Transaction factories

     *  @since 3.0

     */

    void UnloadTransactionFactories();

    /**

     *  Reset access Containers

     *  @since 3.0

     */

    void ResetAccessContainers();

    /**

     *  Inform sub-session about app Id disconnection

     *  @since 3.0

     *  @param aAppId disconnected app Id

     */

    void NotifyDisconnectedAppId( const TDesC& aAppId );

    /**

     *  Inform sub-sessions about CPS close state

     *  @since 3.0

     */

    void NotifyCPSClose();

    /**

     *  Notify Storage Server about new event

     *  @since 3.0

     *  @param aEvent new event to notify

     *  @param aAppId application id event is related

     *  @param aAppIdState state of the application id

     */

    void NotifyNewEventL( TPEngNWSessionSlotEvent aEvent,

                          const TDesC& aAppId,

                          TPEngNWSessionSlotState aAppIdState );

    /**

     *  Leaves with error code if not connected.

     */

    void LeaveIfNotConnectedL() const;

private:

    /**

     * C++ default constructor.

     */

    CPEngCSPSessManager( MPEngServer& aServer );

    /**

     * By default Symbian 2nd phase constructor is private.

     */

    void ConstructL( const CPEngSessionSlotId& aSessId,

                     RPEngStorageAdminClient& aAdmin );

private:    // Data

    /// OWN: Access Plain Access Count, used by cleanUp support

    TInt											iAccessCount;

    /// OWN: Session slot Id

    CPEngSessionSlotId*								iSessionSlotId;

    /// OWN: Session state

    TPEngNWSessionSlotState							iState;

    /// OWN: Container of Access Counters

    CObjectCon*										iAccessCounters;

    ///	REF: Server

    MPEngServer&									iServer;

    /// OWN: Server sub-sessions,

    ///      Elements REFerenced

    RPointerArray<MPEngSubSession>					iServSubSessions;

    /// OWN: Storage Manager admin client

    RPEngStorageAdminSubClient						iStoreAdmin;

    /// OWN: Array of active request handlers

    ///      Elements OWNed

    RPointerArray<MPEngRequestHandler>				iRequestHandlers;

    /// OWN: Transaction factories

    RPointerArray<MPEngTransactionFactory>			iTransFactories;

    /// OWN: Online Plugins loaded

    TBool 											iPluginsLoaded;

    /// OWN: Access handlers

    MPEngAccessHandler*								iAccessHandler;

    /// OWN: pure data handler

    MPEngPureDataHandler*							iPureDataHandler;

    /// OWN: list of Incoming Listen Data Handlers

    ///      Elements OWNed

    RPointerArray<CPEngIncomingDataHandler>			iIncomingHandlers;

    };

#endif      // __CPENGCSPSESSMANAGER_H__

// End of File