diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/server/inc/ncdloadrootnodeoperationimpl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/server/inc/ncdloadrootnodeoperationimpl.h Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,1042 @@ +/* +* 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: +* +*/ + + +#ifndef C_NCDLOADROOTNODEOPERATIONIMPL_H +#define C_NCDLOADROOTNODEOPERATIONIMPL_H + +#include + +#include "ncdbaseoperation.h" +#include "ncdoperationobserver.h" +#include "ncdparserobserver.h" +#include "catalogshttpobserver.h" +#include "catalogshttptypes.h" +#include "catalogshttpsession.h" +#include "catalogsutils.h" +#include "ncdnodeidentifier.h" +#include "ncdconfigurationobserver.h" +#include "ncdproviderdefines.h" + +class CDesC16Array; +class CDesC16ArrayFlat; +class CDesC8ArrayFlat; +class MNcdParser; +class CNcdNodeManager; +class MNcdProtocol; +class CNcdNodeIdentifier; +class CNcdLoadNodeOperationImpl; +class CCatalogsContext; +class MCatalogsAccessPointManager; +class MNcdConfigurationManager; +class MNcdOperationRemoveHandler; +class CNcdContentSourceMap; +class CNcdChildEntityMap; + +// ======== CONSTANTS ======== + + +class CNcdContentSource : public CBase + { +public: + + static CNcdContentSource* NewLC( const CNcdNodeIdentifier& aParentIdentifier ) + { + CNcdContentSource* self = + new( ELeave ) CNcdContentSource; + CleanupStack::PushL( self ); + self->ConstructL( aParentIdentifier ); + return self; + } + + static CNcdContentSource* NewL( RReadStream& aStream ) + { + CNcdContentSource* self = new ( ELeave ) CNcdContentSource; + CleanupStack::PushL( self ); + self->ConstructL( aStream ); + CleanupStack::Pop( self ); + return self; + } + + ~CNcdContentSource() + { + delete iParentIdentifier; + delete iNameSpace; + delete iProvider; + delete iUri; + delete iNodeId; + } + + const TDesC& NameSpace() const + { + return *iNameSpace; + } + void SetNameSpaceL( const TDesC& aNameSpace ) + { + AssignDesL( iNameSpace, aNameSpace ); + } + const TDesC& Provider() const + { + return *iProvider; + } + void SetProviderL( const TDesC& aProvider ) + { + AssignDesL( iProvider, aProvider ); + } + const TDesC& Uri() const + { + return *iUri; + } + void SetUriL( const TDesC& aUri ) + { + AssignDesL( iUri, aUri ); + } + /** + * Getter for node id. + * + * @return const TDesC + */ + const TDesC& NodeId() const + { + return *iNodeId; + } + void SetNodeIdL( const TDesC& aNodeId ) + { + AssignDesL( iNodeId, aNodeId ); + } + + void SetBroken( TBool aBroken ) + { + DLTRACEIN(("broken: %d", aBroken)); + iBroken = aBroken; + } + + TBool IsBroken() const + { + DLTRACEIN(("broken: %d", iBroken)); + return iBroken; + } + + void SetAlwaysVisible( TBool aValue ) + { + iAlwaysVisible = aValue; + } + + TBool AlwaysVisible() const + { + return iAlwaysVisible; + } + + void SetTransparent( TBool aValue ) + { + iTransparent = aValue; + } + + TBool IsTransparent() const + { + return iTransparent; + } + + + CNcdNodeIdentifier& ParentIdentifier() const + { + return *iParentIdentifier; + } + + CNcdContentSource* CopyL() const + { + CNcdContentSource* copy = CNcdContentSource::NewLC( *iParentIdentifier ); + copy->SetNameSpaceL( *iNameSpace ); + copy->SetProviderL( *iProvider ); + copy->SetUriL( *iUri ); + copy->SetNodeIdL( *iNodeId ); + copy->SetBroken( iBroken ); + copy->SetAlwaysVisible( iAlwaysVisible ); + copy->SetTransparent( iTransparent ); + CleanupStack::Pop( copy ); + return copy; + } + + TBool Equals( const CNcdContentSource& aContentSource ) const + { + if ( aContentSource.NameSpace() == NameSpace() && + aContentSource.Provider() == Provider() && + aContentSource.Uri() == Uri() && + aContentSource.NodeId() == NodeId() ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + + + void ExternalizeL( RWriteStream& aStream ) + { + iParentIdentifier->ExternalizeL( aStream ); + ExternalizeDesL( NameSpace(), aStream ); + ExternalizeDesL( Provider(), aStream ); + ExternalizeDesL( Uri(), aStream ); + ExternalizeDesL( NodeId(), aStream ); + aStream.WriteInt8L( iBroken ); + aStream.WriteInt8L( iAlwaysVisible ); + aStream.WriteInt8L( iTransparent ); + } + +private: + CNcdContentSource() + : iBroken( EFalse ), + iAlwaysVisible( EFalse ), + iTransparent( EFalse ) + { + } + + + void ConstructL( const CNcdNodeIdentifier& aParentIdentifier ) + { + iParentIdentifier = CNcdNodeIdentifier::NewL( aParentIdentifier ); + iNameSpace = KNullDesC().AllocL(); + iProvider = KNullDesC().AllocL(); + iUri = KNullDesC().AllocL(); + iNodeId = KNullDesC().AllocL(); + } + + void ConstructL( RReadStream& aStream ) + { + iParentIdentifier = CNcdNodeIdentifier::NewL( aStream ); + InternalizeDesL( iNameSpace, aStream ); + InternalizeDesL( iProvider, aStream ); + InternalizeDesL( iUri, aStream ); + InternalizeDesL( iNodeId, aStream ); + iBroken = aStream.ReadInt8L(); + iAlwaysVisible = aStream.ReadInt8L(); + iTransparent = aStream.ReadInt8L(); + } + +private: + CNcdNodeIdentifier* iParentIdentifier; + HBufC* iNameSpace; + HBufC* iProvider; + HBufC* iUri; + HBufC* iNodeId; + TBool iBroken; + TBool iAlwaysVisible; + TBool iTransparent; + }; + +class CNcdNodeMap : public CBase + { +public: + CNcdNodeMap( CNcdContentSource* aContentSource ) + : iContentSource( aContentSource ) + { + } + + static CNcdNodeMap* NewL( RReadStream& aStream ) + { + CNcdNodeMap* self = new ( ELeave ) CNcdNodeMap; + CleanupStack::PushL( self ); + self->ConstructL( aStream ); + CleanupStack::Pop( self ); + return self; + } + + virtual ~CNcdNodeMap() + { + delete iContentSource; + iNodes.ResetAndDestroy(); + } + + TBool ContainsNode( const CNcdNodeIdentifier& aNodeIdentifier ) + { + for ( TInt i = 0; i < iNodes.Count(); i++ ) + { + if ( iNodes[i]->Equals( aNodeIdentifier ) ) + { + return ETrue; + } + } + return EFalse; + } + + void ExternalizeL( RWriteStream& aStream ) + { + iContentSource->ExternalizeL( aStream ); + aStream.WriteInt32L( iNodes.Count() ); + for ( TInt i = 0; i < iNodes.Count(); i++ ) + { + iNodes[i]->ExternalizeL( aStream ); + } + } + +private: + CNcdNodeMap() + { + } + + void ConstructL( RReadStream& aStream ) + { + DLTRACEIN(("")); + iContentSource = CNcdContentSource::NewL( aStream ); + TInt32 nodeCount = aStream.ReadInt32L(); + for ( TInt i = 0; i < nodeCount; i++ ) + { + CNcdNodeIdentifier* nodeId = CNcdNodeIdentifier::NewLC( aStream ); + iNodes.AppendL( nodeId ); + CleanupStack::Pop( nodeId ); + } + } + +public: + CNcdContentSource* iContentSource; + RPointerArray iNodes; + }; + +class CNcdFolderContent : public CBase + { +public: + static CNcdFolderContent* NewL( + CNcdNodeIdentifier* aFolderIdentifier, TInt aPositionInGrid ) + { + CNcdFolderContent* self = + new ( ELeave ) CNcdFolderContent( aFolderIdentifier, aPositionInGrid ); + return self; + } + + static CNcdFolderContent* NewLC( RReadStream& aStream ) + { + CNcdFolderContent* self = new ( ELeave ) CNcdFolderContent; + CleanupStack::PushL( self ); + self->InternalizeL( aStream ); + return self; + } + + ~CNcdFolderContent() + { + delete iFolderIdentifier; + iContentSources.ResetAndDestroy(); + } + + TInt Find( const CNcdContentSource& aContentSource ) const + { + for ( TInt i = 0; i < iContentSources.Count(); i++ ) + { + if ( iContentSources[i]->Equals( aContentSource ) ) + { + return i; + } + } + return KErrNotFound; + } + + const CNcdNodeIdentifier& FolderIdentifier() const + { + DASSERT( iFolderIdentifier ); + return *iFolderIdentifier; + } + + TInt PositionInGrid() const + { + return iPositionInGrid; + } + + CNcdContentSource& ContentSource( TInt aIndex ) const + { + DASSERT( aIndex >= 0 && aIndex < iContentSources.Count() ); + return *iContentSources[aIndex]; + } + + TInt ContentSourceCount() const + { + return iContentSources.Count(); + } + + void AppendContentSourceL( CNcdContentSource* aContentSource ) + { + iContentSources.AppendL( aContentSource ); + } + + void ClearContentSources() + { + iContentSources.ResetAndDestroy(); + } + + void ExternalizeL( RWriteStream& aStream ) + { + DLTRACEIN(("")); + aStream.WriteInt32L( iPositionInGrid ); + iFolderIdentifier->ExternalizeL( aStream ); + aStream.WriteInt32L( iContentSources.Count() ); + for ( TInt i = 0; i < iContentSources.Count(); i++ ) + { + iContentSources[i]->ExternalizeL( aStream ); + } + } + + +protected: + CNcdFolderContent( CNcdNodeIdentifier* aFolderIdentifier, TInt aPositionInGrid ) : + iPositionInGrid( aPositionInGrid ), iFolderIdentifier( aFolderIdentifier ) + { + } + + CNcdFolderContent() + { + } + + void InternalizeL( RReadStream& aStream ) + { + DLTRACEIN(("")); + iPositionInGrid = aStream.ReadInt32L(); + delete iFolderIdentifier; + iFolderIdentifier = NULL; + iFolderIdentifier = CNcdNodeIdentifier::NewL( aStream ); + + iContentSources.ResetAndDestroy(); + TInt contentSourceCount = aStream.ReadInt32L(); + for ( TInt i = 0; i < contentSourceCount; i++ ) + { + CNcdContentSource* contentSource = CNcdContentSource::NewL( aStream ); + CleanupStack::PushL( contentSource ); + iContentSources.AppendL( contentSource ); + CleanupStack::Pop( contentSource ); + } + } + + +private: + TInt iPositionInGrid; + CNcdNodeIdentifier* iFolderIdentifier; + RPointerArray iContentSources; + }; + + +class CNcdContentSourceMap : public CBase + { +public: + static CNcdContentSourceMap* NewL() + { + CNcdContentSourceMap* self = + new( ELeave ) CNcdContentSourceMap; + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + + static CNcdContentSourceMap* NewL( RReadStream& aStream ) + { + CNcdContentSourceMap* self = new ( ELeave ) CNcdContentSourceMap; + CleanupStack::PushL( self ); + self->ConstructL( aStream ); + CleanupStack::Pop( self ); + return self; + } + + + ~CNcdContentSourceMap() + { + iNodeMaps.ResetAndDestroy(); + iFolderContents.ResetAndDestroy(); + } + + + TInt GetInsertIndexL( + const CNcdContentSource& aContentSource, + const CNcdNodeIdentifier& aParentIdentifier ) + { + DLTRACEIN(("")); + TInt folderIndex = FindFolder( aParentIdentifier ); + User::LeaveIfError( folderIndex ); + CNcdFolderContent& folderContent = FolderContent( folderIndex ); + + TInt csIndex = folderContent.Find( aContentSource ); + User::LeaveIfError( csIndex ); + TInt insertIndex = 0; + for ( TInt i = 0; i <= csIndex; i++ ) + { + CNcdContentSource& contentSource = folderContent.ContentSource( i ); + insertIndex += NodeCount( contentSource ); + } + + if ( aParentIdentifier.NodeNameSpace() == + NcdProviderDefines::KRootNodeNameSpace ) + { + // There may be bundles before this content source, so the index + // must be increased possibly. + for ( TInt i = 0; i < iFolderContents.Count(); i++ ) + { + if ( iFolderContents[i]->FolderIdentifier().NodeNameSpace() != + NcdProviderDefines::KRootNodeNameSpace && + iFolderContents[i]->PositionInGrid() <= csIndex ) + { + insertIndex++; + } + } + return insertIndex; + } + else + { + return insertIndex; + } + } + + void AppendContentSourceL( + CNcdContentSource* aContentSource, + TInt aPositionInGrid = 0 ) + { + DLTRACEIN(("")); + CNcdNodeMap* map = new ( ELeave ) CNcdNodeMap( aContentSource->CopyL() ); + CleanupStack::PushL( map ); + iNodeMaps.AppendL( map ); + CleanupStack::Pop( map ); + + TInt folderIndex = FindFolder( aContentSource->ParentIdentifier() ); + if ( folderIndex != KErrNotFound ) + { + CNcdFolderContent& folderContent = FolderContent( folderIndex ); + folderContent.AppendContentSourceL( aContentSource ); + } + else + { + CNcdNodeIdentifier* parentCopy = + CNcdNodeIdentifier::NewLC( aContentSource->ParentIdentifier() ); + CNcdFolderContent* folderContent = CNcdFolderContent::NewL( + parentCopy, aPositionInGrid ); + CleanupStack::Pop( parentCopy ); + CleanupStack::PushL( folderContent ); + iFolderContents.AppendL( folderContent ); + CleanupStack::Pop( folderContent ); + folderContent->AppendContentSourceL( aContentSource ); + } + } + + void AppendFolderL( const CNcdNodeIdentifier& aNodeIdentifier, + TInt aPositionInGrid = 0 ) + { + TInt folderIndex = FindFolder( aNodeIdentifier ); + if ( folderIndex == KErrNotFound ) + { + CNcdNodeIdentifier* parentCopy = + CNcdNodeIdentifier::NewLC( aNodeIdentifier ); + CNcdFolderContent* folderContent = CNcdFolderContent::NewL( + parentCopy, aPositionInGrid ); + CleanupStack::Pop( parentCopy ); + CleanupStack::PushL( folderContent ); + iFolderContents.AppendL( folderContent ); + CleanupStack::Pop( folderContent ); + } + } + + void AddNodeToContentSourceL( + CNcdNodeIdentifier* aNodeIdentifier, + CNcdContentSource& aContentSource ) + { + DLTRACEIN(("")); + TInt index = Find( aContentSource ); + User::LeaveIfError( index ); + CNcdNodeMap* map = iNodeMaps[index]; + if ( !map->ContainsNode( *aNodeIdentifier ) ) + { + map->iNodes.AppendL( aNodeIdentifier ); + } + } + + TInt ContentSourceCount() + { + return iNodeMaps.Count(); + } + + CNcdContentSource& ContentSource( TInt aIndex ) + { + return *iNodeMaps[aIndex]->iContentSource; + } + + TBool HasContentSource( const CNcdContentSource& aContentSource ) + { + TInt index = Find( aContentSource ); + return index != KErrNotFound; + } + + CNcdContentSource& ContentSourceL( const CNcdContentSource& aContentSource ) + { + TInt index = Find( aContentSource ); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + + return *iNodeMaps[index]->iContentSource; + } + + RPointerArray& NodesL( + const CNcdContentSource& aContentSource ) + { + + TInt index = Find( aContentSource ); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + return iNodeMaps[index]->iNodes; + } + + TInt BundleFolderCount() const + { + TInt count( 0 ); + for ( TInt i = 0; i < iFolderContents.Count(); i++ ) + { + if ( iFolderContents[i]->FolderIdentifier().NodeNameSpace() != + NcdProviderDefines::KRootNodeNameSpace ) + { + count++; + } + } + return count; + } + + const CNcdNodeIdentifier& BundleFolder( TInt aIndex ) const + { + TInt bundleIndex( 0 ); + for ( TInt i = 0; i < iFolderContents.Count(); i++ ) + { + if ( iFolderContents[i]->FolderIdentifier().NodeNameSpace() != NcdProviderDefines::KRootNodeNameSpace ) + { + if ( aIndex == bundleIndex ) + { + return iFolderContents[i]->FolderIdentifier(); + } + bundleIndex++; + } + } + + DASSERT( EFalse ); + return iFolderContents[0]->FolderIdentifier(); + } + + TBool HasBundleFolder( const CNcdNodeIdentifier& aNodeIdentifier ) + { + DLTRACEIN(("")); + TInt index = FindFolder( aNodeIdentifier ); + if ( index != KErrNotFound && aNodeIdentifier.NodeNameSpace() != NcdProviderDefines::KRootNodeNameSpace ) + { + return ETrue; + } + return EFalse; + } + + TInt FindFolder( const CNcdNodeIdentifier& aFolderIdentifier ) const + { + for ( TInt i = 0; i < iFolderContents.Count(); i++ ) + { + if ( iFolderContents[i]->FolderIdentifier().Equals( aFolderIdentifier ) ) + { + return i; + } + } + + return KErrNotFound; + } + + CNcdFolderContent& FolderContent( TInt aIndex ) const + { + DASSERT( aIndex >= 0 && aIndex < iFolderContents.Count() ); + return *iFolderContents[aIndex]; + } + + void ExternalizeL( RWriteStream& aStream ) + { + DLTRACEIN(( ( "Content source count=%d" ), iNodeMaps.Count() )); + aStream.WriteInt32L( iNodeMaps.Count() ); + for ( TInt i = 0; i < iNodeMaps.Count(); i++ ) + { + iNodeMaps[i]->ExternalizeL( aStream ); + } + DLINFO(( ( "Folder content count=%d" ), iFolderContents.Count() )); + aStream.WriteInt32L( iFolderContents.Count() ); + for ( TInt i = 0; i < iFolderContents.Count(); i++ ) + { + iFolderContents[i]->ExternalizeL( aStream ); + } + } + +private: + CNcdContentSourceMap(){} + void ConstructL(){} + + void ConstructL( RReadStream& aStream ) + { + DLTRACEIN(("")); + TInt32 nodeMapCount = aStream.ReadInt32L(); + DLINFO((("Content source count=%d"), nodeMapCount )); + for ( TInt i = 0; i < nodeMapCount; i++ ) + { + CNcdNodeMap* map = CNcdNodeMap::NewL( aStream ); + CleanupStack::PushL( map ); + iNodeMaps.AppendL( map ); + CleanupStack::Pop( map ); + } + + TInt32 folderContentCount = aStream.ReadInt32L(); + DLINFO((("Folder content count=%d"), folderContentCount )); + for ( TInt i = 0; i < folderContentCount; i++ ) + { + CNcdFolderContent* content = CNcdFolderContent::NewLC( aStream ); + iFolderContents.AppendL( content ); + CleanupStack::Pop( content ); + } + } + + TInt Find( const CNcdContentSource& aContentSource ) const + { + for ( TInt i = 0; i < iNodeMaps.Count(); i++ ) + { + if ( iNodeMaps[i]->iContentSource->Equals( aContentSource ) ) + { + return i; + } + } + return KErrNotFound; + } + + + TInt NodeCount( const CNcdContentSource& aContentSource ) const + { + TInt index = Find( aContentSource ); + DASSERT( index >= 0 && index < iNodeMaps.Count() ); + CNcdNodeMap* map = iNodeMaps[index]; + return map->iNodes.Count(); + } + +private: + RPointerArray iNodeMaps; + RPointerArray iFolderContents; + + }; + + +/** + * Load node operation implementation. + * + * Handles the "loading of root node" i.e. creates + * a root node from a conf protocol response. + * + * @lib ?library + * @since S60 ?S60_version *** for example, S60 v3.0 + */ +class CNcdLoadRootNodeOperation : public CNcdBaseOperation, + public MNcdParserObserver, + public MCatalogsHttpObserver, + public MNcdParserConfigurationProtocolObserver, + public MNcdConfigurationObserver + { + +public: + + /** Sub states of root node operation */ + enum TRootNodeState + { + EConfRequest, // create and send a conf request + EReceiveConf, // receive and parse conf data + EConfQuery, // respond to conf query + EBrowseRequest, // create sub-operations + EReceiveBrowse, // wait for sub-operations to complete + EComplete, // everything done + EFailed // operation failed + }; + + + static CNcdLoadRootNodeOperation* NewL( + TInt aClientUid, + CNcdGeneralManager& aGeneralManager, + MCatalogsHttpSession& aHttpSession, + MNcdOperationRemoveHandler* aRemoveHandler, + MCatalogsSession& aSession ); + + static CNcdLoadRootNodeOperation* NewLC( + TInt aClientUid, + CNcdGeneralManager& aGeneralManager, + MCatalogsHttpSession& aHttpSession, + MNcdOperationRemoveHandler* aRemoveHandler, + MCatalogsSession& aSession ); + + virtual ~CNcdLoadRootNodeOperation(); + + /** + * Returns the identifier of the parent node this operation is loading. + * + * @return Identifier of the parent node. + */ + const CNcdNodeIdentifier& NodeIdentifier() const; + +public: //from CNcdBaseOperation + + /** + * @see CNcdBaseOperation::Cancel + */ + virtual void Cancel(); + + /** + * @see CNcdBaseOperation::HandleCancelMessage + */ + virtual void HandleCancelMessage( MCatalogsBaseMessage* aMessage ); + +public: // from MCatalogsHttpObserver + + /** + * @see MCatalogsHttpObserver::HandleHttpEventL + */ + virtual void HandleHttpEventL( + MCatalogsHttpOperation& aOperation, + TCatalogsHttpEvent aEvent ); + + /** + * @see MCatalogsHttpObserver::HandleHttpError() + */ + TBool HandleHttpError( + MCatalogsHttpOperation& aOperation, + TCatalogsHttpError aError ); + +public: //from MNcdParserObserver + + /** + * @see MNcdParserObserver + */ + virtual void ParseError( TInt aErrorCode ); + + /** + * @see MNcdParserObserver + */ + virtual void ParseCompleteL( TInt aError ); + +public: // from MNcdParserConfigurationProtocolObserver + + virtual void ConfigurationBeginL( const TDesC& aVersion, + TInt aExpirationDelta ); + virtual void ConfigurationQueryL( MNcdConfigurationProtocolQuery* aQuery ); + + virtual void ClientConfigurationL( + MNcdConfigurationProtocolClientConfiguration* aConfiguration ); + virtual void ConfigurationDetailsL( + CArrayPtr* aDetails ); + virtual void ConfigurationActionRequestL( + MNcdConfigurationProtocolActionRequest* aActionRequest ); + virtual void ConfigurationErrorL( MNcdConfigurationProtocolError* aError ); + virtual void ConfigurationServerDetailsL( MNcdConfigurationProtocolServerDetails* aServerDetails ); + virtual void ConfigurationEndL(); + +public: // from MNcdOperationObserver + + /** + * @see MNcdOperationObserver + */ + virtual void Progress( CNcdBaseOperation& aOperation ); + + /** + * @see MNcdOperationObserver + */ + virtual void QueryReceived( CNcdBaseOperation& aOperation, + CNcdQuery* aQuery ); + + /** + * @see MNcdOperationObserver + */ + virtual void OperationComplete( CNcdBaseOperation* aOperation, + TInt aError ); + +public: // from MNcdConfigurationObserver + + virtual void ConfigurationChangedL(); + +public: // from CCatalogsCommunicable + + /** + * @see CCatalogsCommunicable + */ + virtual void ReceiveMessage( + MCatalogsBaseMessage* aMessage, + TInt aFunctionNumber ); + +public: // from MNcdParserErrorObserver + + virtual void ErrorL( MNcdPreminetProtocolError* aData ); + + +protected: + + CNcdLoadRootNodeOperation( + TInt aClientUid, + CNcdGeneralManager& aGeneralManager, + MCatalogsHttpSession& aHttpSession, + MNcdOperationRemoveHandler* aRemoveHandler, + MCatalogsSession& aSession ); + + void ConstructL(); + + HBufC8* CreateConfRequestLC( CNcdQuery* aQuery = NULL ); + + /** + * Reverts the nodes which could not be retrieved due to broken content + * source from NodeManager's temp cache to main RAM cache. + */ + void RevertNodesOfBrokenSourcesToCacheL(); + + /** + * Reverts the given node belonging to given content source from + * NodeManager's temp cache to the main cache. + */ + void RevertNodeL( + const CNcdNodeIdentifier& aNodeIdentifier, + const CNcdContentSource& aContentSource ); + + /** + * Checks the content source map for nodes which belong to several parent + * nodes and adds them as child of the different parents. + */ + void AddNodesToDifferentParentsL(); + + /** + * Sets always visible flags to the metadata of the nodes that belong to + * content sources defined as always visible in client configuration. + */ + void SetAlwaysVisibleFlagsL(); + + void ParseCatalogBundleL( const MNcdConfigurationProtocolDetail& aDetail ); + + static TBool ContainsNode( + const RPointerArray& aNodes, + const CNcdNodeIdentifier& aNode); + +protected: + + void HandleConfigurationDataRequestMessage( MCatalogsBaseMessage& aMessage ); + + +protected: // from CNcdBaseOperation + + /** + * @see CNcdBaseOperation::RunOperation + */ + virtual TInt RunOperation(); + + void DoRunOperationL(); + + /** + * @see CNcdBaseOperation::RunOperation + */ + virtual void ChangeToPreviousStateL(); + + virtual TBool QueryCompletedL( CNcdQuery* aQuery ); + +private: // type declarations + + /** Sub states of master server redirection process */ + enum TMasterServerRedirectionState + { + EBegin, // Start state. + ERedirecting, // Redirecting. + EReverted // Returned to use previous master server address. + }; + +private: // data + /** + * A sub-state of this operation's execution. + */ + TRootNodeState iRootNodeState; + + /** + * A sub-state of master server redirection. + */ + TMasterServerRedirectionState iMasterServerRedirectionState; + + /** + * Nodes that have been loaded. This is used to store loaded + * nodes identifiers before they can be sent to the proxy in a message. + */ + RPointerArray iLoadedNodes; + + /** + * This flag is set to indicate that progress info should be sent + * when the next message is received. + */ + TBool iSendProgress; + + CNcdNodeIdentifier* iRootNodeIdentifier; + + /** + * Access point manager for creating access points. + */ + MCatalogsAccessPointManager& iAccessPointManager; + + + /** + * Http session for sending requests and receiving responses. + * Not own. + */ + MCatalogsHttpSession& iHttpSession; + + MNcdProtocol& iProtocol; + + /** + * Configuration manager for getting the Master Server Address + */ + MNcdConfigurationManager& iConfigManager; + + /** + * Http operation for current transaction. + * Not own. + */ + MCatalogsHttpOperation* iTransaction; + + /** + * Sub-operations for browse requests. + */ + RPointerArray iSubOps; + RPointerArray iFailedSubOps; + RPointerArray iCompletedSubOps; + + TInt32 iClientUid; + + /** + * Content sources are stored here. + */ + CNcdContentSourceMap* iContentSourceMap; + + CNcdQuery* iConfQuery; + RPointerArray iSubOpQuerys; + + + MNcdParserConfigurationProtocolObserver* iDefaultConfigurationProtocolObserver; + + HBufC* iServerUri; + + CBufFlat* iConfigResponseBuf; + + TInt iBundleInsertIndex; + + TBool iNodeDbLocked; + + /** + * Maps of current children and their children for new checking. + */ + RPointerArray iChildEntityMaps; + }; + +#endif // C_NCDLOADROOTNODEOPERATIONIMPL_H