/*

* Copyright (c) 2006 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:  Presence Service Connection data cache implementation.

*

*/

#ifndef CPRESENCEDATACACHEIMP_H

#define CPRESENCEDATACACHEIMP_H

#include "ximpapiobjbase.h"

#include "presenceapiobjbase.h"

#include "ximpitemparent.h"

#include "presencetypehelpers.h"

#include "ximpoperationdefs.h"

#include "ximpapieventbase.h"

class MXIMPHost;

class COwnPresenceSubscriptionItem;

class CPresentityPresenceSubscriptionItem;

class CGroupContentSubscriptionItem;

class CWatcherListSubscriptionItem;

class MPresentityGroupInfo;

class CXIMPIdentityImp;

class MXIMPPscContext;

class CXIMPSubscriptionItemBase;

class MPresenceWatcherInfo;

class MXIMPStatus;

class MPresenceBlockInfo;

class CBlockListSubscriptionItem;

class MXIMPIdentity;

class MPresenceInfo;

class MXIMPDataSubscriptionState;

class CXIMPDataSubscriptionStateImp;

class MPresenceCacheWriter;

//class CXIMPApiEventBase;

/**

 * PSC Presence Data Cache implementation.

 *

 * @since S60 v3.2

 */

class CPresenceDataCache : public CBase,

                           public MXIMPItemParent

    {

public: // Definitions

    /** The class ID. */

    enum { KClassId = PRIMP_CLSID_CPRESENCEDATACACHE };

public: // Construction and destruction

    /**

     * Construction

     */

    IMPORT_C static CPresenceDataCache* NewL( MXIMPHost& aHost );

    /**

     * Destruction

     */

    virtual ~CPresenceDataCache();

private:

    CPresenceDataCache( MXIMPHost& aHost );

    void ConstructL();

private: //MXIMPItemParentBase

	TAny* GetInterface(TInt aInterfaceId) ;

    // Expiring items

    void RegisterExpiringItemL( CXIMPSubscriptionItemBase* aExpireItem );

    void UnregisterExpiringItem( CXIMPSubscriptionItemBase* aExpireItem );

private: // From MXIMPItemParent

    /**

     * @see MXIMPItemParent

     */

    // Subscription items

    void RemoveMe( COwnPresenceSubscriptionItem* aChild );

    void RemoveMe( CGroupListSubscriptionItem* aChild );

    void RemoveMe( CGroupContentSubscriptionItem* aChild );

    void RemoveMe( CPresentityPresenceSubscriptionItem* aChild );

    void RemoveMe( CWatcherListSubscriptionItem* aChild );

    void RemoveMe( CPresentityGroupMembersPresenceSubscriptionItem* aChild );

    void RemoveMe( CGrantRequestListSubscriptionItem* aChild );

    void RemoveMe( CBlockListSubscriptionItem* aChild );

    void AddPresentityPresenceSubscriberL( const CXIMPIdentityImp& aIdentity, CXIMPSubscriptionItemBase* aItem, CXIMPIdentityImp* aGroup = NULL );

    void RemovePresentityPresenceSubscriber( const CXIMPIdentityImp& aIdentity, CXIMPSubscriptionItemBase* aItem );

    void ActivatePresentityPresenceSubscriberL( const CXIMPIdentityImp& aIdentity, CXIMPSubscriptionItemBase* aItem );

    void SynthesisePresentityPresenceSubscriptionEventToL( const CXIMPIdentityImp& aIdentity, MXIMPPscContext* aContext, TBool aForceEvent );

    // Configuration items

    void RemoveMe( CPresenceConfigurationItem* aChild );

    void RemoveMe( CPresenceToEveryoneConfigurationItem* aChild );

    void RemoveMe( CGroupMembersPresenceConfigurationItem* aChild );

    void AddPresenceConfiguratorL( const CXIMPIdentityImp& aIdentity, CXIMPConfigurationItemBase* aItem );

    void RemovePresenceConfigurator( const CXIMPIdentityImp& aIdentity, CXIMPConfigurationItemBase* aItem );

    // Other methods

    void AddEventL( CXIMPApiEventBase& aEvent, MXIMPPscContext* aContext );

    TInt32 ProtocolUID( );

    MPresenceCacheWriter* ExternalCache();

public: // New methods

    /**

     * - If OwnPresenceSubscriptionItem is not found, data cache

     *   initializes new one and returns ownership to caller

     * - If OwnPresenceSubscriptionItem is found, data cache increases

     *   refcount by one, and returns the old object

     */

    IMPORT_C COwnPresenceSubscriptionItem& OwnPresenceSubscriptionItemLC();

    IMPORT_C CGroupListSubscriptionItem& GroupListSubscriptionItemLC();

    IMPORT_C CWatcherListSubscriptionItem& WatcherListSubscriptionItemLC();

    IMPORT_C CGrantRequestListSubscriptionItem& GrantRequestListSubscriptionItemLC();

    IMPORT_C CBlockListSubscriptionItem& BlockListSubscriptionItemLC();

    IMPORT_C CGroupContentSubscriptionItem& GroupContentSubscriptionItemLC(

                                                    const CXIMPIdentityImp& aGroupId );

    IMPORT_C CPresentityPresenceSubscriptionItem& PresentityPresenceSubscriptionItemLC(

                                                    const CXIMPIdentityImp& aIdentity );

    IMPORT_C CPresentityGroupMembersPresenceSubscriptionItem&

                PresentityGroupMembersPresenceSubscriptionItemLC( const CXIMPIdentityImp& aIdentity );

    IMPORT_C CPresenceConfigurationItem& PresenceConfigurationItemLC( const CXIMPIdentityImp& aIdentity );

    IMPORT_C CPresenceToEveryoneConfigurationItem& PresenceToEveryoneConfigurationItemLC();

    IMPORT_C CGroupMembersPresenceConfigurationItem& GroupMembersPresenceConfigurationItemLC(

                                                                    const CXIMPIdentityImp& aGroupId );

    /**

     * Checks if group content subscription item with given group id is found.

     */

    IMPORT_C TBool GroupContentSubscriptionItemExists( const CXIMPIdentityImp& aGroupId );

    /**

     * Clean resources concerning context.

     */

    IMPORT_C void CleanResources( MXIMPPscContext& aContext );

    /**

     *

     */

    IMPORT_C void CleanExpired();

    /**

     * Helper method to pack group id.

     * @param aGroupId The group id to be packed.

     * @return HBufC8 containing the packed group id.

     */

    HBufC8* PackGroupIdLC( const MXIMPIdentity& aGroupId );

    IMPORT_C const MXIMPDataSubscriptionState& OwnPresenceDataSubscriptionState() const;

    IMPORT_C const MXIMPDataSubscriptionState& PresentityGroupListDataSubscriptionState() const;

    IMPORT_C const MXIMPDataSubscriptionState& PresentityGroupContentDataSubscriptionState( 

                const MXIMPIdentity& aGroupId ) const;

    IMPORT_C const MXIMPDataSubscriptionState& PresentityPresenceDataSubscriptionState( 

                const MXIMPIdentity& aPresentityId ) const;

    IMPORT_C const MXIMPDataSubscriptionState& PresenceWatcherListDataSubscriptionState() const;

    IMPORT_C const MXIMPDataSubscriptionState& PresenceBlockDataSubscriptionState() const;

    IMPORT_C const MXIMPDataSubscriptionState& PresenceGrantRequestDataSubscriptionState() const;

private: // Helper methods

    /**

     * Template method for removeMe when one subscription item is target.

     * @param aItem Reference to subscription item pointer to remove.

     * @param Pointer of item to remove.

     */

    template< class Type >

    IMPORT_C static void RemoveMe( Type*& aItem, Type* aChild );

    /**

     * Template method for removeme if target subscription item is in array.

     * @param aItemArray Array of subscription items where aChild should exists.

     * @param Pointer of item to remove.

     */

    template< class Type >

    void RemoveMeFromArray( RPointerArray< Type >& aItemArray, Type* aChild );

    /**

     * Templated item instance creation. If item is not found it is created.

     * @param aItem Reference to pointer where new item should be saved.

     * @return Reference to item created.

     */

    template< class Type > 

    Type& ItemLC( Type*& aItem );

    /**

     * Templated item instance creation. If item is not found it is created.

     * @param aItemArray Array of items where new item should be created.

     * @param aIdentity. Key for finding item or for creating the new one.

     * @return Reference to item created.

     */

    template< class Type >

    Type& ArrayItemLC( RPointerArray< Type >& aItemArray, const CXIMPIdentityImp& aIdentity );

    /**

     * Templated item instance creation. If item is not found it is created.

     * @param aItemArray Array of items where new item should be created.

     * @param aContentArray. Content array for passing to new created item.

     * @param aIdentity. Key for finding item or for creating the new one.

     * @return Reference to item created.

     */

    template< class Type, class ContentType >

    Type& ArrayItemLC( RPointerArray< Type >& aItemArray, 

                       RPointerArray< ContentType >& aContentArray,

                       const CXIMPIdentityImp& aIdentity );

    /**

     * Get data subscription state for item.

     * @param aItem Item which data subscription state should be found.

     * @return Data subscription state.

     */    

    template< class Type >

    const MXIMPDataSubscriptionState& DataSubscriptionState( Type* aItem ) const;

    /**

     * Get data subscription state for item.

     * @param aItemArray Item array where item should be found.

     * @aIdentity Key for finding right item.

     * @return Data subscription state.

     */    

    template< class Type >

    const MXIMPDataSubscriptionState& DataSubscriptionState( const RPointerArray< Type >& aItemArray,

                                                             const MXIMPIdentity& aIdentity ) const;

private: // Data

    /**

     * Access to host.

     */

    MXIMPHost& iHost;

    /**

     * Does not own. Removed when RemoveMe called.

     */

    COwnPresenceSubscriptionItem* iOwnSubscriptionItem;

    CGroupListSubscriptionItem* iGroupListSubscriptionItem;

    RPointerArray< CGroupContentSubscriptionItem > iGroupContentSubscriptionItems;

    RPointerArray< CPresentityPresenceSubscriptionItem > iPresentityPresenceSubscriptionItems;

    CWatcherListSubscriptionItem* iWatcherListSubscriptionItem;

    CGrantRequestListSubscriptionItem* iGrantRequestListSubscriptionItem;

    RPointerArray< CPresentityGroupMembersPresenceSubscriptionItem > iGroupMembersPresenceSubscriptionItems;

    CBlockListSubscriptionItem* iBlockListSubscriptionItem;

    RPointerArray< CXIMPSubscriptionItemBase > iExpiringSubscriptionItems;

    RPointerArray< CPresenceConfigurationItem > iPresenceConfigurationItems;

    CPresenceToEveryoneConfigurationItem* iPresenceToEveryoneConfigurationItem;

    RPointerArray< CGroupMembersPresenceConfigurationItem > iGroupMembersPresenceConfigurationItems;

    /**

     * Empty subscription state to pass adaptation exists request is subscription item does not exists.

     */

    CXIMPDataSubscriptionStateImp* iEmptySubscriptionState;

    MPresenceCacheWriter *iExtPresenceCache;

/* ======================================================================== */

    };

#endif // CPRESENCEDATACACHEIMP_H