/*
* 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:
*
*/
#include <badesca.h>
#include <s32mem.h>
#include <limits.h>
#include "ncdsearchoperationimpl.h"
#include "ncdoperationfunctionids.h"
#include "catalogsbasemessage.h"
#include "catalogshttpsession.h"
#include "catalogshttpoperation.h"
#include "catalogshttpconfig.h"
#include "catalogsdebug.h"
#include "catalogsbigdes.h"
#include "ncdrequestgenerator.h"
#include "catalogsaccesspointmanager.h"
#include "ncdrequestbase.h"
#include "ncdrequestbrowsesearch.h"
#include "ncdrequestconfiguration.h"
#include "ncd_pp_itemref.h"
#include "ncd_pp_folderref.h"
#include "ncd_pp_dataentity.h"
#include "ncd_pp_error.h"
// remove these
#include "ncd_pp_itemrefimpl.h"
#include "ncd_pp_folderrefimpl.h"
#include "ncd_pp_dataentityimpl.h"
#include "ncd_pp_datablock.h"
//
#include "ncdprotocolutils.h"
#include "ncdprotocol.h"
#include "ncdprotocolimpl.h"
#include "ncdparser.h"
#include "ncdnodemanager.h"
#include "ncdproviderdefines.h"
#include "ncdnodeidentifier.h"
#include "ncdnodeclassids.h"
#include "ncdnodefolder.h"
#include "ncdoperationobserver.h"
#include "catalogssession.h"
#include "ncdnodeimpl.h"
#include "ncdnodelink.h"
#include "ncdqueryimpl.h"
#include "catalogsutils.h"
#include "ncd_cp_query.h"
#include "ncdnodemetadata.h"
#include "ncdnodemetadataimpl.h"
#include "ncderrors.h"
#include "ncdoperationremovehandler.h"
#include "ncdstoragedescriptordataitem.h"
#include "ncdnodeiconimpl.h"
#include "ncdnodelink.h"
#include "catalogsconstants.h"
#include "ncdnodeclassids.h"
#include "ncdnodecontentinfoimpl.h"
#include "ncditempurpose.h"
#include "ncdutils.h"
#include "ncdsearchnodefolder.h"
#include "ncdnodeclassids.h"
#include "ncdnodefactory.h"
#include "ncdnodeidentifiereditor.h"
#include "ncdsearchnodefolder.h"
#include "ncdcapabilities.h"
#include "ncdsearchnodebundle.h"
#include "ncdchildentity.h"
//_LIT8(KRequestBody, "<?xml version=\"1.0\" encoding=\"UTF-8\"?> <preminetRequest xmlns=\"http://nokia.com/preminet/protocol/v/2/0\" xmlns:cp=\"http://nokia.com/preminet/protocol/configuration/v/1/0\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" version=\"2.0\" namespace=\"http://lynx.ionific.com:9086/ntp-cgw/catalogs\"> <configuration> <client> <cp:software version=\"3.2\" type=\"S60\"/> </client> </configuration> <search> <entity xsi:type=\"Folder\" id=\"cgw_normal\" timestamp=\"2007-12-17T09:30:47.0Z\"/> <entityFilter subscribableContent=\"false\"> <keywords all=\"true\" caseSensitive=\"false\"> <keyword exclude=\"false\">a</keyword> </keywords> <reviewScore>1</reviewScore> </entityFilter> <responseFilter structureDepth=\"2\" metadataDepth=\"2\" metadataPerLevel=\"5\" pageStart=\"2\" pageSize=\"2\"/> </search> </preminetRequest>");
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CNcdSearchOperation* CNcdSearchOperation::NewL(
const CNcdNodeIdentifier& aNodeIdentifier,
const CNcdNodeIdentifier& aParentIdentifier,
const CNcdSearchFilter& aSearchFilter,
TNcdResponseFilterParams aFilterParams,
CNcdGeneralManager& aGeneralManager,
MCatalogsHttpSession& aHttpSession,
MNcdOperationRemoveHandler* aRemoveHandler,
MNcdOperationQueue* aOperationQueue,
MCatalogsSession& aSession,
TBool aLoadChildren,
TNcdChildLoadMode aMode,
TInt aRecursionLevels,
TBool aIsSubOperation )
{
CNcdSearchOperation* self = CNcdSearchOperation::NewLC(
aNodeIdentifier,
aParentIdentifier,
aSearchFilter,
aFilterParams,
aGeneralManager,
aHttpSession,
aRemoveHandler,
aOperationQueue,
aSession,
aLoadChildren,
aMode,
aRecursionLevels,
aIsSubOperation );
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CNcdSearchOperation* CNcdSearchOperation::NewLC(
const CNcdNodeIdentifier& aNodeIdentifier,
const CNcdNodeIdentifier& aParentIdentifier,
const CNcdSearchFilter& aSearchFilter,
TNcdResponseFilterParams aFilterParams,
CNcdGeneralManager& aGeneralManager,
MCatalogsHttpSession& aHttpSession,
MNcdOperationRemoveHandler* aRemoveHandler,
MNcdOperationQueue* aOperationQueue,
MCatalogsSession& aSession,
TBool aLoadChildren,
TNcdChildLoadMode aMode,
TInt aRecursionLevels,
TBool aIsSubOperation )
{
CNcdSearchOperation* self =
new( ELeave ) CNcdSearchOperation( aFilterParams, aMode,
aLoadChildren, aGeneralManager, aHttpSession,
aRemoveHandler, aOperationQueue, aSession, aRecursionLevels,
aIsSubOperation );
CleanupClosePushL( *self );
self->ConstructL( aNodeIdentifier, aParentIdentifier, aSearchFilter );
return self;
}
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CNcdSearchOperation::~CNcdSearchOperation()
{
DLTRACEIN((""));
delete iSearchFilter;
iRemoteFoldersChildOfTransparent.ResetAndDestroy();
}
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void CNcdSearchOperation::FolderRefL(
MNcdPreminetProtocolFolderRef* aData )
{
DLTRACEIN(("%X",aData));
if ( aData == NULL )
{
return;
}
TRAPD( err, DoFolderRefL( aData ) );
if( err != KErrNone )
{
Cancel();
iError = err;
iLoadNodeState = EFailed;
}
RunOperation();
}
void CNcdSearchOperation::DoFolderRefL( MNcdPreminetProtocolFolderRef* aData )
{
DLTRACEIN((""));
// Normal PushL causes USER 42
CleanupDeletePushL( aData );
DLTRACE(( _L("folder id=%S, ns=%S"),
&aData->Id(), &aData->Namespace() ));
DLTRACE(( _L("Parent id=%S, ns=%S"),
&aData->ParentId(), &aData->ParentNamespace() ));
#ifdef CATALOGS_BUILD_CONFIG_DEBUG
if ( iParentIdentifier )
{
DLNODEID( (*iParentIdentifier) );
}
#endif
TBool nodeAdded = EFalse;
// This will contain pointer to the iNodeIdentifier or to the iParentIdentifier
// So, we will know in the end which one is the parent of the current data item.
// Do not delete this in the end because this just points to the member
// variables.
CNcdNodeIdentifier* tmpSearchParentIdentifier( iParentIdentifier );
CNcdNodeIdentifier* metaIdentifier =
NcdNodeIdentifierEditor::CreateMetaDataIdentifierLC( *iNodeIdentifier );
switch ( iLoadMode )
{
case EContentSource:
{
DLTRACE(("Should never come here, ERROR"));
DASSERT(0);
User::Leave( KErrGeneral );
break;
}
case ESingleNode:
{
DASSERT( iNodeIdentifier );
DLINFO(( _L("iNodeIdentifier: ns= %S, id= %S, aData: ns= %S, id= %S"),
&iNodeIdentifier->NodeNameSpace(), &iNodeIdentifier->NodeId(),
&aData->Namespace(), &aData->Id() ));
// Because aData contains metadata ids, we have to get
// the metadata id from the iNodeIdentifier
if ( aData->Id() == metaIdentifier->NodeId() &&
aData->Namespace() == metaIdentifier->NodeNameSpace() )
{
DLTRACE(("ESingleNode"));
// Because the data id is same as the meta id, we know
// that this can not be the root search. Root search namespace
// and id are defined locally here in the client, not in the
// web server.
CNcdNodeManager::TNcdRefHandleMode mode;
if( CNcdNodeFactory::NodePurposeL(
iNodeManager->NodeL( *iNodeIdentifier ) ) ==
CNcdNodeFactory::ENcdSearchNode )
{
mode = CNcdNodeManager::EUpdate;
}
else
{
mode = CNcdNodeManager::EInsert;
}
iNodeManager->RefHandlerL( *iParentIdentifier,
*aData,
iClientUid,
mode,
0,
iParentType,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
nodeAdded = ETrue;
}
else if( aData->ParentId() == metaIdentifier->NodeId() &&
aData->ParentNamespace() == metaIdentifier->NodeNameSpace() )
{
DLINFO(("ESingleNode, adding children"));
// A child of the node that we are loading is received
CNcdNode& node =
iNodeManager->RefHandlerL( *iNodeIdentifier,
*aData,
iClientUid,
CNcdNodeManager::EInsert, // use insertion because child count is not known yet
iNodeIndex++,
CNcdNodeFactory::ENcdNodeFolder,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
// Before saving the node information make sure that the node remote info is
// set correctly. Because nodeAdded will be set true below the node will be
// saved in the end of this function.
if ( aData->RemoteUri() != KNullDesC )
{
DLINFO((_L("Remote search node: %S"), &node.Identifier().NodeId()));
node.NodeLinkL().SetRemoteFlag( ETrue );
if ( iNodeManager->SearchFolderL( *iNodeIdentifier ).IsTransparent() )
{
DLINFO(("Parent is transparent folder, add child to remote folder array"));
iRemoteFoldersChildOfTransparent.AppendL( CNcdNodeIdentifier::NewLC( node.Identifier() ) );
CleanupStack::Pop(); // the nodeidentifier
}
else if ( iRecursionLeft )
{
// Sub operations should not go any further in recursion
DLINFO(("Recursion left"));
iRemoteFolders.AppendL( CNcdNodeIdentifier::NewLC( node.Identifier() ) );
CleanupStack::Pop(); // the nodeidentifier
}
}
else
{
DLINFO((_L("Normal search node: %S"), &node.Identifier().NodeId()));
node.NodeLinkL().SetRemoteFlag( EFalse );
}
// The parent is not the node identified by the iParentIdentifier
tmpSearchParentIdentifier = iNodeIdentifier;
nodeAdded = ETrue;
}
break;
}
case EChildren:
{
DLTRACE(("EChildren"));
DASSERT( iNodeIdentifier );
// Get the parent node. So, we can use its link to get the metadataidentifier.
// The parent always has the link information set here.
CNcdNode& currentNode = iNodeManager->NodeL( *iNodeIdentifier );
DLNODEID( currentNode.NodeLinkL().MetaDataIdentifier() );
if ( aData->Id() == currentNode.NodeLinkL().MetaDataIdentifier().NodeId() &&
aData->Namespace() == currentNode.NodeLinkL().MetaDataIdentifier().NodeNameSpace() )
{
DLINFO(("EChildren Add parent"));
// Get the actual parent for this operation. This is required to check
// if the parent is root or some other kind of folder.
CNcdNode& addParent = iNodeManager->NodeL( *iParentIdentifier );
// add parent
iNodeManager->RefHandlerL( *iParentIdentifier,
*aData,
iClientUid,
CNcdNodeManager::EUpdate,
0, // Should give no index in this case
CNcdNodeFactory::NodeTypeL( addParent ),
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
nodeAdded = ETrue;
// Structure loaded for parent -> send update notification
// for parent node so that it gets internalized.
CNcdNodeIdentifier* loadedNodeId =
CNcdNodeIdentifier::NewLC( currentNode.Identifier() );
iLoadedNodes.AppendL( loadedNodeId );
CleanupStack::Pop( loadedNodeId );
}
else if ( aData->ParentId() == metaIdentifier->NodeId() ||
aData->ParentNamespace() == metaIdentifier->NodeNameSpace() )
{
DLINFO(("EChildren"));
// add child
// We are loading the children of the current node that is
// identified by the iNodeIdentifier.
CNcdNode& node =
iNodeManager->RefHandlerL( *iNodeIdentifier,
*aData,
iClientUid,
CNcdNodeManager::EReplace,
iNodeIndex++,
CNcdNodeFactory::ENcdNodeFolder,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
// Before saving the node information make sure that the node remote info is
// set correctly. Because nodeAdded will be set true below the node will be
// saved in the end of this function.
if ( aData->RemoteUri() != KNullDesC )
{
DLINFO((_L("Remote search node: %S"), &node.Identifier().NodeId()));
node.NodeLinkL().SetRemoteFlag( ETrue );
CNcdNodeIdentifier* identifier = CNcdNodeIdentifier::NewLC( node.Identifier() );
iRemoteFolders.AppendL( identifier );
CleanupStack::Pop( identifier );
}
else
{
DLINFO((_L("Normal search node: %S"), &node.Identifier().NodeId()));
node.NodeLinkL().SetRemoteFlag( EFalse );
}
// The parent is not the node identified by the iParentIdentifier
tmpSearchParentIdentifier = iNodeIdentifier;
nodeAdded = ETrue;
}
break;
}
}
CleanupStack::PopAndDestroy( metaIdentifier );
// add search filter to folder, this is needed so that consecutive
// search ops (started while paging results) can get the filter
if ( nodeAdded )
{
CNcdNodeIdentifier* searchMetaIdentifier =
CNcdNodeIdentifier::NewLC( aData->Namespace(),
aData->Id(),
aData->ServerUri(),
iClientUid );
CNcdSearchNodeFolder& searchFolder = iNodeManager->SearchFolderL(
*tmpSearchParentIdentifier,
*searchMetaIdentifier );
searchFolder.SetSearchFilterL( *iSearchFilter );
if( iLoadMode == ESingleNode && CNcdNodeFactory::NodePurposeL(
iNodeManager->NodeL( *iNodeIdentifier ) ) !=
CNcdNodeFactory::ENcdSearchNode )
{
// search op started for a normal node, add origin identifier
searchFolder.SetOriginIdentifierL( *iNodeIdentifier );
}
iNodeManager->DbSaveNodeL( searchFolder );
CleanupStack::PopAndDestroy( searchMetaIdentifier );
}
// Delete data because ownership has been transferred.
CleanupStack::PopAndDestroy( aData );
DLTRACEOUT((""));
}
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void CNcdSearchOperation::FolderDataL(
MNcdPreminetProtocolDataEntity* aData )
{
DLTRACEIN((""));
if ( aData != NULL )
{
TInt err( KErrNone );
TRAP( err,
// Normal PushL causes USER 42
CleanupDeletePushL( aData );
// This node will contain the metadata that is updated by calling
// the handler function.
// Notice that after this the metadata has also been created.
// So, metadata can be directly used.
CNcdNodeIdentifier* parentIdentifier( NULL );
TBool addMetaData = ETrue;
if( iLoadMode == EChildren || iLoadMode == ESingleNode )
{
DLINFO(("EChildren"));
DASSERT( iNodeIdentifier );
CNcdNodeIdentifier* metaIdentifier =
NcdNodeIdentifierEditor::CreateMetaDataIdentifierL( *iNodeIdentifier );
if ( aData->Id() != metaIdentifier->NodeId() ||
aData->Namespace() != metaIdentifier->NodeNameSpace() )
{
// aData must be child of iNodeIdentifier
parentIdentifier = CNcdNodeIdentifier::NewLC( *iNodeIdentifier );
}
delete metaIdentifier;
metaIdentifier = NULL;
}
if( addMetaData )
{
// set iParentIdentifier as parent if not set otherwise, this would be the case of a
// normal top-level node from a content source
if ( ! parentIdentifier )
{
parentIdentifier = CNcdNodeIdentifier::NewLC( *iParentIdentifier );
}
CNcdNode& node =
iNodeManager->DataHandlerL( *parentIdentifier, *aData, iClientUid );
CleanupStack::PopAndDestroy( parentIdentifier );
// Notice that the loaded nodes should contain the actual node identifier
// instead of metadata identifier, because the identifiers are returned to
// the proxy side after operation completes.
CNcdNodeIdentifier* loadedNodeId =
CNcdNodeIdentifier::NewLC( node.Identifier() );
iLoadedNodes.AppendL( loadedNodeId );
CleanupStack::Pop( loadedNodeId );
DLINFO(("node loaded, id: %S", &node.Identifier().NodeId() ));
// If the data contains icon id and datablock id, they are stored until
// the datablock arrives later (in DataBlocksL method).
const MNcdPreminetProtocolIcon* icon = aData->Icon();
if ( icon != NULL )
{
const TDesC& iconId = icon->Id();
const TDesC& dataBlockId = icon->DataBlock();
if ( iconId != KNullDesC && dataBlockId != KNullDesC )
{
// Icon id may be mapped to the metadata id here
MapIconIdForDataBlockL( iconId, dataBlockId,
node.NodeMetaDataL().Identifier() );
// Notice that here we need to get the node by using the
// parent identifier and metadata id, because the metadata
// identifier itself is not enough to identify the node.
node.NodeMetaDataL().IconL().SetIconDataReady( EFalse );
}
}
}
else if ( parentIdentifier )
{
CleanupStack::PopAndDestroy( parentIdentifier );
}
// Delete data because ownership has been transferred.
CleanupStack::PopAndDestroy( aData );
); //TRAPD
if( err != KErrNone )
{
iError = err;
iLoadNodeState = EFailed;
}
}
RunOperation();
DLTRACEOUT((""));
}
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void CNcdSearchOperation::ItemRefL( MNcdPreminetProtocolItemRef* aData )
{
DLTRACEIN((""));
// Item references are handled only when children are loaded or if the
// search mode is not ENormal
//
// If all item refs were handled recursive searching would be veeery
// slow and we might run out of memory due to very high number of
// nodes (800 and more)
if ( ( iSearchFilter->SearchMode() == MNcdSearchFilter::ENormal &&
iLoadMode != EChildren &&
!iNodeManager->SearchFolderL( *iNodeIdentifier ).IsTransparent() ) ||
!aData )
{
delete aData;
DLTRACEOUT(("Not loading children or no data"));
return;
}
TRAPD( err, DoItemRefL( aData ) );
// Delete data because ownership has been transferred.
delete aData;
aData = NULL;
if( err != KErrNone )
{
DLERROR(("Error: %d", err));
iError = err;
iLoadNodeState = EFailed;
}
RunOperation();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CNcdSearchOperation::DoItemRefL( MNcdPreminetProtocolItemRef* aData )
{
DLTRACEIN((""));
// Because aData contains metadata ids, we have to get
// the metadata id from the iNodeIdentifier
CNcdNodeIdentifier* metaIdentifier =
NcdNodeIdentifierEditor::CreateMetaDataIdentifierLC( *iNodeIdentifier );
switch ( iLoadMode )
{
case EContentSource:
{
DLTRACE(("Should never come here, ERROR"));
DASSERT(0);
break;
}
case ESingleNode:
{
DLINFO(("Search single node"));
DASSERT( iNodeIdentifier );
if ( aData->Id() == metaIdentifier->NodeId() &&
aData->Namespace() == metaIdentifier->NodeNameSpace() )
{
iNodeManager->RefHandlerL( *iParentIdentifier,
*aData,
iClientUid,
CNcdNodeManager::EUpdate,
0,
iParentType,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
}
else if( aData->ParentId() == metaIdentifier->NodeId() &&
aData->ParentNamespace() == metaIdentifier->NodeNameSpace() )
{
// add child
iNodeManager->RefHandlerL( *iNodeIdentifier,
*aData,
iClientUid,
CNcdNodeManager::EInsert, // use insertion because child count is not known yet
iNodeIndex++,
CNcdNodeFactory::ENcdNodeFolder,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
}
break;
}
case EChildren:
{
DLINFO(("Search children"));
DASSERT( iNodeIdentifier );
// Get the parent node. So, we can use its link to get the metadataidentifier.
// The parent always has the link information set here.
CNcdNode& parentNode = iNodeManager->NodeL( *iNodeIdentifier );
if ( aData->Id() == parentNode.NodeLinkL().MetaDataIdentifier().NodeId() &&
aData->Namespace() == parentNode.NodeLinkL().MetaDataIdentifier().NodeNameSpace() )
{
// add parent
iNodeManager->RefHandlerL( *iParentIdentifier,
*aData,
iClientUid,
CNcdNodeManager::EUpdate,
0,
iParentType,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
}
else if ( aData->ParentId() == metaIdentifier->NodeId() &&
aData->ParentNamespace() == metaIdentifier->NodeNameSpace() )
{
// add child
iNodeManager->RefHandlerL( *iNodeIdentifier,
*aData,
iClientUid,
CNcdNodeManager::EReplace,
iNodeIndex++,
CNcdNodeFactory::ENcdNodeFolder,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode );
}
break;
}
}
CleanupStack::PopAndDestroy( metaIdentifier );
DLTRACEOUT((""));
}
void CNcdSearchOperation::ItemDataL(
MNcdPreminetProtocolDataEntity* aData )
{
DLTRACEIN((""));
// Item metadata is handled only when children are loaded or if the
// search mode is not ENormal
//
// If all item refs were handled recursive searching would be veeery
// slow and we might run out of memory due to very high number of
// nodes (800 and more)
if ( ( iSearchFilter->SearchMode() == MNcdSearchFilter::ENormal &&
iLoadMode != EChildren &&
!iNodeManager->SearchFolderL( *iNodeIdentifier ).IsTransparent() ) ||
!aData )
{
delete aData;
DLTRACEOUT(("Not loading children or no data"));
return;
}
TRAPD( err, DoItemDataL( aData ) );
// Delete data because ownership has been transferred.
delete aData;
aData = NULL;
if( err != KErrNone )
{
DLERROR(("Error: %d", err));
iError = err;
iLoadNodeState = EFailed;
}
RunOperation();
}
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void CNcdSearchOperation::DoItemDataL(
MNcdPreminetProtocolDataEntity* aData )
{
DLTRACEIN((""));
TBool addMetaData = ETrue;
CNcdNodeIdentifier* parentIdentifier( NULL );
if( iLoadMode == EChildren || iLoadMode == ESingleNode )
{
DLINFO(("EChildren or ESingleNode"));
DASSERT( iNodeIdentifier );
CNcdNodeIdentifier* metaIdentifier =
NcdNodeIdentifierEditor::CreateMetaDataIdentifierL( *iNodeIdentifier );
if ( aData->Id() != metaIdentifier->NodeId() ||
aData->Namespace() != metaIdentifier->NodeNameSpace() )
{
// aData must be child of iNodeIdentifier
parentIdentifier = CNcdNodeIdentifier::NewLC( *iNodeIdentifier );
}
delete metaIdentifier;
metaIdentifier = NULL;
}
// set iParentIdentifier as parent if not set otherwise, this would be the case of a
// normal top-level node from a content source
if ( ! parentIdentifier )
{
parentIdentifier = CNcdNodeIdentifier::NewLC( *iParentIdentifier );
}
// Get the node reference from the data handler.
// The node has the given parent and its metadata
// will be internalized with the given data.
CNcdNode& node =
iNodeManager->DataHandlerL( *parentIdentifier, *aData, iClientUid );
CleanupStack::PopAndDestroy( parentIdentifier );
// Notice that the loaded nodes should contain the actual node identifier
// instead of metadata identifier, because the identifiers are returned to
// the proxy side after operation completes.
CNcdNodeIdentifier* loadedNodeId =
CNcdNodeIdentifier::NewLC( node.Identifier() );
iLoadedNodes.AppendL( loadedNodeId );
CleanupStack::Pop( loadedNodeId );
// If the data contains icon id and datablock id, they are stored until
// the datablock arrives later.
const MNcdPreminetProtocolIcon* icon = aData->Icon();
if ( icon != NULL )
{
const TDesC& iconId = icon->Id();
const TDesC& dataBlockId = icon->DataBlock();
if ( iconId != KNullDesC && dataBlockId != KNullDesC )
{
// The node metadata was created by using the DataHandlerL
// and inserted for the node.
// So, the metadata can be asked from the node now.
MapIconIdForDataBlockL(iconId, dataBlockId,
node.NodeMetaDataL().Identifier() );
node.NodeMetaDataL().IconL().SetIconDataReady( EFalse );
}
}
DLTRACEOUT((""));
}
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CNcdSearchOperation::CNcdSearchOperation(
TNcdResponseFilterParams aFilterParams,
TNcdChildLoadMode aMode,
TBool aLoadChildren,
CNcdGeneralManager& aGeneralManager,
MCatalogsHttpSession& aHttpSession,
MNcdOperationRemoveHandler* aRemoveHandler,
MNcdOperationQueue* aOperationQueue,
MCatalogsSession& aSession,
TInt aRecursionLevels,
TBool aIsSubOperation )
: CNcdLoadNodeOperationImpl( CNcdNodeFactory::ENcdSearchNode,
aFilterParams, aMode, aLoadChildren,
aGeneralManager, aHttpSession,
aRemoveHandler, aOperationQueue, aSession, aIsSubOperation, ETrue ),
iParentType( CNcdNodeFactory::ENcdNodeFolder ),
iRecursionLeft( aRecursionLevels )
{
iOperationType = ESearchOperation;
}
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CNcdSearchOperation::ConstructL(
const CNcdNodeIdentifier& aNodeIdentifier,
const CNcdNodeIdentifier& aParentIdentifier,
const CNcdSearchFilter& aFilter )
{
DLTRACEIN((""));
CNcdLoadNodeOperationImpl::ConstructL( aNodeIdentifier,
aParentIdentifier );
iSearchFilter = CNcdSearchFilter::NewL( aFilter );
DetermineParentTypeL( aNodeIdentifier.ClientUid() );
CNcdNode& node = iNodeManager->NodeL( *iNodeIdentifier );
if( node.ClassId() == NcdNodeClassIds::ENcdBundleFolderNodeClassId )
{
// Search op started for a bundle.
// Search op started from a non-search node (i.e. starting a new search via search api).
// Create a search folder skeleton and replace iNodeIdentifier with the
// resulting search folder's identifier. This makes stuff easier elsewhere in the op.
CNcdNodeIdentifier* originalIdentifier = iNodeIdentifier;
CNcdNode& searchNode = CreateSearchBundleSkeletonL();
iNodeIdentifier = CNcdNodeIdentifier::NewL( searchNode.Identifier() );
delete originalIdentifier;
}
else if ( CNcdNodeFactory::NodePurposeL( node.ClassId() ) !=
CNcdNodeFactory::ENcdSearchNode )
{
// Search op started from a non-search node (i.e. starting a new search via search api).
// Create a search folder skeleton and replace iNodeIdentifier with the
// resulting search folder's identifier. This makes stuff easier elsewhere in the op.
CNcdNodeIdentifier* originalIdentifier = iNodeIdentifier;
CNcdNode& searchNode = CreateSearchFolderSkeletonL();
iNodeIdentifier = CNcdNodeIdentifier::NewL( searchNode.Identifier() );
delete originalIdentifier;
}
DLTRACEOUT((""));
}
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
HBufC8* CNcdSearchOperation::CreateRequestLC(
CNcdNodeIdentifier* aNodeIdentifier,
TNcdResponseFilterParams aFilterParams,
const TDesC& aUri )
{
//DLTRACEIN(("pagesize=%d, pagestart=%d, depth=%d",aPageSize,aPageStart,aDepth));
DLTRACEIN((""));
CNcdRequestBrowseSearch* req =
NcdRequestGenerator::CreateSearchRequestLC();
// create textual representations for content purposes
CDesC16ArrayFlat* contentPurposes = new ( ELeave ) CDesC16ArrayFlat(
KListGranularity );
CleanupStack::PushL( contentPurposes );
TUint purposes = iSearchFilter->ContentPurposes();
if ( purposes & ENcdItemPurposeMusic )
{
contentPurposes->AppendL( KNcdContentPurposeMusic );
}
if ( purposes & ENcdItemPurposeRingtone )
{
contentPurposes->AppendL( KNcdContentPurposeRingtone );
}
if ( purposes & ENcdItemPurposeWallpaper )
{
contentPurposes->AppendL( KNcdContentPurposeWallpaper );
}
if ( purposes & ENcdItemPurposeVideo )
{
contentPurposes->AppendL( KNcdContentPurposeVideo );
}
if ( purposes & ENcdItemPurposeTheme )
{
contentPurposes->AppendL( KNcdContentPurposeTheme );
}
if ( purposes & ENcdItemPurposeApplication )
{
contentPurposes->AppendL( KNcdContentPurposeApplication );
}
if ( purposes & ENcdItemPurposeHtmlPage )
{
contentPurposes->AppendL( KNcdContentPurposeHtmlPage );
}
if ( purposes & ENcdItemPurposeGame )
{
contentPurposes->AppendL( KNcdContentPurposeGame );
}
if ( purposes & ENcdItemPurposeScreensaver )
{
contentPurposes->AppendL( KNcdContentPurposeScreensaver );
}
if ( purposes & ENcdItemPurposeStream )
{
contentPurposes->AppendL( KNcdContentPurposeStream );
}
// The parameter is the actual search node identifier. So, it can be used
// to get the node from the manager.
DLINFO((_L("Search node ns: %S, Id: %S"),
&aNodeIdentifier->NodeNameSpace(),
&aNodeIdentifier->NodeId()));
CNcdNode& node = iNodeManager->NodeL( *aNodeIdentifier );
req->SetNamespaceL( aNodeIdentifier->NodeNameSpace() );
CDesC16ArrayFlat* elements = new (ELeave) CDesC16ArrayFlat(1);
CleanupStack::PushL( elements );
switch ( iLoadMode )
{
case ESingleNode:
{
DLTRACE(("ESingleNode"))
DASSERT( aNodeIdentifier );
DASSERT( node.ClassId() != NcdNodeClassIds::ENcdItemNodeClassId );
if ( node.ClassId() == NcdNodeClassIds::ENcdSearchItemNodeClassId )
{
// search op started for item, can't do a search
req->SetSearch( EFalse );
}
else if ( node.ClassId() == NcdNodeClassIds::ENcdSearchBundleNodeClassId )
{
DLTRACE(("Searching from bundle, load children as sub-operations"));
CNcdSearchNodeFolder& folder = iNodeManager->SearchFolderL( node.Identifier() );
const RPointerArray<CNcdChildEntity>& children = folder.ChildArray();
for ( TInt i = 0 ; i < children.Count() ; i++ )
{
CNcdNode& childNode = iNodeManager->NodeL( children[i]->Identifier() );
// remote folders are loaded separately
CNcdNodeIdentifier* remoteFolderId =
CNcdNodeIdentifier::NewLC(
childNode.Identifier() );
iRemoteFolders.AppendL( remoteFolderId );
CleanupStack::Pop( remoteFolderId );
}
DLTRACE(("Only search bundle children to load"));
User::Leave( KNcdLoadNodeErrRemoteOnly );
}
else
{
// search op started for folder, add search filter
req->AddEntityFilterL( iSearchFilter->Keywords(),
*contentPurposes,
ETrue,
ETrue);
}
req->AddEntityL(
node.NodeLinkL().MetaDataIdentifier().NodeId(),
node.NodeLinkL().Timestamp(),
ETrue );
// Use response filter only for non-transparent folders
if( node.ClassId() == NcdNodeClassIds::ENcdSearchFolderNodeClassId &&
!iNodeManager->SearchFolderL( node.Identifier() ).IsTransparent() )
{
// If not using recursion or we are on the last level of recursion
// we don't need to load the children. This ensures that
// with 0 recursion depth search works just like in 3.1.50
TInt childCount = INT_MAX; // load all the children
if ( !iRecursionLeft )
{
childCount = 1; // load just one child
}
req->AddResponseFilterL(
childCount,
0, // pageStart: load from the first child
1, // structureDepth: load child structure
0, // metaDataDepth: don't load child metadata
1, // metaDataPerLevel: only load one metadata per level
*elements,
*elements );
}
DLTRACE(("ESingleNode done"))
break;
}
case EChildren:
{
DLTRACE(("EChildren"));
// load children can only be done for folders
DASSERT( node.ClassId() == NcdNodeClassIds::ENcdSearchFolderNodeClassId ||
node.ClassId() == NcdNodeClassIds::ENcdFolderNodeClassId ||
node.ClassId() == NcdNodeClassIds::ENcdSearchBundleNodeClassId );
// add search filter
req->AddEntityFilterL( iSearchFilter->Keywords(),
*contentPurposes,
ETrue,
ETrue);
req->AddEntityL(
node.NodeLinkL().MetaDataIdentifier().NodeId(),
node.NodeLinkL().Timestamp(),
EFalse ); // Don't load parent metadata.
// loading children, use filter params
switch ( iChildLoadMode )
{
case ELoadStructure:
{
DLTRACE(("ELoadStructure"));
// Calculate correct pagesize.
TInt pageSize = CalculateStructPageSize(aFilterParams.iPageStart,
aFilterParams.iPageSize,
iNodeManager->FolderL( node.Identifier() ),
iChildLoadMode );
// Add response filter to get only the desired amount of children.
req->AddResponseFilterL(
pageSize,
aFilterParams.iPageStart,
1, // structureDepth: load child structure
0, // metaDataDepth: don't load child metadata
0, // metaDataPerLevel: don't load child metadata
*elements,
*elements );
break;
}
case ELoadMetadata:
{
DLTRACE(("ELoadMetadata"));
// search op should never load metadata for non-search folders
// as in this case no search is conducted
DASSERT( node.ClassId() ==
NcdNodeClassIds::ENcdSearchFolderNodeClassId ||
node.ClassId() == NcdNodeClassIds::ENcdSearchBundleNodeClassId);
CNcdNodeFolder& folder = iNodeManager->FolderL( *aNodeIdentifier );
// Special handling for bundle folders.
if ( folder.ClassId() == NcdNodeClassIds::ENcdSearchBundleNodeClassId )
{
DLTRACE(("Search bundle -> load children in sub ops."));
for ( TInt i = aFilterParams.iPageStart ;
i < aFilterParams.iPageStart + aFilterParams.iPageSize ;
i++ )
{
CNcdNode& childNode = iNodeManager->NodeL( folder.ChildL( i ) );
if ( !childNode.NodeMetaData() || childNode.NodeLinkL().IsExpired() )
{
// load node only if it has no metadata or if it's expired
CNcdNodeIdentifier* remoteFolderId =
CNcdNodeIdentifier::NewLC( childNode.Identifier() );
// Remote folderlist contains actual node ids.
iRemoteFolders.AppendL( remoteFolderId );
CleanupStack::Pop( remoteFolderId );
}
}
if( iRemoteFolders.Count() > 0 )
{
DLTRACE(("Only remote folders to load"));
User::Leave( KNcdLoadNodeErrRemoteOnly );
}
else
{
DLTRACE(("Nothing to do -> complete operation"));
User::Leave( KNcdLoadNodeErrNothingToDo );
}
}
else
{
DLTRACE(("Normal search folder"));
// Calculate correct pagesize.
TInt pageSize = CalculateStructPageSize(aFilterParams.iPageStart,
aFilterParams.iPageSize,
folder,
iChildLoadMode );
// Add response filter to get only the desired amount of children.
req->AddResponseFilterL(
pageSize, // pageSize:
aFilterParams.iPageStart, // pageStart: not applicable in this case as pageSize is 0
1, // structureDepth: load child structure
1, // metaDataDepth: load child metadata
aFilterParams.iPageSize,// metaDataPerLevel: load metadata only for the requested page
*elements,
*elements );
}
DLTRACE(("ELoadMetadata done"));
break;
}
}
DLTRACE(("EChildren done"));
break;
}
case EContentSource:
default:
{
// this should never happen
DASSERT( 0 );
break;
}
}
CleanupStack::PopAndDestroy( elements );
CleanupStack::PopAndDestroy( contentPurposes );
AddQueryResponsesL( req );
HBufC8* data = NULL;
data = iProtocol.ProcessPreminetRequestL(
iSession.Context(), *req, aUri );
CleanupStack::PopAndDestroy( req );
CleanupStack::PushL( data );
return data;
}
void CNcdSearchOperation::CreateSubOperationsL()
{
DLTRACEIN(("remote folder count: %d", iRemoteFolders.Count()));
for ( TInt i = 0 ; i < iRemoteFolders.Count() ; i++ )
{
CNcdNode& remoteFolder = iNodeManager->NodeL( *iRemoteFolders[i] );
CNcdSearchOperation* loadOp =
CNcdSearchOperation::NewLC(
*iRemoteFolders[i],
remoteFolder.NodeLinkL().ParentIdentifier(),
*iSearchFilter,
TNcdResponseFilterParams(),
iGeneralManager,
iHttpSession,
iRemoveHandler,
iOperationQueue,
iSession,
EFalse, // Results in ESingleNode load mode.
ELoadStructure, // Not used in ESingleNode mode.
iRecursionLeft - 1,
ETrue );
loadOp->AddObserverL( this );
User::LeaveIfError( loadOp->Start() );
iSubOps.AppendL( loadOp );
CleanupStack::Pop( loadOp );
}
DLINFO(("Child of transparent count: %d", iRemoteFoldersChildOfTransparent.Count() ));
// Create load operations for children of transparent folders.
for ( TInt i = 0 ; i < iRemoteFoldersChildOfTransparent.Count() ; i++ )
{
CNcdNode& remoteFolder = iNodeManager->NodeL( *iRemoteFoldersChildOfTransparent[i] );
CNcdSearchOperation* loadOp =
CNcdSearchOperation::NewLC(
*iRemoteFoldersChildOfTransparent[i],
remoteFolder.NodeLinkL().ParentIdentifier(),
*iSearchFilter,
TNcdResponseFilterParams(),
iGeneralManager,
iHttpSession,
iRemoveHandler,
iOperationQueue,
iSession,
EFalse, // Results in ESingleNode load mode.
ELoadStructure, // Not used in ESingleNode mode.
iRecursionLeft, // Don't decrease the recursion level for child of transparent
ETrue );
loadOp->AddObserverL( this );
User::LeaveIfError( loadOp->Start() );
iSubOps.AppendL( loadOp );
CleanupStack::Pop( loadOp );
}
}
TBool CNcdSearchOperation::IsLoadingNecessaryL()
{
DLTRACEIN((""));
DASSERT( iNodeIdentifier );
CNcdNode& node = iNodeManager->NodeL( *iNodeIdentifier );
if ( node.ClassId() == NcdNodeClassIds::ENcdSearchRootNodeClassId )
{
DLTRACE(("Search root -> don't load"));
return EFalse;
}
else if ( iLoadMode == EChildren && iChildLoadMode == ELoadMetadata &&
node.ClassId() != NcdNodeClassIds::ENcdSearchBundleNodeClassId )
{
DLTRACE(("ELoadMetadata for normal folder -> load"));
return ETrue;
}
else if( iLoadMode == ESingleNode && node.ClassId() == NcdNodeClassIds::ENcdSearchBundleNodeClassId )
{
DLTRACE(("Search bundle and ESingleNode -> load"));
return ETrue;
}
else if( node.ClassId() == NcdNodeClassIds::ENcdSearchBundleNodeClassId ||
node.ClassId() == NcdNodeClassIds::ENcdBundleFolderNodeClassId )
{
DLTRACE(("Bundle or search bundle -> don't load"));
return EFalse;
}
else
{
DLTRACE(("load"));
return ETrue;
}
}
TBool CNcdSearchOperation::IsChildClearingNecessaryL()
{
DLTRACEIN((""));
CNcdNode& node = iNodeManager->NodeL( *iNodeIdentifier );
return node.ClassId() == NcdNodeClassIds::ENcdSearchFolderNodeClassId &&
iLoadMode == ESingleNode;
}
void CNcdSearchOperation::DetermineParentTypeL( const TUid& aUid )
{
DLTRACEIN((""));
CNcdNodeIdentifier* searchRoot =
NcdNodeIdentifierEditor::CreateSearchRootIdentifierForClientLC( aUid );
DASSERT( iNodeIdentifier );
DASSERT( iParentIdentifier );
// don't do parent type check for search root as it has no parent
if ( !searchRoot->Equals( *iNodeIdentifier ) )
{
iParentType = CNcdNodeFactory::NodeTypeL(
iNodeManager->NodeL( *iParentIdentifier ) );
}
CleanupStack::PopAndDestroy( searchRoot );
}
CNcdNode& CNcdSearchOperation::CreateSearchBundleSkeletonL()
{
DLTRACEIN((""));
CNcdNodeFolder& bundle = iNodeManager->FolderL( *iNodeIdentifier );
CNcdNodeMetaData& bundleMeta = bundle.NodeMetaDataL();
CNcdSearchNodeBundle& searchBundle =
iNodeManager->CreateSearchBundleL( bundleMeta.Identifier(),
*iParentIdentifier );
// Create a link for the bundle
CNcdNodeLink& link = searchBundle.CreateAndSetLinkL();
// Also, notice that it is essential to insert the metadata identifier into the
// link info. So, the right metadata will be found when the bundle is opened
// from the database. For example when application has been started.
link.SetMetaDataIdentifierL( bundleMeta.Identifier() );
// Set the metadata to the search bundle because it was not set during creation.
searchBundle.SetNodeMetaDataL( bundleMeta );
searchBundle.SetSearchFilterL( *iSearchFilter );
// Set the search bundle as child of the parent node.
iNodeManager->AddToParentL( *iParentIdentifier, bundleMeta.Identifier(),
iParentType,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeManager::EInsert, 0 );
// Add child folders to search bundle
const RPointerArray<CNcdChildEntity>& children = bundle.ChildArray();
for( TInt i = 0 ; i < children.Count() ; i++ )
{
// bundle's children can only be folders
CNcdNodeFolder& bundleChild = iNodeManager->FolderL( children[i]->Identifier() );
// add only children with search capability
if( iNodeManager->IsCapabilitySupportedL( bundleChild.Identifier(),
NcdCapabilities::KSearch,
iSession.Context() ) )
{
// Bunlde child's metadata may be unavailable so just use the
// metadata identifier from link
//CNcdNodeMetaData& bundleChildMeta = bundleChild.NodeMetaDataL();
CNcdNodeLink& bundleChildLink = bundleChild.NodeLinkL();
CNcdSearchNodeFolder& searchBundleChild =
iNodeManager->CreateSearchFolderL( bundleChildLink.MetaDataIdentifier(),
searchBundle.Identifier() );
// Create a link for the child
CNcdNodeLink& childLink = searchBundleChild.CreateAndSetLinkL();
// Also, notice that it is essential to insert the metadata identifier into the
// link info. So, the right metadata will be found when the node is opened
// from the database. For example when application has been started.
childLink.SetMetaDataIdentifierL( bundleChildLink.MetaDataIdentifier() );
// copy server uri from original node
if( bundleChild.NodeLinkL().RemoteUri() != KNullDesC )
{
childLink.SetServerUriL( bundleChild.NodeLinkL().RemoteUri() );
}
else
{
childLink.SetServerUriL( bundleChild.NodeLinkL().ServerUri() );
}
// Set the metadata to the bundle folder because it was not set during creation.
//searchBundleChild.SetNodeMetaDataL( bundleChildMeta );
searchBundleChild.SetSearchFilterL( *iSearchFilter );
TBool transparent =
( bundleChild.ClassId() == NcdNodeClassIds::ENcdTransparentFolderNodeClassId );
searchBundleChild.SetTransparent( transparent );
// Set the folder as child of search bundle.
iNodeManager->AddToParentL( searchBundle.Identifier(), bundleChildLink.MetaDataIdentifier(),
CNcdNodeFactory::ENcdNodeSearchBundle,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode, //This parameter is unused
CNcdNodeManager::EAppend,
0,
transparent );
searchBundleChild.SetOriginIdentifierL( bundleChild.Identifier() );
iNodeManager->DbSaveNodeL( searchBundleChild );
}
}
iNodeManager->DbSaveNodeL( searchBundle );
return searchBundle;
}
CNcdNode& CNcdSearchOperation::CreateSearchFolderSkeletonL()
{
DLTRACEIN((""));
CNcdNodeFolder& folder = iNodeManager->FolderL( *iNodeIdentifier );
CNcdNodeMetaData& folderMeta = folder.NodeMetaDataL();
CNcdSearchNodeFolder& searchFolder =
iNodeManager->CreateSearchFolderL( folderMeta.Identifier(),
*iParentIdentifier );
// Create a link for the folder
CNcdNodeLink& link = searchFolder.CreateAndSetLinkL();
// Also, notice that it is essential to insert the metadata identifier into the
// link info. So, the right metadata will be found when the folder is opened
// from the database. For example when application has been started.
link.SetMetaDataIdentifierL( folderMeta.Identifier() );
// copy server uri from original node
if( folder.NodeLinkL().RemoteUri() != KNullDesC )
{
link.SetServerUriL( folder.NodeLinkL().RemoteUri() );
}
else
{
link.SetServerUriL( folder.NodeLinkL().ServerUri() );
}
// Set the metadata to the search bundle because it was not set during creation.
searchFolder.SetNodeMetaDataL( folderMeta );
searchFolder.SetSearchFilterL( *iSearchFilter );
TBool transparent =
( folder.ClassId() == NcdNodeClassIds::ENcdTransparentFolderNodeClassId );
// Set the search folder as child of the parent node.
iNodeManager->AddToParentL( *iParentIdentifier,
folderMeta.Identifier(),
iParentType,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeFactory::ENcdSearchNode,
CNcdNodeManager::EInsert,
0,
transparent );
searchFolder.SetOriginIdentifierL( *iNodeIdentifier );
// Because AddToParentL only saves the parent information after child is added to it
// we should always save the bundle node here. So, it will be usable after client is
// restarted.
iNodeManager->DbSaveNodeL( searchFolder );
return searchFolder;
}
void CNcdSearchOperation::ErrorL( MNcdPreminetProtocolError* aData )
{
DLTRACEIN((""));
switch ( aData->Code() )
{
case 404:
{
// Removed/missing nodes need no special handling in search op,
// so just fail the operation.
iError = KNcdErrorNodeWasRemoved;
iLoadNodeState = EFailed;
Cancel();
delete aData;
RunOperation();
break;
}
default:
{
CNcdLoadNodeOperationImpl::ErrorL( aData );
break;
}
}
}
TInt CNcdSearchOperation::RemoteFolderCount() const
{
DLTRACEIN((""));
return iRemoteFolders.Count() + iRemoteFoldersChildOfTransparent.Count();
}
void CNcdSearchOperation::RemoveChildrenL( CNcdNodeFolder& aFolder )
{
DLTRACEIN((""));
aFolder.RemoveChildren();
}