diff -r 000000000000 -r 32704c33136d ncdengine/provider/client/inc/ncdnodemanagerproxy.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/client/inc/ncdnodemanagerproxy.h Tue Jan 26 12:06:03 2010 +0200 @@ -0,0 +1,394 @@ +/* +* 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 +#include + +#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 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