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:  

    15 *

    16 */

    17 

    18 

    19 #ifndef C_NCDLOADNODEOPERATIONIMPL_H

    20 #define C_NCDLOADNODEOPERATIONIMPL_H

    21 

    22 #include <e32base.h>

    23 

    24 #include "ncdbaseoperation.h"

    25 #include "ncdparserobserver.h"

    26 #include "catalogshttpobserver.h"

    27 #include "catalogshttptypes.h"

    28 #include "catalogshttpsession.h"

    29 #include "ncdoperationobserver.h"

    30 #include "ncdchildloadmode.h"

    31 #include "ncdnodefactory.h"

    32 // move content source to it's own header and include it

    33 // instead of root op's header

    34 #include "ncdloadrootnodeoperationimpl.h"

    35 

    36 //Constants.

    37 const TInt KNcdStructPageSize(48);

    38 

    39 

    40 class CDesC16Array;

    41 class CDesC16ArrayFlat;

    42 class CDesC8ArrayFlat;

    43 class MNcdParser;

    44 class CNcdNodeManager;

    45 class MNcdProtocol;

    46 class CNcdNodeIdentifier;

    47 class MCatalogsContext;

    48 class MNcdPreminetProtocolEntityRef;

    49 class MNcdPreminetProtocolDataEntity;

    50 class CNcdQuery;

    51 class MNcdOperationRemoveHandler;

    52 class MCatalogsAccessPointManager;

    53 class MNcdOperationQueue;

    54 

    55 

    56 class TNcdResponseFilterParams

    57     {

    58 public:

    59     TNcdResponseFilterParams()

    60         {

    61         iPageSize = 0;

    62         iPageStart = 0;

    63         iStructureDepth = 0;

    64         iMetadataDepth = 0;

    65         iMetadataPerLevel = 0;

    66         }

    67 public:

    68     TInt iPageSize;

    69     TInt iPageStart;

    70     TInt iStructureDepth;

    71     TInt iMetadataDepth;

    72     TInt iMetadataPerLevel;

    73     };

    74 

    75 const TInt KNcdLoadNodeErrNothingToDo(-1000000);

    76 const TInt KNcdLoadNodeErrRemoteOnly(-1000001);

    77 

    78 /**

    79  *  Load node operation implementation.

    80  *

    81  *  Handles loading nodes from server.

    82  *

    83  *  @lib ?library

    84  *  @since S60 ?S60_version *** for example, S60 v3.0

    85  */

    86 class CNcdLoadNodeOperationImpl : public CNcdBaseOperation,

    87                                   public MNcdParserObserver,

    88                                   public MNcdParserEntityObserver,

    89                                   public MCatalogsHttpObserver,

    90                                   public MNcdParserDataBlocksObserver

    91     {

    92 class CNcdNodeIconMap;    

    93 public:

    94 

    95     /** Sub states of load node operation */

    96     enum TLoadNodeOperationState

    97         {

    98         ESendRequest,      // create and send a browse request

    99         EReceive,          // receive and parse node data

   100         //EQuery,            // a query is pending

   101         ERemote,           // create sub operations for remote folders

   102         EReceiveRemote,    // wait completion of sub operations

   103         EComplete,         // everything done

   104         EFailed            // operation failed

   105         };

   106         

   107     enum TLoadMode

   108         {

   109         EContentSource,

   110         ESingleNode,

   111         EChildren,

   112         };

   113     

   114     

   115     /**

   116      * @param aCreateParent Creates the parent node with the given purpose

   117      * if it does not exist yet.

   118      */

   119     static CNcdLoadNodeOperationImpl* NewL(

   120         const CNcdNodeIdentifier& aNodeIdentifier,

   121         const CNcdNodeIdentifier& aParentIdentifier,

   122         CNcdNodeFactory::TNcdNodePurpose aParentNodePurpose,

   123         TNcdResponseFilterParams aFilterParams,

   124         CNcdGeneralManager& aGeneralManager,

   125         MCatalogsHttpSession& aHttpSession,

   126         MNcdOperationRemoveHandler* aRemoveHandler,

   127         MNcdOperationQueue* aOperationQueue,

   128         MCatalogsSession& aSession,

   129         TBool aLoadChildren = EFalse,

   130         TNcdChildLoadMode aMode = ELoadStructure,

   131         TBool aIsSubOperation = EFalse,

   132         TBool aCreateParent = ETrue );

   133 

   134     /**

   135      * @param aCreateParent Creates the parent node with the given purpose

   136      * if it does not exist yet.

   137      */

   138     static CNcdLoadNodeOperationImpl* NewLC(

   139         const CNcdNodeIdentifier& aNodeIdentifier,

   140         const CNcdNodeIdentifier& aParentIdentifier,

   141         CNcdNodeFactory::TNcdNodePurpose aParentNodePurpose,

   142         TNcdResponseFilterParams aFilterParams,        

   143         CNcdGeneralManager& aGeneralManager,

   144         MCatalogsHttpSession& aHttpSession,

   145         MNcdOperationRemoveHandler* aRemoveHandler,

   146         MNcdOperationQueue* aOperationQueue,

   147         MCatalogsSession& aSession,

   148         TBool aLoadChildren = EFalse,

   149         TNcdChildLoadMode aMode = ELoadStructure,

   150         TBool aIsSubOperation = EFalse,

   151         TBool aCreateParent = ETrue );

   152         

   153     /**

   154      * Overloaded constructor for loading from a content source.

   155      * Sets iIsSubOperation to ETrue.

   156      */

   157     static CNcdLoadNodeOperationImpl* NewLC(

   158         CNcdContentSource& aContentSource,

   159         CNcdContentSourceMap* aContentSourceMap,

   160         const CNcdNodeIdentifier& aParentIdentifier,        

   161         CNcdGeneralManager& aGeneralManager,

   162         MCatalogsHttpSession& aHttpSession,

   163         MNcdOperationRemoveHandler* aRemoveHandler,        

   164         MCatalogsSession& aSession );

   165         

   166     virtual ~CNcdLoadNodeOperationImpl();

   167     

   168     TLoadNodeOperationState State();

   169     

   170     /**

   171      * Getter for loaded nodes.

   172      * Intended for parent op use during a progress callback.

   173      * The array contents will be removed after the progress calback.

   174      *

   175      * @return An array of nodes that have been loaded by this op.

   176      */        

   177     const RPointerArray<CNcdNodeIdentifier>& LoadedNodes();

   178     

   179     /**

   180      * Returns the identifier of the parent node this operation is loading,

   181      * if available.

   182      *

   183      * @return Identifier of the parent node or NULL.

   184      */

   185     const CNcdNodeIdentifier* NodeIdentifier() const;

   186 

   187 public: // from CNcdBaseOperation

   188 

   189     /**

   190      * @see CNcdBaseOperation::Start

   191      */

   192     virtual TInt Start();

   193 

   194     /**

   195      * @see CNcdBaseOperation::Cancel

   196      */

   197     virtual void Cancel();

   198     

   199     /**

   200      * @see CNcdBaseOperation::HandleCancelMessage

   201      */

   202     virtual void HandleCancelMessage( MCatalogsBaseMessage* aMessage );

   203     

   204     /**

   205      * @see CNcdBaseOperation::CompleteMessage         

   206      */

   207     virtual TInt CompleteMessage( MCatalogsBaseMessage* & aMessage,

   208         TNcdOperationMessageCompletionId aId,

   209         const MNcdSendable& aSendableObject,

   210         TInt aStatus );

   211         

   212     /**

   213      * @see CNcdBaseOperation::CompleteMessage         

   214      */

   215     virtual TInt CompleteMessage( MCatalogsBaseMessage* & aMessage,

   216         TNcdOperationMessageCompletionId aId,

   217         TInt aStatus );

   218         

   219     /**

   220      * @see CNcdBaseOperation::CompleteMessage         

   221      */

   222     virtual TInt CompleteMessage( MCatalogsBaseMessage*& aMessage,

   223         TNcdOperationMessageCompletionId aId,

   224         const MNcdSendable& aSendableObject,

   225         RPointerArray<CNcdNodeIdentifier>& aNodes,

   226         TInt aStatus );

   227         

   228     /**

   229      * @see CNcdBaseOperation::CompleteMessage         

   230      */

   231     virtual TInt CompleteMessage( MCatalogsBaseMessage*& aMessage,

   232         TNcdOperationMessageCompletionId aId,

   233         RPointerArray<CNcdExpiredNode>& aExpiredNodes,

   234         TInt aStatus );

   235         

   236 

   237 // from base class MCatalogsHttpObserver

   238 

   239     /**     

   240      * @see MCatalogsHttpObserver::HandleHttpEventL

   241      */

   242     virtual void HandleHttpEventL( 

   243         MCatalogsHttpOperation& aOperation, 

   244         TCatalogsHttpEvent aEvent );

   245         

   246     /**

   247      * @see MCatalogsHttpObserver::HandleHttpError()

   248      */

   249     TBool HandleHttpError(

   250         MCatalogsHttpOperation& aOperation,

   251         TCatalogsHttpError aError );

   252         

   253 public: // from MNcdParserObserver

   254 

   255     /**

   256      * @see MNcdParserObserver

   257      */

   258     virtual void ParseError( TInt aErrorCode );

   259 

   260     /**

   261      * @see MNcdParserObserver

   262      */

   263     virtual void ParseCompleteL( TInt aError );

   264 

   265 public: // from  MNcdParserEntityObserver

   266 

   267     /**

   268      * @see MNcdParserEntityObserver

   269      */

   270     virtual void FolderRefL( MNcdPreminetProtocolFolderRef* aData );

   271     

   272     /**

   273      * @see MNcdParserEntityObserver

   274      */

   275     virtual void FolderDataL( MNcdPreminetProtocolDataEntity* aData );

   276     

   277     /**

   278      * @see MNcdParserEntityObserver

   279      */

   280     virtual void ItemRefL( MNcdPreminetProtocolItemRef* aData );

   281     

   282     /**

   283      * @see MNcdParserEntityObserver

   284      */

   285     virtual void ItemDataL( MNcdPreminetProtocolDataEntity* aData );

   286     

   287 public: // from MNcdOperationObserver

   288     

   289     /**

   290      * @see MNcdOperationObserver

   291      */

   292     virtual void Progress( CNcdBaseOperation& aOperation );

   293     

   294     /**

   295      * @see MNcdOperationObserver

   296      */

   297     virtual void QueryReceived( CNcdBaseOperation& aOperation,

   298                                 CNcdQuery* aQuery );

   299 

   300     /**

   301      * @see MNcdOperationObserver

   302      */

   303     virtual void OperationComplete( CNcdBaseOperation* aOperation,

   304                                     TInt aError );

   305 

   306 public: // from MNcdParserDataBlocksObserver

   307 

   308     /**

   309      * @see MNcdDataBlocksObserver

   310      */

   311     virtual void DataBlocksL( 

   312         CArrayPtr<MNcdPreminetProtocolDataBlock>* aData );

   313 

   314 public: // from CNcdBaseOperation

   315 

   316     /**

   317      * @see CNcdBaseOperation

   318      */

   319     virtual TBool QueryCompletedL( CNcdQuery* aQuery );

   320     

   321 public: // from MNcdParserErrorObserver

   322 

   323     virtual void ErrorL( MNcdPreminetProtocolError* aData );

   324 

   325     

   326 protected:

   327 

   328     CNcdLoadNodeOperationImpl( 

   329         CNcdNodeFactory::TNcdNodePurpose aParentNodePurpose,

   330         TNcdResponseFilterParams aFilterParams,

   331         TNcdChildLoadMode aMode,

   332         TBool aLoadChildren,

   333         CNcdGeneralManager& aGeneralManager,

   334         MCatalogsHttpSession& aHttpSession,

   335         MNcdOperationRemoveHandler* aRemoveHandler,

   336         MNcdOperationQueue* aOperationQueue,

   337         MCatalogsSession& aSession,

   338         TBool aIsSubOperation,

   339         TBool aCreateParent );

   340         

   341     CNcdLoadNodeOperationImpl( 

   342         CNcdGeneralManager& aGeneralManager,

   343         MCatalogsHttpSession& aHttpSession,

   344         MNcdOperationRemoveHandler* aRemoveHandler,

   345         MCatalogsSession& aSession  );

   346     

   347     void ConstructL( const CNcdNodeIdentifier& aNodeIdentifier,

   348         const CNcdNodeIdentifier& aParentIdentifier );

   349         

   350     void ConstructL( CNcdContentSource& aContentSource,

   351         CNcdContentSourceMap* aContentSourceMap,

   352         const CNcdNodeIdentifier& aParentIdentifier );

   353         

   354     

   355     

   356     virtual HBufC8* CreateRequestLC( CNcdNodeIdentifier* aNodeIdentifier,

   357         TNcdResponseFilterParams aFilterParams,

   358         const TDesC& aUri );

   359 

   360     /**

   361      * Maps the icon ID for data block ID if the icon data is in a separate

   362      * data block.

   363      *

   364      * @param aIconId The icon Id.

   365      * @param aDataBlockId The data block Id containing the icon data.

   366      * @param aNodeIdenfier The node which has the icon.

   367      */

   368     void MapIconIdForDataBlockL(

   369         const TDesC& aIconId, const TDesC& aDataBlockId,

   370         const CNcdNodeIdentifier& aNodeIdentifier);

   371         

   372     /**

   373      * Used to request the ID of the icon of which data is in the given

   374      * data block.

   375      *

   376      * @note The responsibility of closing the returned array is in the caller.

   377      * @param aDataBlockId ID of the data block

   378      * @param aNodeIdentifier On return the node which has the icon is

   379      *                        assigned to this pointer.

   380      * @return The icon ID or NULL of icon id was not found.

   381      */

   382     RPointerArray<CNcdLoadNodeOperationImpl::CNcdNodeIconMap> IconsForDataBlockL(

   383         const TDesC& aDataBlockId);

   384     

   385     /**

   386      * Creates sub load-operations for remote folders.

   387      *

   388      */    

   389     virtual void CreateSubOperationsL();

   390     

   391     /**

   392      * Checks whether loading is really necessary.

   393      * This method is used to determine whether to complete

   394      * the op early on before doing anything else. 

   395      * There are many cases where it's impossible or unwise to complete

   396      * the operation normally e.g. load started for search root.

   397      */    

   398     virtual TBool IsLoadingNecessaryL();

   399     

   400     /**

   401      * Checks whether a folder's children should be cleared

   402      */

   403     virtual TBool IsChildClearingNecessaryL();

   404      

   405 

   406     /**

   407      * Determines the type of the parent node

   408      */

   409     void DetermineParentTypeL( const TUid& aUid );

   410     

   411     /**

   412      * Removes the session of current namespace & server uri.

   413      */

   414     void RemoveServerSessionL();

   415      

   416     /**

   417      * Sets the children loaded flag for the folder (or folders)

   418      * that were loaded (the flags intention is to differentiate first time

   419      * load from subsequent ones). 

   420      *

   421      * @see CNcdNodeFolder::SetChildrenPreviouslyLoaded

   422      */

   423     void SetChildrenLoadedFlagL();

   424     

   425     /**

   426      * Refreshesh seen status if needed.

   427      *

   428      * @see CNcdNodeSeenInfo::RefreshFolderSeenStatusL

   429      */

   430     void RefreshSeenStatusL();

   431     

   432     /**

   433      * Calculates the correct structure page size for the given page

   434      * of the given folder.

   435      *

   436      * @param aPageStart Start index of the page.

   437      * @param aPageSize Original page size.

   438      * @param aNodeFolder The folder.

   439      * @param aChildLoadMode Load mode.

   440      */

   441     TInt CalculateStructPageSize(

   442         TInt aPageStart,

   443         TInt aPageSize,

   444         CNcdNodeFolder& aNodeFolder,

   445         TNcdChildLoadMode aChildLoadMode );

   446         

   447     

   448     /**

   449      * Returns the amount of remote folders that need to be loaded

   450      * separately as sub-operations.

   451      *

   452      * @return Remote folder count.

   453      */

   454     

   455     virtual TInt RemoteFolderCount() const;

   456     

   457     /**

   458      * Removes folder's children

   459      */

   460     virtual void RemoveChildrenL( CNcdNodeFolder& aFolder );

   461     

   462     /**

   463      * Notifies the operation manager about completion of a queued operation,

   464      * if the given completion id indicates that the operation is really completed.

   465      *

   466      * @param aId The completion id.

   467      */

   468     void NotifyCompletionOfQueuedOperation( TNcdOperationMessageCompletionId aId );    

   469     

   470     

   471 public: // from CNcdBaseOperation

   472 

   473     /**

   474      * @see CNcdBaseOperation::RunOperation

   475      */

   476     virtual TInt RunOperation();

   477     

   478     /**

   479      * @see CNcdBaseOperation::RunOperation

   480      */

   481     virtual void ChangeToPreviousStateL();

   482     

   483 protected:

   484 

   485     void DoRunOperationL();    

   486     

   487 protected: // data

   488     

   489     /**

   490      * A sub-state of this operation's execution.

   491      */

   492     TLoadNodeOperationState iLoadNodeState;

   493     

   494     /**

   495      * Nodes that have been loaded. This is used to store loaded

   496      * nodes identifiers before they can be sent to the proxy in a message.

   497      */

   498     RPointerArray<CNcdNodeIdentifier> iLoadedNodes;

   499         

   500     /**

   501      * Parent node identifier.

   502      */

   503     CNcdNodeIdentifier* iParentIdentifier;

   504     

   505     /**

   506      * Identifier of the node this op is loading.

   507      */

   508     CNcdNodeIdentifier* iNodeIdentifier;

   509     

   510     /**

   511      * Reference to access point manager.

   512      * Not owned by this.

   513      */

   514     MCatalogsAccessPointManager& iAccessPointManager;

   515     

   516     MNcdProtocol& iProtocol;

   517     

   518     /**

   519      * Http session for sending requests and receiving responses.

   520      * Not own.

   521      */

   522     MCatalogsHttpSession& iHttpSession;

   523     

   524     /**

   525      * Http operation for current transaction.

   526      * Not own.

   527      */

   528     MCatalogsHttpOperation* iTransaction;

   529         

   530     TNcdResponseFilterParams iFilterParams;

   531     

   532     CNcdQuery* iLoadNodeQuery;

   533     

   534     /**

   535      * Sub-operations for browse requests.

   536      */

   537     RPointerArray<CNcdLoadNodeOperationImpl> iSubOps;

   538     RPointerArray<CNcdLoadNodeOperationImpl> iFailedSubOps;

   539     RPointerArray<CNcdLoadNodeOperationImpl> iCompletedSubOps;

   540     

   541     HBufC* iServerUri;

   542     

   543     RPointerArray<CNcdQuery> iSubOpQuerys;

   544     

   545     /**

   546      * Remote folders encountered during the operation are stored here.

   547      * Load operations will be started for these nodes.

   548      */

   549     RPointerArray<CNcdNodeIdentifier> iRemoteFolders;

   550     

   551     /**

   552      * Child folders of transparent folders encountered during the

   553      * operation are stored here. Load operations will be started

   554      * from these nodes.

   555      */

   556     RPointerArray<CNcdNodeIdentifier> iTransparentChildFolders;

   557     

   558     /**

   559      * Child items of transparent folders.

   560      */

   561     RPointerArray<CNcdNodeIdentifier> iTransparentChildItems;

   562     

   563     TNcdChildLoadMode iChildLoadMode;

   564     TLoadMode iLoadMode;

   565     

   566     /**

   567      * Not own.

   568      */     

   569     CNcdContentSource* iContentSource;

   570     

   571     /**

   572      * Not own.

   573      */

   574     CNcdContentSourceMap* iContentSourceMap;

   575     

   576     TUid iClientUid;

   577     

   578     /**

   579      * Node index, this is used to put a child node to the

   580      * correct place in the parent node.

   581      */

   582     TInt iNodeIndex;

   583     

   584     /**

   585      * These are used if icon data is in separate data block.

   586      */

   587     RPointerArray<CNcdNodeIconMap> iNodeIconMaps;

   588     

   589     /**

   590      * Type of the parent node: root or folder

   591      */

   592     CNcdNodeFactory::TNcdNodeType iParentType;

   593     

   594     /** 

   595      * Purpose of the parent node.

   596      */

   597     CNcdNodeFactory::TNcdNodePurpose iParentPurpose;

   598     

   599     /**

   600      * Indicates whether the parent node must be created.

   601      */

   602     TBool iCreateParent;

   603     

   604     /**

   605      * Operation queue, not own.

   606      */

   607     MNcdOperationQueue* iOperationQueue;    

   608     

   609     /**

   610      * ETrue if node updates are held until the entire response

   611      * has been handled.

   612      *

   613      * This is used to ensure that datablocks have been received

   614      * before nodes are updated to the proxy-side

   615      */

   616     TBool iHoldNodeUpdates;

   617     

   618     class CNcdNodeIconMap : public CBase

   619         {

   620     public:

   621         static CNcdNodeIconMap* NewLC(

   622             const CNcdNodeIdentifier& aMetadataId,

   623             const TDesC& aIconId,

   624             const TDesC& aDataBlockId );

   625         ~CNcdNodeIconMap();

   626 

   627         HBufC* iDataBlockId;

   628         HBufC* iIconId;

   629         CNcdNodeIdentifier* iMetadataId;

   630         

   631     private:

   632         void ConstructL(

   633             const CNcdNodeIdentifier& aMetadataId,

   634             const TDesC& aIconId,

   635             const TDesC& aDataBlockId );

   636         CNcdNodeIconMap();                        

   637         };

   638     };

   639 

   640 #endif // C_NCDLOADNODEOPERATIONIMPL_H