1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Implements CNcdNodeManager class

    15 *

    16 */

    17 

    18 

    19 #include "ncdnodemanager.h"

    20 

    21 #include <e32err.h>

    22 #include <s32mem.h>

    23 #include <badesca.h>

    24 

    25 #include "ncdnodedbmanager.h"

    26 #include "ncdnodecachecleaner.h"

    27 #include "ncdnodecachecleanermanager.h"

    28 #include "ncdnodeidentifier.h"

    29 #include "ncdnodeidentifiereditor.h"

    30 #include "ncdnodeclassids.h"

    31 #include "ncdnodeimpl.h"

    32 #include "ncdnodeitem.h"

    33 #include "ncdnodefolder.h"

    34 #include "ncdbundlefolder.h"

    35 #include "ncdnodetransparentfolder.h"

    36 #include "ncdrootnode.h"

    37 #include "ncdsearchnodefolder.h"

    38 #include "ncdnodelink.h"

    39 #include "ncdnodemetadataimpl.h"

    40 #include "ncdnodeitemmetadata.h"

    41 #include "ncdnodefoldermetadata.h"

    42 #include "ncdsearchnodeitem.h"

    43 #include "ncdsearchnodefolder.h"

    44 #include "ncdsearchrootnode.h"

    45 #include "ncdexpirednode.h"

    46 #include "ncdchildentity.h"

    47 #include "ncdpurchasehistorydbimpl.h"

    48 #include "ncdnodepreviewimpl.h"

    49 #include "ncdstoragedescriptordataitem.h"

    50 #include "catalogsbasemessage.h"

    51 #include "catalogssession.h"

    52 #include "ncd_pp_folderref.h"

    53 #include "ncd_pp_itemref.h"

    54 #include "ncd_pp_dataentity.h"

    55 #include "ncd_pp_download.h"

    56 #include "ncdpreviewmanager.h"

    57 #include "ncdstoragemanagerimpl.h"

    58 #include "ncdconfigurationmanager.h"

    59 #include "ncdnodefunctionids.h"

    60 #include "ncdproviderdefines.h"

    61 #include "ncdserverdetails.h"

    62 #include "catalogscontext.h"

    63 #include "catalogsutils.h"

    64 #include "catalogsconstants.h"

    65 #include "ncd_pp_expiredcacheddata.h"

    66 #include "ncdproviderutils.h"

    67 #include "ncdutils.h"

    68 #include "ncdsearchnodebundle.h"

    69 #include "ncdfavoritemanagerimpl.h"

    70 #include "ncdnodeseeninfo.h"

    71 #include "ncdnodeiconimpl.h"

    72 #include "ncderrors.h"

    73 #include "ncdsearchablenode.h"

    74 #include "ncdnodeidentifierutils.h"

    75 #include "ncdgeneralmanager.h"

    76 

    77 #include "catalogsdebug.h"

    78 

    79 // If the values from the provider are given in kilos and other classes

    80 // require them in bytes, this value can be used for conversion.

    81 const TInt KBytesToKilos( 1024 );

    82 

    83 const TInt KNodeCacheGranularity = 256;

    84 

    85 CNcdNodeManager::CNcdNodeManager( CNcdGeneralManager& aGeneralManager )

    86 : CCatalogsCommunicable(),

    87   iPurchaseHistory( aGeneralManager.PurchaseHistory() ),  

    88   iNodeCache( KNodeCacheGranularity ),

    89   iNodeMetaDataCache( KNodeCacheGranularity ),

    90   iTempNodeCache( KNodeCacheGranularity ),

    91   iConfigurationManager( aGeneralManager.ConfigurationManager() ),

    92   iNodeOrder( CNcdNode::Compare ),

    93   iGeneralManager( aGeneralManager )

    94     {

    95     DLTRACEIN((""));    

    96     }

    97 

    98 

    99 void CNcdNodeManager::ConstructL()

   100     {

   101     DLTRACEIN((""));

   102     iGeneralManager.SetNodeManager( *this );

   103     iDbManager = CNcdNodeDbManager::NewL( iGeneralManager.StorageManager() );

   104     

   105     // Make sure that db manager is created before factory is created.

   106     iNodeFactory = CNcdNodeFactory::NewL( *this );

   107     

   108     // Notice that this function uses the objects created above.

   109     // So, if the creation is moved somewhere else, make sure that

   110     // NodeDbManager and NodeFactory are also created.

   111     iNodeCacheCleanerManager = 

   112         CNcdNodeCacheCleanerManager::NewL( iGeneralManager, 

   113                                            NodeDbManager(),

   114                                            NcdProviderDefines::KDbDefaultMaxByteSize,

   115                                            NodeFactory() );

   116 

   117     iPreviewManager = CNcdPreviewManager::NewL( iGeneralManager, 

   118                                           NcdProviderDefines::KMaxClientPreviews );

   119     iPreviewManager->LoadDataL();

   120     iGeneralManager.SetNodeManager( *this );

   121     

   122     iSeenInfo = CNcdNodeSeenInfo::NewL( iGeneralManager );

   123 

   124     iSearchableNode = new ( ELeave ) CNcdSearchableNode( *this );

   125     DLTRACEOUT((""));

   126     }

   127 

   128 

   129 CNcdNodeManager::~CNcdNodeManager()

   130     {

   131     DLTRACEIN((""));

   132     

   133     // Ensure that all cached objects are closed

   134     FullCacheCleanup();

   135 

   136 

   137     if ( iSearchableNode ) 

   138         {

   139         iSearchableNode->Close();        

   140         }

   141         

   142     // Delete member variables in reverse order when comparing

   143     // to the creation order.

   144 

   145     delete iPreviewManager;

   146     

   147     // Delete node cache cleaner.

   148     delete iNodeCacheCleanerManager;   

   149 

   150     // Delete node factory.

   151     delete iNodeFactory;

   152 

   153     // Delete the db manager.

   154     delete iDbManager;

   155     

   156     // Delete the seen info.

   157     delete iSeenInfo;

   158 

   159     iClientDatabaseLocks.Close();

   160     

   161     DLTRACEOUT((""));

   162     }

   163 

   164 

   165 CNcdNodeManager* CNcdNodeManager::NewL( CNcdGeneralManager& aGeneralManager )

   166     {

   167     CNcdNodeManager* self =

   168         new( ELeave ) CNcdNodeManager( aGeneralManager );

   169     CleanupClosePushL( *self );

   170     self->ConstructL();

   171     CleanupStack::Pop( self );

   172     return self;

   173     }

   174 

   175 

   176 // ---------------------------------------------------------------------------

   177 // General getter functions

   178 // ---------------------------------------------------------------------------

   179 

   180 CNcdPurchaseHistoryDb& CNcdNodeManager::PurchaseHistory() const

   181     {

   182     return iPurchaseHistory;

   183     }

   184 

   185 CNcdPreviewManager& CNcdNodeManager::PreviewManager()  const

   186     {

   187     return *iPreviewManager;

   188     }

   189 

   190 

   191 

   192 // ---------------------------------------------------------------------------

   193 // Functions to get node objects from caches or from db. 

   194 // And, functions to create node objects.

   195 // ---------------------------------------------------------------------------

   196 

   197 CNcdNode& CNcdNodeManager::NodeL( const CNcdNodeIdentifier& aIdentifier )

   198     {

   199     DLTRACEIN((""));

   200     

   201     CNcdNode* node = NodePtrL( aIdentifier );

   202     if ( node == NULL )

   203         {

   204         User::Leave( KErrNotFound );

   205         }

   206 

   207     DLTRACEOUT((""));

   208     return *node;

   209     }

   210 

   211 CNcdNode& CNcdNodeManager::NodeL( const CNcdNodeIdentifier& aParentNodeIdentifier,

   212                                   const CNcdNodeIdentifier& aNodeMetaDataIdentifier )

   213     {

   214     DLTRACEIN((""));

   215     

   216     CNcdNodeIdentifier* identifier =

   217         NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentNodeIdentifier, 

   218                                                          aNodeMetaDataIdentifier );

   219     CNcdNode& node = NodeL( *identifier );

   220 

   221     CleanupStack::PopAndDestroy( identifier );

   222 

   223     DLTRACEOUT((""));

   224 

   225     return node;

   226     }

   227 

   228 

   229 CNcdNode* CNcdNodeManager::NodePtrL( const CNcdNodeIdentifier& aIdentifier )

   230     {

   231     DLTRACEIN(( _L("Node id: %S, %S, %d"), 

   232                 &aIdentifier.NodeNameSpace(),

   233                 &aIdentifier.NodeId(),

   234                 aIdentifier.ClientUid().iUid ));

   235 

   236     CNcdNode* node( FindNodeFromCacheL( aIdentifier ) );

   237     if ( node != NULL )

   238         {

   239         DLTRACEOUT(("Found node"));

   240         return node;

   241         }

   242 

   243     DLINFO(("Start loading the node from storage"));

   244     // Check if the node can be found from the db because it was not found

   245     // from the cache.

   246     // This function leaves with KErrNotFound if the data was not found from

   247     // the database. If this is the case then the data should be loaded from

   248     // internet. But it is not job of this function. Let it leave.

   249     TRAPD( trapError, node = &DbNodeL( aIdentifier ) );

   250     if ( trapError == KErrNotFound )

   251         {

   252         // Node was not found from db. So, return NULL value.

   253         DLTRACEOUT(("Node was not found anywhere. Return NULL."));

   254         return NULL;

   255         }

   256     // Leave if some other error occurred.

   257     User::LeaveIfError( trapError );

   258 

   259     DLTRACEOUT(("Node found from db"));

   260     return node;

   261     }

   262 

   263 

   264 CNcdNode* CNcdNodeManager::NodePtrL( const CNcdNodeIdentifier& aParentNodeIdentifier,

   265                                      const CNcdNodeIdentifier& aNodeMetaDataIdentifier )

   266     {

   267     DLTRACEIN((""));

   268     

   269     CNcdNodeIdentifier* identifier =

   270         NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentNodeIdentifier, 

   271                                                          aNodeMetaDataIdentifier );

   272     CNcdNode* node = NodePtrL( *identifier );

   273 

   274     CleanupStack::PopAndDestroy( identifier );

   275 

   276     DLTRACEOUT((""));

   277 

   278     return node;

   279     }

   280 

   281 

   282 CNcdNodeFolder& CNcdNodeManager::FolderL( const CNcdNodeIdentifier& aIdentifier )

   283     {

   284     DLTRACEIN(( _L("Node id: %S, %S, %d"), 

   285                 &aIdentifier.NodeNameSpace(),

   286                 &aIdentifier.NodeId(),

   287                 aIdentifier.ClientUid().iUid ));

   288 

   289     CNcdNode& node( NodeL( aIdentifier ) );

   290     CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

   291     if ( nodeType != CNcdNodeFactory::ENcdNodeFolder &&

   292         nodeType != CNcdNodeFactory::ENcdNodeSearchBundle

   293          && nodeType != CNcdNodeFactory::ENcdNodeRoot )

   294         {

   295         // The node was not of the right type

   296         DLERROR(("Wrong type of node: %d. Should be folder: %d or %d or %d",

   297                  nodeType, 

   298                  CNcdNodeFactory::ENcdNodeFolder,

   299                  CNcdNodeFactory::ENcdNodeSearchBundle,

   300                  CNcdNodeFactory::ENcdNodeRoot));

   301 

   302         // For debug purposes

   303         DASSERT( EFalse );

   304                 

   305         User::Leave( KErrArgument );

   306         }

   307 

   308     DLTRACEOUT((""));

   309 

   310     return static_cast<CNcdNodeFolder&>( node );

   311     }

   312 

   313 

   314 CNcdRootNode& CNcdNodeManager::RootNodeL( const TUid& aClientUid )

   315     {

   316     DLTRACEIN((""));

   317 

   318     // All the search roots have the same namespace, but their ids are

   319     // the client UIDs.

   320     CNcdNodeIdentifier* identifier = 

   321         NcdNodeIdentifierEditor::CreateRootIdentifierForClientLC( aClientUid );

   322 

   323     CNcdNode& node( NodeL( *identifier ) );

   324 

   325     CleanupStack::PopAndDestroy( identifier );

   326 

   327     // Check the type to make sure that the casting is ok in the end.

   328     CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

   329     if ( nodeType != CNcdNodeFactory::ENcdNodeRoot )

   330         {

   331         // The node was not right

   332         DLERROR(("Wrong node type. Should be root"));

   333 

   334         // For debug purposes

   335         DASSERT( EFalse );

   336                 

   337         User::Leave( KErrArgument );

   338         }

   339 

   340     DLTRACEOUT((""));

   341 

   342     return static_cast<CNcdRootNode&>( node );            

   343     }

   344 

   345 

   346 CNcdSearchNodeFolder& CNcdNodeManager::SearchFolderL( const CNcdNodeIdentifier& aParentNodeIdentifier,

   347                                                       const CNcdNodeIdentifier& aNodeMetaDataIdentifier )

   348     {

   349     DLTRACEIN((""));

   350 

   351     CNcdNode& node( NodeL( aParentNodeIdentifier, aNodeMetaDataIdentifier ) );

   352     

   353     // Check the type and purpose to make sure that the casting is ok in the end.

   354     CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

   355     CNcdNodeFactory::TNcdNodePurpose nodePurpose( NodeFactory().NodePurposeL( node ) );

   356     if ( nodeType != CNcdNodeFactory::ENcdNodeFolder

   357          && nodeType != CNcdNodeFactory::ENcdNodeRoot

   358          || nodePurpose != CNcdNodeFactory::ENcdSearchNode )

   359         {

   360         // The node was not right

   361         DLERROR(("Wrong node class."));

   362 

   363         DASSERT( EFalse );

   364 

   365         // The node was not of the right type

   366         User::Leave( KErrArgument );

   367         }

   368 

   369     DLTRACEOUT((""));

   370 

   371     return static_cast<CNcdSearchNodeFolder&>( node );

   372     }

   373 

   374 

   375 CNcdSearchNodeFolder& CNcdNodeManager::SearchFolderL( const CNcdNodeIdentifier& aNodeIdentifier )

   376     {

   377     DLTRACEIN((""));

   378 

   379     CNcdNode& node( NodeL( aNodeIdentifier ));

   380     

   381     // Check the type and purpose to make sure that the casting is ok in the end.

   382     CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

   383     CNcdNodeFactory::TNcdNodePurpose nodePurpose( NodeFactory().NodePurposeL( node ) );

   384     if ( nodeType != CNcdNodeFactory::ENcdNodeFolder

   385          && nodeType != CNcdNodeFactory::ENcdNodeRoot

   386          && nodeType != CNcdNodeFactory::ENcdNodeSearchBundle

   387          || nodePurpose != CNcdNodeFactory::ENcdSearchNode )

   388         {

   389         // The node was not right

   390         DLERROR(("Wrong node class."));

   391 

   392         DASSERT( EFalse );

   393 

   394         // The node was not of the right type

   395         User::Leave( KErrArgument );

   396         }

   397 

   398     DLTRACEOUT((""));

   399 

   400     return static_cast<CNcdSearchNodeFolder&>( node );

   401     }

   402     

   403     

   404 CNcdSearchNodeItem& CNcdNodeManager::SearchNodeItemL( const CNcdNodeIdentifier& aNodeIdentifier )

   405     {

   406     DLTRACEIN((""));

   407 

   408     CNcdNode& node( NodeL( aNodeIdentifier ));

   409     

   410     if ( node.ClassId() != NcdNodeClassIds::ENcdSearchItemNodeClassId )

   411         {

   412         // The node was not right

   413         DLERROR(("Wrong node class."));

   414 

   415         DASSERT( EFalse );

   416 

   417         // The node was not of the right type

   418         User::Leave( KErrArgument );

   419         }

   420 

   421     DLTRACEOUT((""));

   422 

   423     return static_cast<CNcdSearchNodeItem&>( node );

   424     }

   425 

   426 

   427 CNcdNode& CNcdNodeManager::CreateNodeL( CNcdNodeFactory::TNcdNodeType aNodeType,

   428                                         CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

   429                                         const CNcdNodeIdentifier& aNodeIdentifier )

   430     {

   431     DLTRACEIN(("Nodetype: %d, nodepurpose: %d", aNodeType, aNodePurpose));

   432     DLINFO((_L("Identifier ns: %S, id: %S"), 

   433             &aNodeIdentifier.NodeNameSpace(),

   434             &aNodeIdentifier.NodeId()));

   435 

   436     // The node identifier can not be empty

   437     DASSERT( !aNodeIdentifier.ContainsEmptyFields() );

   438 

   439     // Get the class id of the node that has the given purpose.

   440     // The data type parameter informs if an item or a folder should be created.

   441     // Set the class id to be some item as a default.

   442     NcdNodeClassIds::TNcdNodeClassId classId =

   443             NodeFactory().NodeClassIdL( aNodeType, aNodePurpose );

   444 

   445     DLINFO(("classid of node: %d", classId));

   446 

   447     CNcdNode* node( NodePtrL( aNodeIdentifier ) );

   448        

   449     if ( node == NULL )

   450         {

   451         DLINFO(("Create node"));

   452         // Create the node according to the class id

   453         node = NodeFactory().CreateNodeLC( aNodeIdentifier,

   454                                            classId );

   455 

   456         DASSERT( node );

   457         

   458         // and insert node to the cache.

   459         AppendNodeToCacheL( node );

   460         

   461         // cache takes ownership of the node

   462         CleanupStack::Pop( node );

   463         

   464         // NodePtr inserts the metadata if node was found there.

   465         // There is no reason to insert the metadata here, because the

   466         // node has been just created, and it does not contains the

   467         // link data where the metadata id info is inserted.

   468         }

   469     else if ( NodeFactory().NodeTypeL( *node ) != aNodeType

   470               || NodeFactory().NodePurposeL( *node  ) != aNodePurpose )

   471         {

   472         // Node was already in the list. But, the node is not

   473         // of the expected type or purpose.

   474         // Notice, that if the requested node purpose was scheme node and the

   475         // node that already exists is of the different purpose, then we use the

   476         // original node. So, schemes do not require this checking.

   477         DLINFO(("classid of real node: %d", node->ClassId() ));

   478         DLERROR(("Wrong node type or purpose."));

   479         DLERROR(("Type: %d, should be: %d",

   480                  NodeFactory().NodeTypeL( *node ), 

   481                  aNodeType));

   482         DLERROR(("Purpose: %d, should be: %d",

   483                  NodeFactory().NodePurposeL( *node ), 

   484                  aNodePurpose));

   485         DASSERT( EFalse );

   486         User::Leave( KErrArgument );

   487         }

   488 

   489     DLTRACEOUT((""));

   490 

   491     return *node;     

   492     }

   493 

   494 

   495 CNcdNode& CNcdNodeManager::CreateNodeL( CNcdNodeFactory::TNcdNodeType aNodeType,

   496                                         CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

   497                                         const CNcdNodeIdentifier& aParentNodeIdentifier,

   498                                         const CNcdNodeIdentifier& aMetaDataIdentifier )

   499     {

   500     DLTRACEIN((""));

   501 

   502     // Check the metadata identifier because it has to contain values. These values

   503     // are used when the node is created. The parent node may contain empty values.

   504     // because the root does not have parent.

   505     if ( aMetaDataIdentifier.ContainsEmptyFields() )

   506         {

   507         DLERROR(("Cannot create node with empty identifier meta values"));

   508         

   509         // For debug purposes

   510         DASSERT( EFalse );

   511         

   512         User::Leave( KErrArgument );

   513         }

   514 

   515     // Try to find the node before creating it.

   516     // Use the correct form of identifier by asking it from the factory

   517     CNcdNodeIdentifier* identifier =

   518         NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentNodeIdentifier, 

   519                                                          aMetaDataIdentifier );

   520     CNcdNode& node( CreateNodeL( aNodeType, aNodePurpose, *identifier ) );

   521     CleanupStack::PopAndDestroy( identifier );

   522 

   523     DLTRACEOUT((""));

   524 

   525     return node; 

   526     }

   527 

   528 

   529 CNcdNodeItem& CNcdNodeManager::CreateNodeItemL( CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

   530                                                 const CNcdNodeIdentifier& aNodeIdentifier )

   531     {

   532     DLTRACEIN((""));

   533 

   534     CNcdNode& node =

   535         CreateNodeL( CNcdNodeFactory::ENcdNodeItem, aNodePurpose, 

   536                      aNodeIdentifier );

   537     

   538     // Now it is safe to do casting.

   539 

   540     DLTRACEOUT((""));

   541 

   542     return static_cast<CNcdNodeItem&>(node);    

   543     }

   544 

   545 CNcdNodeItem& CNcdNodeManager::CreateNodeItemL( CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

   546                                                 const CNcdNodeIdentifier& aParentNodeIdentifier,

   547                                                 const CNcdNodeIdentifier& aMetaDataIdentifier )

   548     {

   549     DLTRACEIN((""));

   550 

   551     CNcdNode& node =

   552         CreateNodeL( CNcdNodeFactory::ENcdNodeItem, aNodePurpose, 

   553                      aParentNodeIdentifier, aMetaDataIdentifier );

   554     

   555     // Now it is safe to do casting.

   556 

   557     DLTRACEOUT((""));

   558 

   559     return static_cast<CNcdNodeItem&>(node);   

   560     }

   561 

   562 

   563 CNcdNodeFolder& CNcdNodeManager::CreateNodeFolderL( CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

   564                                                     const CNcdNodeIdentifier& aNodeIdentifier,

   565                                                     CNcdNodeFactory::TNcdNodeType aFolderType )

   566     {

   567     DLTRACEIN((""));

   568 

   569     CNcdNode& node =

   570         CreateNodeL( aFolderType, aNodePurpose, 

   571                      aNodeIdentifier );

   572     

   573     // Now it is safe to do casting.

   574 

   575     DLTRACEOUT((""));

   576 

   577     return static_cast<CNcdNodeFolder&>(node);    

   578     }

   579     

   580 CNcdNodeFolder& CNcdNodeManager::CreateNodeFolderL( CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

   581                                                     const CNcdNodeIdentifier& aParentNodeIdentifier,

   582                                                     const CNcdNodeIdentifier& aMetaDataIdentifier,

   583                                                     CNcdNodeFactory::TNcdNodeType aFolderType )

   584     {

   585     DLTRACEIN((""));

   586 

   587     CNcdNode& node =

   588         CreateNodeL( aFolderType, aNodePurpose, 

   589                      aParentNodeIdentifier, aMetaDataIdentifier );

   590     

   591     // Now it is safe to do casting.

   592 

   593     DLTRACEOUT((""));

   594 

   595     return static_cast<CNcdNodeFolder&>(node);    

   596     }    

   597 

   598 

   599 CNcdRootNode& CNcdNodeManager::CreateRootL( const TUid& aClientUid )

   600     {

   601     DLTRACEIN((""));

   602     

   603     CNcdNodeIdentifier* rootIdentifier( 

   604         NcdNodeIdentifierEditor::CreateRootIdentifierForClientLC( aClientUid ) );

   605         

   606     CNcdNode& node( CreateNodeL( CNcdNodeFactory::ENcdNodeRoot,

   607                                  CNcdNodeFactory::ENcdNormalNode,

   608                                  *rootIdentifier ) );

   609 

   610     CleanupStack::PopAndDestroy( rootIdentifier );

   611 

   612     DLTRACEOUT((""));

   613 

   614     return static_cast<CNcdRootNode&>( node );            

   615     }

   616 

   617 

   618 CNcdRootNode& CNcdNodeManager::CreateRootL( const MCatalogsContext& aContext )

   619     {

   620     DLTRACEIN((""));

   621     return CreateRootL( aContext.FamilyId() );

   622     }

   623     

   624     

   625 CNcdNodeFolder& CNcdNodeManager::CreateSearchRootL( const MCatalogsContext& aContext )

   626     {

   627     DLTRACEIN((""));

   628     

   629     CNcdNodeIdentifier* rootIdentifier( 

   630         NcdNodeIdentifierEditor::CreateSearchRootIdentifierForClientLC( aContext.FamilyId() ) );

   631         

   632     CNcdNode& node( CreateNodeL( CNcdNodeFactory::ENcdNodeRoot,

   633                                  CNcdNodeFactory::ENcdSearchNode,

   634                                  *rootIdentifier ) );

   635 

   636     CleanupStack::PopAndDestroy( rootIdentifier );

   637 

   638     DLTRACEOUT((""));

   639 

   640     return static_cast<CNcdNodeFolder&>( node );

   641     }

   642 

   643 

   644 CNcdNodeFolder& CNcdNodeManager::CreateBundleFolderL( const CNcdNodeIdentifier& aMetaDataIdentifier )

   645     {

   646     DLTRACEIN((""));

   647     // The parent of the bundle is always the root folder

   648     CNcdNodeIdentifier* rootIdentifier = 

   649         NcdNodeIdentifierEditor::CreateRootIdentifierForClientLC( aMetaDataIdentifier.ClientUid() );

   650 

   651     CNcdNodeFolder& folder =

   652         CreateNodeFolderL( CNcdNodeFactory::ENcdBundleNode, 

   653                            *rootIdentifier, 

   654                            aMetaDataIdentifier );

   655                            

   656     CleanupStack::PopAndDestroy( rootIdentifier );

   657 

   658     DLTRACEOUT((""));

   659     

   660     return folder;

   661     }

   662 

   663 

   664 CNcdNode& CNcdNodeManager::CreateTemporaryNodeOrSupplierL( const CNcdNodeIdentifier& aMetaDataIdentifier )

   665     {

   666     DLTRACEIN((""));

   667 

   668     CNcdNode* node( NULL );

   669 

   670     // First check if the given temporary node already exists in RAM or in databse.

   671     // We can use NodeL also for this operation.

   672     CNcdNodeIdentifier* tempNodeIdentifier =

   673         NcdNodeIdentifierEditor::CreateTemporaryNodeIdentifierLC( aMetaDataIdentifier );

   674         

   675     // Note that if the node is found it is also inserted into the node cache

   676     // but it is not saved into the database.

   677     TRAP_IGNORE( node = &NodeL( *tempNodeIdentifier ) );

   678 

   679     // If the temporary node did not exist. Then create supplier, which also checks

   680     // if the corresponding node already exists in RAM or in database.

   681     // CreateNodeL can handle this.

   682     // If it does not exist then there is still possibility that the corresponding

   683     // metadata exists. If metadata exists, then it can be used to create the correct

   684     // temporary node

   685     if ( node == NULL )

   686         {

   687         // First check the metadata.

   688         // The ownership of the meta will be in cache.

   689         CNcdNodeMetaData* meta( NULL );

   690         TRAP_IGNORE( meta = &NodeMetaDataL( aMetaDataIdentifier ) );

   691         

   692         if ( meta != NULL )

   693             {

   694             DLINFO(("Meta was found for the temp node"));

   695             

   696             // Metadata was found. So, create right type temporary node.

   697             if ( meta->ClassId() 

   698                     == NcdNodeClassIds::ENcdFolderNodeMetaDataClassId )

   699                 {

   700                 DLINFO(("Create temp folder"));

   701                 node = &CreateNodeFolderL( CNcdNodeFactory::ENcdNormalNode,

   702                                            *tempNodeIdentifier );

   703                 }

   704             else if ( meta->ClassId() 

   705                         == NcdNodeClassIds::ENcdItemNodeMetaDataClassId )

   706                 {

   707                 DLINFO(("Create temp item"));

   708                 node = &CreateNodeItemL( CNcdNodeFactory::ENcdNormalNode,

   709                                          *tempNodeIdentifier );                

   710                 }

   711             else

   712                 {

   713                 DLINFO(("Unknown meta type"));

   714                 DASSERT( EFalse );

   715                 User::Leave( KErrUnknown );

   716                 }

   717             

   718             DLINFO(("Setting node metadata"))

   719             node->SetNodeMetaDataL( *meta );

   720             }

   721         else

   722             {

   723             DLINFO(("Create node supplier"));

   724             node = &CreateNodeL( CNcdNodeFactory::ENcdNodeSupplier,

   725                                  CNcdNodeFactory::ENcdNormalNode,

   726                                  *tempNodeIdentifier );

   727             }

   728         }

   729     // Notice that if the node creation worked correctly, it will

   730     // be added to the cache list. So the ownership is in cache, so

   731     // no need to keep the node in cleanup stack.

   732     

   733     // Now that we have the node, make sure that all the necessary information

   734     // is inserted to its link. This includes metadata identifier and the

   735     // server uri.

   736     CNcdNodeLink& link( node->CreateAndSetLinkL() );

   737     link.SetMetaDataIdentifierL( aMetaDataIdentifier );

   738     link.SetServerUriL( aMetaDataIdentifier.ServerUri() );

   739     

   740     CleanupStack::PopAndDestroy( tempNodeIdentifier );

   741 

   742     // Now that everything is ok, save the node into the db.

   743     DbSaveNodeL( *node );

   744     

   745     DLTRACEOUT((""));

   746     

   747     return *node;

   748     }

   749     

   750 

   751 CNcdNode* CNcdNodeManager::CreateTemporaryNodeIfMetadataExistsL(

   752     const CNcdNodeIdentifier& aMetadataIdentifier ) 

   753     {

   754     DLTRACEIN((""));

   755     

   756     // Check if the metadata exists.

   757     CNcdNodeMetaData* metadata( NULL );

   758     TRAPD( err, metadata = &NodeMetaDataL( aMetadataIdentifier ) );

   759     if ( err == KErrNotFound ) 

   760         {

   761         // Metadata not found, cannot do anything.

   762         return NULL;

   763         }

   764     

   765     User::LeaveIfError( err );

   766     DASSERT( metadata );

   767     

   768     // Metadata exists, create temporary node of correct type.   

   769 

   770     // First check if the given temporary node already exists in RAM or in databse.

   771     // We can use NodeL also for this operation.

   772     CNcdNodeIdentifier* tempNodeIdentifier =

   773         NcdNodeIdentifierEditor::CreateTemporaryNodeIdentifierLC( aMetadataIdentifier );

   774 

   775     CNcdNode* node( NULL );

   776     TRAP( err, node = &NodeL( *tempNodeIdentifier ) );

   777     LeaveIfNotErrorL( err, KErrNotFound );

   778     

   779     if ( node == NULL )

   780         {

   781         // If the temporary node did not exist. Create one according to the type of

   782         // the metadata.            

   783         if ( metadata->ClassId() == NcdNodeClassIds::ENcdFolderNodeMetaDataClassId )

   784             {

   785             DLINFO(("Create temp folder"));

   786             node = &CreateNodeFolderL( CNcdNodeFactory::ENcdNormalNode,

   787                                        *tempNodeIdentifier );

   788             }

   789         else if ( metadata->ClassId() 

   790                     == NcdNodeClassIds::ENcdItemNodeMetaDataClassId )

   791             {

   792             DLINFO(("Create temp item"));

   793             node = &CreateNodeItemL( CNcdNodeFactory::ENcdNormalNode,

   794                                      *tempNodeIdentifier );                

   795             }

   796         else

   797             {

   798             DLINFO(("Unknown meta type"));

   799             DASSERT( EFalse );

   800             User::Leave( KErrUnknown );

   801             }

   802         

   803         DLINFO(("Setting node metadata"))

   804         node->SetNodeMetaDataL( *metadata );

   805         }

   806     else

   807         {

   808         // Temporary node exists. Check that it has the metadata.

   809         CNcdNodeMetaData* existingMeta = node->NodeMetaData();

   810         if ( existingMeta )

   811             {

   812             DASSERT( existingMeta == metadata );

   813             }

   814         else 

   815             {

   816             // Temporary node did not have metadata, install it.

   817             node->SetNodeMetaDataL( *metadata );

   818             }

   819         }

   820         

   821     DASSERT( node );

   822     DASSERT( node->NodeMetaData() );

   823     

   824     // Notice that if the node creation worked correctly, it will

   825     // be added to the cache list. So the ownership is in cache, so

   826     // no need to keep the node in cleanup stack.

   827     

   828     // Now that we have the node, make sure that all the necessary information

   829     // is inserted to its link. This includes metadata identifier and the

   830     // server uri.

   831     CNcdNodeLink& link( node->CreateAndSetLinkL() );

   832     link.SetMetaDataIdentifierL( aMetadataIdentifier );

   833     link.SetServerUriL( aMetadataIdentifier.ServerUri() );

   834     

   835     CleanupStack::PopAndDestroy( tempNodeIdentifier );

   836 

   837     // Now that everything is ok, save the node into the db.

   838     DbSaveNodeL( *node );

   839     

   840     DLTRACEOUT((""));

   841     

   842     return node;

   843     }

   844     

   845     

   846 CNcdSearchNodeBundle& CNcdNodeManager::CreateSearchBundleL( const CNcdNodeIdentifier& aMetaDataIdentifier,

   847     const CNcdNodeIdentifier& aParentIdentifier )

   848     {

   849     DLTRACEIN((""));

   850     

   851 

   852     CNcdNodeFolder& folder =

   853         CreateNodeFolderL( CNcdNodeFactory::ENcdSearchNode, 

   854                            aParentIdentifier, 

   855                            aMetaDataIdentifier,

   856                            CNcdNodeFactory::ENcdNodeSearchBundle );

   857                            

   858     // Now it is safe to do casting.

   859 

   860     DLTRACEOUT((""));

   861 

   862     return static_cast<CNcdSearchNodeBundle&>(folder);

   863     }

   864 

   865 CNcdSearchNodeFolder& CNcdNodeManager::CreateSearchFolderL( const CNcdNodeIdentifier& aMetaDataIdentifier,

   866     const CNcdNodeIdentifier& aParentIdentifier )

   867     {

   868     DLTRACEIN((""));

   869     

   870 

   871     CNcdNodeFolder& folder =

   872         CreateNodeFolderL( CNcdNodeFactory::ENcdSearchNode, 

   873                            aParentIdentifier, 

   874                            aMetaDataIdentifier,

   875                            CNcdNodeFactory::ENcdNodeFolder );

   876                            

   877     // Now it is safe to do casting.

   878 

   879     DLTRACEOUT((""));

   880 

   881     return static_cast<CNcdSearchNodeBundle&>(folder);

   882     }

   883 

   884 

   885 CNcdNodeMetaData& CNcdNodeManager::NodeMetaDataL(  

   886     const CNcdNodeIdentifier& aIdentifier )

   887     {

   888     DLTRACEIN(( _L("Metadata id: %S, %S, %d"), 

   889                 &aIdentifier.NodeNameSpace(),

   890                 &aIdentifier.NodeId(),

   891                 aIdentifier.ClientUid().iUid ));

   892 

   893     CNcdNodeMetaData* metaData( 

   894         FindNodeMetaDataFromCache( aIdentifier ) );

   895 

   896     if ( metaData == NULL )

   897         {

   898         // Check if the node can be found from the db because it was not found

   899         // from the cache.

   900         // This function leaves with KErrNotFound if the data was not found from

   901         // the database. If this is the case then the data should be loaded from

   902         // internet. But it is not job of this function. Let it leave.

   903         metaData = &DbMetaDataL( aIdentifier );        

   904         }

   905 

   906     DLTRACEOUT((""));

   907     

   908     return *metaData;

   909     }

   910 

   911 

   912 CNcdNodeMetaData& CNcdNodeManager::CreateNodeMetaDataL(

   913     const CNcdNodeIdentifier& aMetaDataIdentifier,

   914     CNcdNodeFactory::TNcdNodeType aMetaType ) 

   915     {

   916     

   917     DLTRACEIN(( _L("Metadata id: %S, %S, %d"), 

   918                 &aMetaDataIdentifier.NodeNameSpace(),

   919                 &aMetaDataIdentifier.NodeId(),

   920                 aMetaDataIdentifier.ClientUid().iUid ));

   921     

   922     CNcdNodeMetaData* metaData( NULL );

   923     TRAPD( err, metaData = &NodeMetaDataL( aMetaDataIdentifier ) );

   924     if ( err != KErrNone ) 

   925         {

   926         if ( err == KErrNotFound ) 

   927             {

   928             metaData = NodeFactory().CreateMetaDataLC( aMetaDataIdentifier, aMetaType );

   929             iNodeMetaDataCache.AppendL( metaData );

   930             // Cache takes ownership of the metadata

   931             CleanupStack::Pop( metaData );

   932             }

   933         else 

   934             {

   935             User::Leave( err );

   936             }

   937         }

   938     

   939     return *metaData;

   940     }

   941 

   942 

   943 

   944 // ---------------------------------------------------------------------------

   945 // Functions that are used to insert data information

   946 // gotten from the data parsers into the correct node

   947 // objects. These functions are provided for operations.

   948 // The updated information may also be inserted from the 

   949 // purchase history.

   950 // ---------------------------------------------------------------------------

   951 

   952 CNcdNode& CNcdNodeManager::RefHandlerL( 

   953     const CNcdNodeIdentifier& aParentNodeIdentifier,

   954     MNcdPreminetProtocolEntityRef& aData,

   955     const TUid& aClientUid,

   956     TNcdRefHandleMode aMode,

   957     TInt aIndex,

   958     CNcdNodeFactory::TNcdNodeType aParentNodeType,

   959     CNcdNodeFactory::TNcdNodePurpose aParentNodePurpose,

   960     CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

   961     TBool aCreateParent )

   962     {

   963     DLTRACEIN(("aData: %X, nodepurpose: %d, aCreateParent: %d", &aData, aNodePurpose, aCreateParent));

   964     

   965     DLINFO((_L("parent node ns: %S, id: %S"), 

   966 

   967             &aParentNodeIdentifier.NodeNameSpace(), &aParentNodeIdentifier.NodeId()));

   968     DLINFO((_L("parent node from entity ns: %S, id: %S"), 

   969             &aData.ParentNamespace(), &aData.ParentId()));

   970 

   971     DLINFO((_L("data ns: %S, id: %S"), 

   972             &aData.Namespace(), &aData.Id()));

   973             

   974     DLINFO((_L("insert index: %d, mode: %d"), aIndex, aMode ));

   975     DPROFILING_BEGIN( x );

   976 

   977     // Get the type of the node -- folder or item.

   978     CNcdNodeFactory::TNcdNodeType nodeType = CNcdNodeFactory::ENcdNodeItem;

   979     if ( aData.Type() == MNcdPreminetProtocolEntityRef::EFolderRef )

   980         {

   981         nodeType = CNcdNodeFactory::ENcdNodeFolder;

   982         }

   983     else if ( aData.Type() != MNcdPreminetProtocolEntityRef::EItemRef )

   984         {                

   985         // Wrong type

   986         DLINFO(( "Wrong node data type: %d", aData.Type() ));

   987         DASSERT( EFalse );

   988         User::Leave( KErrArgument );

   989         }   

   990 

   991     // Notice that the aClientUid is used here instead of the parent identifier uid,

   992     // because the parent identifier may be empty in some cases.

   993     CNcdNodeIdentifier* metaIdentifier = 

   994         CNcdNodeIdentifier::NewLC( aData.Namespace(), 

   995                                    aData.Id(),

   996                                    aData.ServerUri(), 

   997                                    aClientUid );

   998 

   999         

  1000     // Check if the node already exists in RAM cache or in the db.

  1001     // Also, check the node type. This function replaces old node

  1002     // in RAM cache (not in db) if the node type and purpose do

  1003     // not match with the ones gotten from the parser.

  1004     CNcdNode& node( CheckAndCreateNodeL( nodeType, 

  1005                                          aNodePurpose,

  1006                                          aParentNodeIdentifier,

  1007                                          *metaIdentifier ) );

  1008 

  1009 

  1010 

  1011     if ( aCreateParent ||

  1012          !aParentNodeIdentifier.ContainsEmptyFields() &&

  1013          NodePtrL( aParentNodeIdentifier ) ) 

  1014         {        

  1015         // Insert the node to the parent if it does not already exist there.

  1016         // Note that here we insert it into the actual parent. Not into the parent

  1017         // that is set for the proxy parent.

  1018         // Note that the node link is internalized after the node has been inserted into the

  1019         // parent. This way, the link will finally contain the correct info, for example

  1020         // the correct parent info.

  1021         // Make sure that the parent node type is correct in case root is used

  1022         AddToParentL( aParentNodeIdentifier, 

  1023                       *metaIdentifier, 

  1024                       aParentNodeType, 

  1025                       aParentNodePurpose, 

  1026                       aNodePurpose, 

  1027                       aMode, 

  1028                       aIndex );

  1029         DLINFO(("AddToParentL done, aData: %X", &aData));

  1030         }

  1031 

  1032     // Metaid is not needed anymore. So, delete it.

  1033     CleanupStack::PopAndDestroy( metaIdentifier );

  1034     metaIdentifier = NULL;

  1035 

  1036     // Internalize data to the link of the node

  1037     DLINFO(("Internalize link data"));

  1038     

  1039     // Note that the parent identifier should be checked if the parent is transparent in

  1040     // other words if this node should be child of transparent.

  1041     // Then the actual parent for the proxy transmission should be set to be the

  1042     // grand parent node.

  1043     if ( aNodePurpose == CNcdNodeFactory::ENcdChildOfTransparentNode )

  1044         {

  1045         DLINFO(("Transparent child. Get parent of parent"));

  1046         // Parse the correct grandparent identifier because the proxy side will get

  1047         // the grandparent identifier for the parent identifier info in case of transparent

  1048         // nodes.

  1049         CNcdNodeIdentifier* grandParentIdentifier( 

  1050             NcdNodeIdentifierEditor::ParentOfLC( aParentNodeIdentifier ) );

  1051         node.InternalizeLinkL( 

  1052             aData, aParentNodeIdentifier, *grandParentIdentifier, aClientUid );

  1053         CleanupStack::PopAndDestroy( grandParentIdentifier );

  1054         }

  1055     else 

  1056         {

  1057         node.InternalizeLinkL( 

  1058             aData, aParentNodeIdentifier, aParentNodeIdentifier, aClientUid );

  1059         }

  1060 

  1061     // Metadata of the node may exists in cache at this point already, but it is not

  1062     // installed to the node, because otherwise the state of the node would be

  1063     // "initialized" and UI would not reload the metadata. This is a problem if

  1064     // user wants to force refresh level3 view.

  1065     

  1066     // Save the node now after it has been inserted into its parent.

  1067     // Because the node has been updated and contains at least new

  1068     // link data, we should save the new data to the database.

  1069     DLINFO(("Save node"));

  1070 

  1071     DbSaveNodeL( node );

  1072     DPROFILING_END( x );

  1073     DLTRACEOUT((""));

  1074     

  1075     return node;

  1076     }

  1077 

  1078 

  1079 CNcdNode& CNcdNodeManager::DataHandlerL( 

  1080     const CNcdNodeIdentifier& aParentNodeIdentifier,

  1081     MNcdPreminetProtocolDataEntity& aData,

  1082     const TUid& aClientUid )

  1083     {

  1084     DLTRACEIN((_L("parent ns: %S, id: %S, data ns: %S, id: %S, name: %S"), 

  1085                 &aParentNodeIdentifier.NodeNameSpace(), &aParentNodeIdentifier.NodeId(), 

  1086                 &aData.Namespace(), &aData.Id(),&aData.Name()));

  1087     DPROFILING_BEGIN( x );

  1088     // Create the metadata according to the entity information

  1089     

  1090     // Notice:

  1091     // The data entity namespace information is conditional accroding to the protocol. 

  1092     // But the parser should always set the correct namespace. The parent node namespace

  1093     // can not be used here because the parent may be in different namespace than

  1094     // the child. At least if the root is used.

  1095 

  1096     // Notice that if the parent is for example root,

  1097     // then the parent server uri is KNullDesC which is not the right server.

  1098     // Use the serveruri that is gotten from the aData interface object.

  1099     // Also, notice that aClientUid is used here. Because in some special cases,

  1100     // the parent node identifier may be empty.

  1101     CNcdNodeIdentifier* metaId = 

  1102         CNcdNodeIdentifier::NewLC( aData.Namespace(), 

  1103                                    aData.Id(), 

  1104                                    aData.ServerUri(),

  1105                                    aClientUid );

  1106 

  1107     // The node should always exist in the database if metadata exist.

  1108     CNcdNode& node( NodeL( aParentNodeIdentifier, *metaId ) );

  1109 

  1110 

  1111     DLINFO(("Create metadata"));

  1112     CNcdNodeFactory::TNcdNodeType metaType( CNcdNodeFactory::ENcdNodeItem );

  1113     if ( aData.Type() == EFolderEntity )

  1114         {

  1115         metaType = CNcdNodeFactory::ENcdNodeFolder;

  1116         }

  1117     else if ( aData.Type() != EItemEntity )

  1118         {

  1119         DLERROR(("Wrong entity type"));

  1120         DASSERT( EFalse );

  1121         User::Leave( KErrArgument );

  1122         }

  1123     

  1124     // Checks that the old metadata is of the right type if it already

  1125     // exists. If the types do not match, then the old metadata in 

  1126     // RAM cache is replaced by the new metadata object that is of the

  1127     // correct type. Notice, that the db is not updated by this function call.    

  1128     CNcdNodeMetaData& metaData( 

  1129         CheckAndCreateMetaDataL( *metaId, metaType ) );    

  1130     

  1131     CleanupStack::PopAndDestroy( metaId );

  1132 

  1133     DLINFO(("Internalize meta"));

  1134