/*
* 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