/*
* 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: Contains CNcdNodeManagerProxy class
*
*/
#ifndef NCD_NODE_MANAGER_PROXY_H
#define NCD_NODE_MANAGER_PROXY_H
#include <e32base.h>
#include <e32cmn.h>
#include "ncdbaseproxy.h"
#include "ncdschemenodetype.h"
class CNcdNodeProxy;
class CNcdRootNodeProxy;
class CNcdNodeFolderProxy;
class CNcdOperationManagerProxy;
class CNcdSubscriptionManagerProxy;
class CNcdNodeIdentifier;
class CNcdSearchRootNodeProxy;
class CNcdProviderProxy;
class CNcdExpiredNode;
class MNcdPurchaseDetails;
class CNcdFavoriteManagerProxy;
/**
* CNodeManagerProxy provides functions to ...
* @lib ?library
* @since S60 ?S60_version *** for example, S60 v3.0
*/
class CNcdNodeManagerProxy : public CNcdBaseProxy
{
public:
/**
* NewL
*
* @return CNcdNodeManagerProxy* Pointer to the created object
* of this class.
*/
static CNcdNodeManagerProxy* NewL(
MCatalogsClientServer& aSession,
TInt aHandle,
CNcdOperationManagerProxy& aOperationManager,
CNcdSubscriptionManagerProxy& aSubscriptionManager,
CNcdProviderProxy& aProvider );
/**
* NewLC
*
* @return CNcdNodeManagerProxy* Pointer to the created object
* of this class.
*/
static CNcdNodeManagerProxy* NewLC(
MCatalogsClientServer& aSession,
TInt aHandle,
CNcdOperationManagerProxy& aOperationManager,
CNcdSubscriptionManagerProxy& aSubscriptionManager,
CNcdProviderProxy& aProvider );
/**
* Destructor
*
* Deletes the nodes from the node cache.
*/
virtual ~CNcdNodeManagerProxy();
public: // Functions to get nodes if they exist in the server side
/**
* Creates a node according to the given id.
* If corresponding node has already been created, the old
* one will be returned and new one is not created.
*
* @note If server side does not contain the node this function
* will leave with KErrNotFound and does not return NULL in that case.
*
* @param
* @return
* @exeption Leaves with KErrNotFound If node did not exist.
*/
CNcdNodeProxy& NodeL( const CNcdNodeIdentifier& aNodeIdentifier );
public: // Functions that will create nodes in the server side if they do not
// already exist.
/**
* Creates the root node.
* If corresponding node has already been created, the old
* one will be returned and new one is not created.
*
* @return
*/
CNcdRootNodeProxy& RootNodeL();
/**
* Creates the search root node.
* If corresponding node has already been created, the old
* one will be returned and new one is not created.
*
* @return CNcdSearchRootNodeProxy&
*/
CNcdSearchRootNodeProxy& SearchRootNodeL();
/**
* When aForceCreate is ETrue, function forces the server side to create a node
* with the given id if the node is not found from the cache.
* The node will not have any parent. If aForceCreate is EFalse, then
* scheme node is returned only if it already exists or if the metadata exists
* in RAM or database cache. The scheme node is added to favourites.
*
* @note If the corresponding node already exists, then instead of creating a
* new node, the existing node is returned.
*
* @param aMetadataIdentifier
* @param aRemoveOnDisconnect If true, the node is removed from favorites when the
* client-server session is closed.
* @param aType Type of the scheme node to create.
* @param aForceCreate Determines if the node will always be created.
* @return CNcdNodeProxy&
* @exception Leave KErrNotFound if aForceCreate has been set as EFalse,
* and the node was not created.
*/
CNcdNodeProxy& CNcdNodeManagerProxy::CreateSchemeNodeL(
const CNcdNodeIdentifier& aMetadataIdentifier,
TNcdSchemeNodeType aType,
TBool aRemoveOnDisconnect,
TBool aForceCreate );
/**
* Forces the server side to create a temporary node by using the purchase details
* information. If the node already exists in the cache then that node will be
* returned.
* This node will not be a child of any other node. So, it is up to user
* what to do with the node.
*
* @note This function assumes that purchase details contain the information that
* is required to initialize the metadata if it can not be found from the database or
* from the cache.
*
* @param aDetails Purchase details are used to create correct form of the node.
* @return CNcdNodeProxy&
*/
CNcdNodeProxy& CreateTemporaryNodeL( const MNcdPurchaseDetails& aDetails );
/**
* Forces the server side to create a temporary node folder and inserts a metadata for it.
* This node will not be a child of any other node. So, it is up to user
* what to do with the node.
*
* @param aMetadataIdentifier
* @param aCreateMetaData If true, this function will create a dummy metadata if the
* metadata does not already exist. The dummy metadata initializes itself from the
* purchase history if the purchase history contains corresponding info.
* @return CNcdNodeProxy&
*/
CNcdNodeProxy& CreateTemporaryNodeFolderL(
const CNcdNodeIdentifier& aMetadataIdentifier,
TBool aCreateMetaData );
/**
* This function works like CreateTemporaryNodeFolderL but cretes a bundle folder
* instead.
*
* @see CNcdNodeManagerProxy::CreateTemporaryNodeFolderL
*/
CNcdNodeProxy& CreateTemporaryBundleFolderL(
const CNcdNodeIdentifier& aMetadataIdentifier,
TBool aCreateMetaData );
/**
* This function works like CreateTemporaryNodeFolderL but cretes an item
* instead.
*
* @see CNcdNodeManagerProxy::CreateTemporaryNodeFolderL
*/
CNcdNodeProxy& CreateTemporaryNodeItemL(
const CNcdNodeIdentifier& aMetadataIdentifier,
TBool aCreateMetaData );
/**
* This function checks the node cache for the old temporary node. If the node exists it
* will be used. If the node does not exist, the node will be created to server side
* if the metadata exists there already. Correct type of the node is concluded from the
* type of the metadata. If the metadata does not exist, the node is not created and
* the function will leave.
*
* @param aMetadataIdentifier The metadata identifier.
* @return The node.
* @leave KErrNotFound If the node cannot be created since metadata does not exist.
*/
CNcdNodeProxy& CreateTemporaryNodeIfMetadataExistsL(
const CNcdNodeIdentifier& aMetadataIdentifier );
/**
* This function checks the node cache for the old node. If the node exists it will be used.
* If the node does not exist, the node will be asked from the server side node manager.
* Then, supplier node or temporary item or temporary folder proxy will be created.
*
* @note This function creates the supplier if the temporary node or corresponding metadata
* did not exist in the server side cache or in db. Unlike temporary node functions above,
* this function does not create the metadata if it does not exist in database.
*
* @note Supplier node will use CNcdNodeManagerProxy::ReplaceCacheNodeL to replace
* the supplier node in cache, when temporary node can be created and used.
*
* @param aMetadataIdentifier
*/
CNcdNodeProxy& CreateTemporaryOrSupplierNodeL( const CNcdNodeIdentifier& aMetadataIdentifier );
/**
* This function can be used if some node in cache list is
* wanted to be replaced by the new proxy node.
* This may the case if the original node type was not known
* when the node was created as a supplier node.
* After loading the node data from the web server,
* a temporary node of the correct type is created in server side.
* Then, that temporary node can be used instead.
*
* @note If the node is found from the server side, old node object is removed
* from the proxy ram cache and replaced by the new node object of the same
* node identifier. UI may still use the old node object
* if it owns it but after calling this function the manager will
* return pointer directly to the new node object instead.
*
* @param aNodeIdentifier The identifier of the node that will be replaced by the new
* node object.
* @return CNcdNodeProxy&
* @exception Leaves with KErrNotFound if the node did not exist in
* the server side.
*/
CNcdNodeProxy& ReplaceCacheNodeL( const CNcdNodeIdentifier& aNodeIdentifier );
public:
/**
* Checks if the node exists in the cache.
* @param aNodeIdentifier identifies the node that is looked for.
* @return CNcdNodeProxy* pointer to the node that can be found from
* the cache. NULL if the node was not found. Ownership is NOT transferred.
*/
CNcdNodeProxy* NodeExists( const CNcdNodeIdentifier& aNodeIdentifier ) const;
/**
* This informs the manager that the given node is deleted.
* Because the node is deleted, it has to be removed from the cache.
*
* @param aNode The node that was or will be deleted.
*/
void NodeDeleted( CNcdNodeProxy* aNode );
/**
* This function internalizes the given node and all the nodes
* whose metadata part of the identifier matches the given node.
* The related nodes are gotten from the node cache of this
* node manager proxy. This function is provided to make sure
* that if operations use temporary nodes and the API user may
* still have the handle to the original node, the operation may
* also update the original nodes instead of just the temporary
* one.
*
* @param aNode Node that will be internalized and used to
* search for other related nodes for internalization.
*/
void InternalizeRelatedNodesL( CNcdNodeProxy& aNode ) const;
/**
* Getter for subscription manager.
*
* @return Reference to subscription manager.
*/
CNcdSubscriptionManagerProxy& SubscriptionManager() const;
/**
* Setter for favorite manager. This must be set always!
*
* @param aFavoriteManager The favorite manager.
*/
void SetFavoriteManager( CNcdFavoriteManagerProxy& aFavoriteManager );
/**
* Clears all search result nodes.
*/
void ClearSearchResultsL();
/**
*
* @param aServerUri Server URI
* @param aNamespace Namespace
*/
TBool IsCapabilitySupportedL( const CNcdNodeIdentifier& aNode,
const TDesC& aCapability );
/**
* Internalizes expired nodes and notifies api users via provider.
*
* @param aExpiredNodes A list of expired nodes in need of re-loading.
*/
void HandleExpiredNodesL( RPointerArray< CNcdExpiredNode >& aExpiredNodes );
/**
* @return CNcdProviderProxy& Reference to the provider.
*/
CNcdProviderProxy& Provider() const;
protected:
/**
* Constructor
*/
CNcdNodeManagerProxy(
MCatalogsClientServer& aSession,
TInt aHandle,
CNcdOperationManagerProxy& aOperationManager,
CNcdSubscriptionManagerProxy& aSubscriptionManager,
CNcdProviderProxy& aProvider );
/**
* ConstructL
*/
virtual void ConstructL();
private:
// Prevent if not implemented
CNcdNodeManagerProxy( const CNcdNodeManagerProxy& aObject );
CNcdNodeManagerProxy& operator =( const CNcdNodeManagerProxy& aObject );
/*
CNcdNodeProxy& CNcdNodeManagerProxy::CreateSchemeNodeL(
const CNcdNodeIdentifier& aMetadataIdentifier,
TInt aFunctionId );
*/
CNcdNodeProxy& CreateNodeL( const CNcdNodeIdentifier& aNodeIdentifier );
private: // data
// This manager is required when nodes are created.
// Because they should now the operation manager which
// they use to ask and create operations.
CNcdOperationManagerProxy& iOperationManager;
// This manager is required when nodes are created.
// Because their purchase should know the manager.
CNcdSubscriptionManagerProxy& iSubscriptionManager;
// This manager is required when nodes are create since
// it must be given to all the nodes. Not own.
CNcdFavoriteManagerProxy* iFavoriteManager;
// This array contains all the nodes that have been created.
RPointerArray<CNcdNodeProxy> iNodeCache;
// Root node under which everything else is located.
CNcdRootNodeProxy* iRootNode;
// Search root node under which all search results are located.
CNcdSearchRootNodeProxy* iSearchRootNode;
// Needed for expiration callback
CNcdProviderProxy& iProvider;
};
#endif // NCD_NODE_MANAGER_PROXY_H