/*

* 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:   This file contains the header file of CIAUpdateNode class 

*

*/

#ifndef IA_UPDATE_NODE_IMPL_H

#define IA_UPDATE_NODE_IMPL_H

#include "iaupdatebasenodeimpl.h"

#include "iaupdatenode.h"

#include "iaupdatecontentoperationobserver.h"

class CIAUpdateNodeDependency;

/**

 *

 */

class CIAUpdateNode : public CIAUpdateBaseNode, 

                      public MIAUpdateNode,

                      public MIAUpdateContentOperationObserver

    {

public:

    /** 

     *

     */

    enum TDependencyCheckStatus

        {

        EDependencyCheckNotSet,

        EDependencyCheckGoing,

        EDependencyCheckPassed,

        EDependencyCheckFailed

        };

    /**

     * @see IAUpdateNodeFactory::CreateNodeLC

     **/

    static CIAUpdateNode* NewLC( MNcdNode* aNode,

                                 CIAUpdateController& aController );

    /**

     * @see CIAUpdateNode::NewLC

     **/

    static CIAUpdateNode* NewL( MNcdNode* aNode,

                                CIAUpdateController& aController );

    /**

     * Destructor

     **/

    virtual ~CIAUpdateNode();

public: // CIAUpdateBaseNode

    /**

     * @note This implementation also includes all OwnContentSizesL of 

     * the non-hidden nodes of the dependency tree.

     * @see CIAUpdateBaseNode::ContentSize

     */

    virtual TInt ContentSizeL() const;   

public: // MIAUpdateNode

    /**

     * @see MIAUpdateNode::Type

     **/

    virtual TPackageType Type() const;

    /**

     * This implementation always returns EFalse.

     * @see MIAUpdateNode::IsSelfUpdate

     */

    virtual TBool IsSelfUpdate() const;

    /**

     * @see MIAUpdateNode::GetDependenciesL

     **/

    virtual void GetDependenciesL( 

        RPointerArray< MIAUpdateNode >& aDependencies,

        TBool aIncludeHidden ) const;

    /**

     * @see MIAUpdateNode::GetDependantsL

     */

    virtual void GetDependantsL( 

        RPointerArray< MIAUpdateNode >& aDependants,

        TBool aIncludeHidden ) const;

    /**

     * @see MIAUpdateNode::IsDownloaded

     **/

    virtual TBool IsDownloaded() const;

    /**

     * @see MIAUpdateNode::IsInstalled

     **/

    virtual TBool IsInstalled() const;

    /**

     * @see MIAUpdateNode::DownloadL

     **/

    virtual void DownloadL( MIAUpdateNodeObserver& aObserver );

    /**

     * @see MIAUpdateNode::InstallL

     **/

    virtual void InstallL( MIAUpdateNodeObserver& aObserver );

    /**

     * @see MIAUpdateNode::CancelOperation

     **/    

    virtual void CancelOperation();

    /** 

     * @notice That this value has to be set by other objects. 

     * If it is not set, it returns zero.

     *

     * @see MIAUpdateNode::Depth

     */

    virtual TInt Depth() const;

    /**

     * @see MIAUpdateNode:::NodeType

     */

    virtual TNodeType NodeType() const;

    /**

     * @see MIAUpdateNode::Base

     */

    virtual MIAUpdateBaseNode& Base();

public: // MIAUpdateContentOperationObserver

    /**

     * @see MIAUpdateContentOperationObserver::ContentOperationComplete

     */

    virtual void ContentOperationComplete( CIAUpdateBaseNode& aNode, 

                                           TInt aError );

    /**

     * @see MIAUpdateContentOperationObserver::ContentOperationProgress

     */

    virtual void ContentOperationProgress( CIAUpdateBaseNode& aNode, 

                                           TInt aProgress, 

                                           TInt aMaxProgress );

public: // ** New functions

    /**

     * Can be used to reset variables that are set externally.

     * Variables such as depth and leaf distance and check status.

     */

    void Reset();

    /**

     * @return TBool ETrue if the node content has been purchased.

     * Else EFalse.

     */

    TBool IsPurchased() const;

    /**

     * This method provides means to add extra dependencies for this node.

     * If the dependency corresponding to the given node already exists, then the

     * old dependency is kept. If given dependency will create a loop, then nothing

     * is done.

     *

     * @note This function supposes that the dependency tree below aDependencyNode

     * is fullfilled and intact.

     *

     * @param aDependencyNode This node depends on aDependencyNode.

     * @param aAddDependency If ETrue, then dependency chain is

     * updated and the dependant depths are updated. If EFalse, then dependency

     * is not added but still dependant depths are updated. This can be usefull, 

     * if dependency chain should not be changed, but still the depths of the 

     * dependant items should know about some excess dependency nodes that may 

     * affect the operation flow order.

     */

    void SetExcessDependencyL( CIAUpdateNode& aDependencyNode,

                               TBool aAddDependency );

    /**

     * @see CIAUpdateNode::GetDependenciesL

     */

    void GetDependencyNodesL( 

        RPointerArray< CIAUpdateNode >& aDependencies,

        TBool aIncludeHidden ) const;

    /**

     * Sets the status that informs if the dependency chain check for this node and

     * all the nodes it depends on were passed or failed.

     *

     * @param aStatus

     */

    void SetDependencyCheckStatus( TDependencyCheckStatus aStatus );

    /**

     * @return TDependencyCheckStatus Dependency check status of this node and

     * all the nodes it depends on.

     */

    TDependencyCheckStatus DependencyCheckStatus() const;

    /**

     * @notice That this value has to be set by other objects. 

     * If it is not set, it returns zero. 

     *

     * @return TInt This value informs the distance of this node

     * from the furthest leaf node.

     */

    TInt LeafDistance() const;    

    /**

     * @param aDistance This value informs the distance of this node

     * from the furthest leaf node.

     */

    void SetLeafDistance( TInt aDistance );

    /**

     * @param aDepth This value informs the distance of this node from

     * the furthest root. Root has zero depth.

     */

    void SetDepth( TInt aDepth );

    /**

     * RPointerArray< CIAUpdateNode >& Reference to the dependant node array. 

     * Ownership is not transferred.

     */

    const RPointerArray< CIAUpdateNode >& DependantNodes() const;

    /**

     * Adds dependant node for this node. 

     * @param aDependantNode Dependant node

     */

    void AddDependantL( CIAUpdateNode& aDependantNode );

    /**

     * Updates the depths of the dependency nodes

     * starting from this node and then recursively

     * its dependencies.

     *

     * @note Depth is updated only if the new depth will be greater

     * than the old depth or if a negative value is given for refresh.

     *

     * @param aDepth The depth of this node.

     */

    void UpdateDependencyDepthsL( TInt aDepth );

protected:

    /**

     * @see CIAUpdateBaseNode::CIAUpdateBaseNode

     */

    CIAUpdateNode( CIAUpdateController& aController );

    /**

     * @see CIAUpdateBaseNode::ConstructL

     */    

    virtual void ConstructL( MNcdNode* aNode );

    /**

     * @see CIAUpdateNode::IsPurchased

     */

    virtual TBool IsPurchasedL() const;

    /**

     * @see CIAUpdateNode::IsDownloaded

     */

    virtual TBool IsDownloadedL() const;

    /**

     * @see CIAUpdateNode::IsInstalled

     */

    virtual TBool IsInstalledL() const;

    /**

     * @return MIAUpdateNodeObserver* Operation observer.

     * NULL if not set and then operation is not going on.

     * Ownership is not transferred.

     */

    MIAUpdateNodeObserver* OperationObserver() const;

private:

    // Prevent these if not implemented

    CIAUpdateNode( const CIAUpdateNode& aObject );

    CIAUpdateNode& operator =( const CIAUpdateNode& aObject );

    // Updates the leaf distances of the dependant nodes

    // starting from this node and then recursively

    // its dependants. aLeafDistance is the distance of 

    // this node from the furthest leaf node.

    void UpdateDependantLeafDistancesL( TInt aLeafDistance );

private: // data

    TDependencyCheckStatus              iDependencyCheckStatus;

    TInt                                iLeafDistance;

    TInt                                iDepth;

    // These arrays do not own the nodes.

    RPointerArray< CIAUpdateNode >      iDependants;

    RPointerArray< CIAUpdateNode >      iExcessDependencyNodes;

    // Not owned.

    MIAUpdateNodeObserver*              iOperationObserver;

    };

#endif  //  IA_UPDATE_NODE_IMPL_H