--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/client/inc/ncdnodemanagerproxy.h Thu Dec 17 08:51:10 2009 +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 <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