/*
* 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:  Factory of Storage Manager
*
*/



#ifndef __CPENGSTORAGEMANAGERFACTORY_H__
#define __CPENGSTORAGEMANAGERFACTORY_H__

//  INCLUDES
#include <e32base.h>
#include "RPEngStorageClient.h"
#include "MPEngStorageFactory.h"

#include "RObjectArray.h"


// FORWARD DECLARATIONS
class CPEngStorageManagerWatcher;
class CPEngStorageManager;
class CPEngSessionSlotId;
class CPEngSessionSlotState;
class MPEngGlobalEventObserver;


/**
 *  Factory of Storage Manager
 *	It holds all active Watchers of the storage manager
 *	There is always one watcher per each session slot which is
 *	shared by all storage manager instances accessing this session slot
 *
 *  @lib PEngStoreMan2.dll
 *  @since 3.0
 */
NONSHARABLE_CLASS( CPEngStorageManagerFactory ):
        public CActive,
        public MPEngStorageFactory
    {
public:  // Constructors and destructor

    /**
     *	Instance of the storage factory, it is created if needed
     *
     *  @since 3.0
     *  @param
     *  @return
     */
    static CPEngStorageManagerFactory* InstanceLC();

    /**
     *	Gets pointer to the Manager factory it is exists
     *	if not then NULL pointer
     *
     *  @since 3.0
     *  @param
     *  @return
     */
    static CPEngStorageManagerFactory* Instance();

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

public:	// New functions for reference counting support

    /**
     *	Openes handle new handle to Storage Manager Factory
     *
     *	@since 3.0
     */
    void Open();

    /**
     *	Closes handle to the Storage Manager Factory
     *
     *	@since 3.0
     */
    void Close();

public: // virtual Functions of the CActive

    /**
     *	Handles an active object’s request completion event.
     *	@since 3.0
     */
    void RunL();

    /**
     *	Handles a leave occurring in the request completion
     *	event handler RunL()
     *	@since 3.0
     */
    TInt RunError( TInt aError );

    /**
     *	Implements cancellation of an outstanding request.
     *	This function is called as part of the active object’s Cancel().
     *	@since 3.0
     */
    void DoCancel();

public: // New Functions from MPEngStorageFactory

    /**
     *  Remove Storage watcher,
     *	@see <MPEngStorageFactory.h>
     */
    void CloseStorageWatcher(
        CPEngStorageManagerWatcher* aStorageWatcher );

    /**
     *  Increases reference counter of Factory
     *	@see <MPEngStorageFactory.h>
     */
    void OpenWatcher();

    /**
     *  Storage Manager main client
     *	@see <MPEngStorageFactory.h>
     */
    RPEngStorageClient& MainClient();

public: // New Functions of the base class

    /**
     *	Retrieves Storage Manager instance
     *	Ownership is passed to the caller
     *	To get Storage manager which has handle to the correct
     *	sub-folder of the Storage,
     *	Server address and user name has to be specified.
     *
     *	@since 3.0
     *	@param aSessionSlot session slot Class which caries
     *				unique information about the session
     *	@return MPEngStorageManager type pointer,
     *                  ownership is passed to the caller
      */
    CPEngStorageManager* StorageManagerL(
        const CPEngSessionSlotId& aSessionSlot );


    /**
     *	Retrieves Storage Manager Watcher pointer
     *	When this method is called,
     *  Reference counter is increased and when user does not
     *	need watcher, close shall be called
     *
     *	To get Storage manager Watcher which has handle to
     *	the correct sub-folder of the Storage,
     *	Server address and user name has to be specified
     *
     *	@since 3.0
     *	@param aSessionSlot session slot Class which caries
     *				unique information about the session
     *	@return MPEngStorageManagerWatcher type pointer,
     *				ownership is passed to the caller
      */
    CPEngStorageManagerWatcher* StorageManagerWatcherL(
        const CPEngSessionSlotId& aSessionSlot );

    /**
     *	Create Session folder in the storage
     *	This will ensure existence of the session slot folder till the
     *	moment calling application will not unregister from the
     *	session slot folder ( RemoveSessionFolderL)
     *
     *	@since 3.0
     *	@param aSessionSlot session slot Class which caries
     *				unique information about the session
     *	@param aApplicationId application Id
     */
    void CreateSessionFolderL(
        const CPEngSessionSlotId& aSessionSlot,
        const TDesC& aApplicationId );

    /**
     *	Remove Session folder from the storage,
     *	Session folder Session is deleted from the storage,
     *	only if the calling	application was the last one registered
     *	@see CreateSessionFolderL()
     *
     *	@since 3.0
     *	@param aSessionSlot session slot Class which caries
     *				unique information about the session
     *	@param aApplicationId application Id
     */
    void RemoveSessionFolderL(
        const CPEngSessionSlotId& aSessionSlot,
        const TDesC& aApplicationId );

    /**
     *	Get Session slot state
     *	returns class where is described state of the session slot
     *	ownership is passed
     *
     *	@since 3.0
     *	@param aSessionSlot session slot Class which caries
     *				unique information about the session
     *	@param aSessionSlotState state class is updated on the
     *			return with actual state
     */
    void SessionSlotStateL( const CPEngSessionSlotId& aSessionSlot,
                            CPEngSessionSlotState& aSessionSlotState );

    /**
     *	Get list of existing Session slots
     *	Returns array of all existing session slots, no matter if
     *	session is opened or closed.
     *
     *	@since 3.0
     *	@param aSessionSlot session slot Class which caries
     *				unique information about the session
     */
    void AllSessionSlotsStatesL(
        RObjectArray<CPEngSessionSlotState>& aSessionSlots );


    /**
     *	Register Global event observer
     *	Global event observer will be notified about all events
     *	of the PEC engine
     *
     *	@since 3.0
     *	@param aGlobalObserver call back interface implemented by the
     *				observer
     *		Function leaves with KErrAlreadyExists
     *		, if same observer is already registered
     */
    void RegisterGlobalEventObserverL(
        MPEngGlobalEventObserver& aGlobalObserver );

    /**
     *	Unregister Global event observer
     *	Global observer is unregistered, if observer is not found
     *	among the registered observers, function is ignored
     *
     *	@since 3.0
     *	@param aGlobalObserver call back interface implemented by the
     *				observer
     */
    void UnregisterGlobalObserver(
        MPEngGlobalEventObserver& aGlobalObserver );

private:  // New private Functions

    /**
     *	Start global event listener
     *	@since 3.0
     */
    void StartGlobalEventListenerL();


private:	// private constructors

    /**
    * C++ default constructor.
    */
    CPEngStorageManagerFactory();

    /**
    * Symbian 2nd phase constructor
    */
    void ConstructL();

private:    // Data

    /// Listener of global events is activated
    TBool											iListening;

    /// Is listening scout created on the server side
    TInt											iScoutCreated;

    /// Access count of the reference counted object
    TInt											iAccessCount;

    /// OWN: Storage manager main client
    RPEngStorageClient								iStoreManagerClient;

    /// REF: Container with all Storage ID watchers
    RPointerArray<CPEngStorageManagerWatcher>		iStorageWatchers;

    /// REF: Global Events Observers
    RPointerArray<MPEngGlobalEventObserver>			iObservers;

    /// OWN:New Global Event receive Buffer
    HBufC8*											iGlobalEventBuff;

    /// New Global Event
    TPtr8											iGlobalEventDes;

    /// Last All states buffer size
    TInt											iAllStatesBuffSize;

    /// OWN: Flag is object is still alive
    TBool* 											iAliveFlag;
    };

#endif      // __CPENGSTORAGEMANAGERFACTORY_H__

// End of File