--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/iaupdate/IAD/engine/controller/inc/iaupdatecontentoperationmanager.h Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,406 @@
+/*
+* Copyright (c) 2007-2008 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: CIAUpdateContentOperationManager
+*
+*/
+
+
+#ifndef IA_UPDATE_CONTENT_OPERATION_MANAGER_H
+#define IA_UPDATE_CONTENT_OPERATION_MANAGER_H
+
+
+#include <e32base.h>
+#include <e32cmn.h>
+
+#include "iaupdatecontentoperationobserver.h"
+
+class CIAUpdateBaseNode;
+class CIAUpdateNode;
+class MIAUpdateOperation;
+class MNcdPurchaseDetails;
+
+
+/**
+ * CIAUpdateContentOperationManager
+ * This will provide base functionality that can handle installing
+ * of hidden dependency nodes when one operation is requested
+ * for one visible node.
+ *
+ * @note Functions of this class trust that node dependencies do not loop.
+ * If dependency loops are set into nodes, then the operations may go
+ * into forever loop. So, when dependency links between nodes are created,
+ * the loops need to be handled already then.
+ */
+class CIAUpdateContentOperationManager : public CActive,
+ public MIAUpdateContentOperationObserver
+ {
+
+public:
+
+ /**
+ * This defines the possible types of operations.
+ */
+ enum TContentOperationType
+ {
+ /**
+ * No content operation is created for this.
+ */
+ ENoContentOperation,
+
+ /**
+ * Purchase operation should be created for this.
+ */
+ EPurchaseOperation,
+
+ /**
+ * Download operation should be created for this.
+ */
+ EDownloadOperation,
+
+ /**
+ * Install operation should be created for this.
+ */
+ EInstallOperation
+ };
+
+
+ /**
+ * @return CIAUpdateContentOperationManager* Created object.
+ * Ownership is transferred.
+ */
+ static CIAUpdateContentOperationManager* NewL();
+
+ /**
+ * @see CIAUpdateContentOperationManager:: NewL
+ */
+ static CIAUpdateContentOperationManager* NewLC();
+
+
+ /**
+ * Destructor
+ */
+ virtual ~CIAUpdateContentOperationManager();
+
+
+ /**
+ * If aError contains some base error value
+ * this function will remove the base value
+ * and returns the actual error code.
+ *
+ * @param aError Error code that needs to be checked.
+ * @return TInt Correct error code.
+ */
+ static TInt CheckErrorCode( TInt aError );
+
+ /**
+ * This function can be used to check the last operation type of the
+ * service pack.
+ *
+ * @param aNodeDetails Purchase history details of a node.
+ * @return TContentOperationType Operation type which describes the last
+ * operation that was done for the node. As a default this is EPurchaseOperation,
+ * but if download or install is tried then result is according to that.
+ * If the given node is not a service pack, then ENoContentOperation
+ * is returned.
+ */
+ static TContentOperationType ServicePackOperationType(
+ MNcdPurchaseDetails& aNodeDetails );
+
+
+ /**
+ * This function will sort the given array according to node depths.
+ * Then, all leaf nodes will be after their dependants in the
+ * array and root nodes are always in the beginning. This function
+ * can be used, for example, if recursion hierarchy is not what is wanted.
+ *
+ * @param aNodes Node array that will be sorted.
+ */
+ static void SortNodeArray( RPointerArray< CIAUpdateNode >& aNodes );
+
+
+ /**
+ * Uses HandleDependenciesL to create the node list.
+ *
+ * @param aNode Node whose dependencies are gone through.
+ * @param aNodes Array that will contain all the nodes that are part of
+ * the operation directed for this node.
+ * This means that all the wanted node branches that this node depends on
+ * are included into the array. The given node is set as first in the array.
+ * The tree hierarchy will be created recursive and leaves are towards the end
+ * of the array.
+ * @param aAcceptHiddenDependencyNodes If ETrue, then all the hidden
+ * dependency nodes and their branches are included. If EFalse the hidden
+ * dependency nodes are skipped.
+ * @param aAcceptVisibleDependencyNodes If ETrue, then all the non-hidden
+ * dependency nodes and their branches are included. If EFalse the non-hidden
+ * dependency nodes are skipped.
+ */
+ static void GetOperationNodesL( const CIAUpdateNode& aNode,
+ RPointerArray< CIAUpdateNode >& aNodes,
+ TBool aAcceptHiddenDependencyNodes,
+ TBool aAcceptDependencyVisibleNodes );
+
+
+ /**
+ * @param aNode The head node of the hierarchy whose total content
+ * size is counted.
+ * @param aIncludeDownloaded ETrue if already downloaded node content
+ * should be included into the total size. Else EFalse.
+ * @param aIncludeInstalled ETrue if already installed node content
+ * should be included into the total size. Else EFalse.
+ * @param aAcceptHiddenDependencyNodes If ETrue, then all the hidden
+ * dependency nodes and their branches are included. If EFalse the hidden
+ * dependency nodes are skipped.
+ * @param aAcceptVisibleDependencyNodes If ETrue, then all the non-hidden
+ * dependency nodes and their branches are included. If EFalse the non-hidden
+ * dependency nodes are skipped.
+ * @return TInt The content size of this node and contents it depends on.
+ */
+ static TInt TotalContentSizeL( const CIAUpdateNode& aNode,
+ TBool aIncludeDownloaded,
+ TBool aIncludeInstalled,
+ TBool aAcceptHiddenDependencyNodes,
+ TBool aAcceptDependencyVisibleNodes );
+
+
+ /**
+ * Starts the operation.
+ *
+ * @param aObserver This observer will be informed when
+ * operation is completed.
+ * @param aOperationType Type of the operation for node content.
+ * @param aNode The main node that will be inserted to the node list.
+ * Hidden nodes that belong to the dependency tree under this node
+ * are also inserted to the list.
+ * @exception Leaves with KErrInUser if the operation has
+ * already been started and not completed. Leaves with
+ * KErrArgument if the node is set as hidden. In other cases,
+ * leaves with system wide error codes.
+ */
+ void StartL( MIAUpdateContentOperationObserver& aObserver,
+ const TContentOperationType& aOperationType,
+ CIAUpdateNode& aNode );
+
+
+ /**
+ * @return const TContentOperationType& Operation type of the current or last
+ * operation. This value is set when StartL is called.
+ */
+ const TContentOperationType& OperationType() const;
+
+
+public: // MIAUpdateContentOperationObserver
+
+ /**
+ * @see MIAUpdateContentOperationObserver::ContentOperationComplete
+ *
+ * This is called when one of the nodes in the node chain has completed.
+ * This does not mean that the operation as a whole has finished yet.
+ *
+ */
+ virtual void ContentOperationComplete( CIAUpdateBaseNode& aNode,
+ TInt aError );
+
+ /**
+ * @see MIAUpdateContentOperationObserver::ContentOperationProgress
+ */
+ virtual void ContentOperationProgress( CIAUpdateBaseNode& aNode,
+ TInt aProgress,
+ TInt aMaxProgress );
+
+
+protected: // CActive
+
+ /**
+ * @see CActive::DoCancel
+ *
+ * Cancels the operation.
+ */
+ virtual void DoCancel();
+
+ /**
+ * @see CActive::RunL
+ *
+ * Calls HandleContentL for the current node from the node list.
+ * If the previous operation has failed, then other operations
+ * will not be continued. Observer is informed about the completion
+ * of the jobs with error code or KErrNone if operation was successfull
+ * as a whole.
+ */
+ virtual void RunL();
+
+ /**
+ * @see CActive::RunError
+ */
+ virtual TInt RunError( TInt aError );
+
+
+private:
+
+ // Prevent these if not implemented
+ CIAUpdateContentOperationManager(
+ const CIAUpdateContentOperationManager& aObject );
+ CIAUpdateContentOperationManager& operator =(
+ const CIAUpdateContentOperationManager& aObject );
+
+
+ /**
+ * Constructor
+ */
+ CIAUpdateContentOperationManager();
+
+ /**
+ * 2nd. phase constructor
+ */
+ void ConstructL();
+
+
+ /**
+ * If a progress value was changed. Then, observer is informed.
+ *
+ * @param aProgress Progress value for current operation.
+ * @param aMaxProgress Progress value for current operation.
+ */
+ void UpdateProgress( TInt aProgress, TInt aMaxProgress );
+
+ // Called when all the nodes have been handled or if error has occurred
+ // during operation chain.
+ void CompleteOperation( TInt aError );
+
+
+ // Resets progress values to their defaults.
+ void ResetProgress();
+
+ // Resets only current progress values to their defaults.
+ void ResetCurrentProgress();
+
+
+ // Initialize total maximum progress value to according to
+ // the type of the operation.
+ void InitTotalMaxProgressL(
+ const TContentOperationType& aOperationType );
+
+
+ // This function calculates the whole content size of the nodes
+ // in the array.
+ static TInt ArrayTotalContentSizeL(
+ const RPointerArray< CIAUpdateNode >& aNodes,
+ TBool aIncludeDownloaded,
+ TBool aIncludeInstalled );
+
+
+ // Insert this node and all the hidden dependencies under it
+ // into the member node array.
+ // Also, reset all the variables related to this.
+ void SetNodeArrayL( CIAUpdateNode& aNodes );
+
+
+ /**
+ * Handle node dependencies and correct nodes into the array.
+ *
+ * @param aNode Node that is handled.
+ * @param aNodes Node array that will contain the whole dependency hierarchy.
+ * @param aAcceptHiddenDependencyNodes If ETrue, then all the hidden
+ * dependency nodes and their branches are included. If EFalse the hidden
+ * dependency nodes are skipped.
+ * @param aAcceptVisibleDependencyNodes If ETrue, then all the non-hidden
+ * dependency nodes and their branches are included. If EFalse the non-hidden
+ * dependency nodes are skipped.
+ */
+ static void HandleDependenciesL(
+ const CIAUpdateNode& aNode,
+ RPointerArray< CIAUpdateNode >& aNodes,
+ TBool aAcceptHiddenDependencyNodes,
+ TBool aAcceptVisibleDependencyNodes );
+
+
+ // Creates the operation the corresponds the given operation type and node.
+ // Ownership of the operation is transferred.
+ MIAUpdateOperation* CreateOperationL(
+ const TContentOperationType& aOperationType,
+ CIAUpdateNode& aNode );
+
+
+ // Updates the purchase history of the node with the given
+ // error code.
+ void UpdatePurchaseHistory(
+ CIAUpdateNode& aNode, TInt aError ) const;
+
+
+ // Checks if the node is a service pack.
+ static TBool IsServicePack( const CIAUpdateNode& aNode );
+
+
+ // Set the current node for the operation flow
+ void SetCurrentNodeL();
+
+
+ // Check if the operation has been successfully done for the given node.
+ // If aCheckSelfUpdate is ETrue, then also self updates are checked
+ // when install operation is going on. If aCheckSelfUpdate is EFlase,
+ // then check is always passed for self update installs. This is because
+ // self updates will be installed separately later. So, self updates can
+ // not be checked here in the middle of the install flow.
+ TBool CheckNode( const CIAUpdateNode& aNode,
+ TBool aCheckSelfUpdate ) const;
+
+
+private: // data
+
+ // All the nodes that will be handled by HandleContentL function
+ // during active loops. Does not own nodes.
+ RPointerArray< CIAUpdateNode > iNodes;
+
+ // The main node that is given when the operation is requested and started.
+ // Not owned.
+ CIAUpdateNode* iNode;
+
+ // The node that is currently handled with the operation.
+ // Not owned.
+ CIAUpdateNode* iCurrentNode;
+
+ // When operation is started, the observer is set.
+ // When operation finishes observer is informed and this variable
+ // is set to NULL.
+ // Not owned.
+ MIAUpdateContentOperationObserver* iObserver;
+
+ // Operation type informs what kind of operations should be created
+ // for the nodes when flow proceeds.
+ TContentOperationType iOperationType;
+
+ // Current operation.
+ // Owned.
+ MIAUpdateOperation* iOperation;
+
+ // Defines total maximum progress value for the operation.
+ TInt iTotalMaxProgress;
+
+ // Defines total progress value for the operation.
+ TInt iTotalProgress;
+
+ // Defines current maximum progress value for the operation.
+ TInt iCurrentMaxProgress;
+
+ // Defines progress value for the current operation.
+ TInt iCurrentProgress;
+
+ // This variable is used to count how many operations
+ // were successfull in the flow.
+ TInt iSuccessCount;
+
+ };
+
+#endif // IA_UPDATE_CONTENT_OPERATION_MANAGER_H
+