/*

* 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