/*

* Copyright (c) 2007-2009 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:   This module contains the implementation of CIAUpdateNode class 

*                member functions.

*

*/

#include <ncdnode.h>

#include <ncdnodepurchase.h>

#include <ncdnodedownload.h>

#include <ncdnodeinstall.h>

#include <ncdnodecontentinfo.h>

#include "iaupdatenodeimpl.h"

#include "iaupdatenodeobserver.h"

#include "iaupdatenodedependencyimpl.h"

#include "iaupdatenodedetails.h"

#include "iaupdatecontrollerimpl.h"

#include "iaupdateutils.h"

#include "iaupdatecontentoperationmanager.h"

#include "iaupdateprotocolconsts.h"

#include "iaupdatedebug.h"

// -----------------------------------------------------------------------------

// CIAUpdateNode::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

// 

CIAUpdateNode* CIAUpdateNode::NewLC( MNcdNode* aNode,

                                     CIAUpdateController& aController )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::NewLC() begin");

    CIAUpdateNode* self = 

        new( ELeave ) CIAUpdateNode( aController );

    CleanupStack::PushL( self );    

    self->ConstructL( aNode );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::NewLC() end");

    return self;

    }

// -----------------------------------------------------------------------------

// CIAUpdateNode::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//     

CIAUpdateNode* CIAUpdateNode::NewL( MNcdNode* aNode,

                                    CIAUpdateController& aController )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::NewL() begin");

    CIAUpdateNode* self = 

        CIAUpdateNode::NewLC( aNode, aController );

    CleanupStack::Pop( self );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::NewL() end");

    return self;

    }

// -----------------------------------------------------------------------------

// CIAUpdateNode::CIAUpdateNode

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CIAUpdateNode::CIAUpdateNode( CIAUpdateController& aController ) 

: CIAUpdateBaseNode( aController )

    {

    }

// -----------------------------------------------------------------------------

// CIAUpdateNode::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CIAUpdateNode::ConstructL( MNcdNode* aNode )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::ConstructL() begin");

    // Let the parent handle it all.

    CIAUpdateBaseNode::ConstructL( aNode );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::ConstructL() end");

    }

// -----------------------------------------------------------------------------

// CIAUpdateNode::~CIAUpdateNode

// Destructor

// -----------------------------------------------------------------------------

//    

CIAUpdateNode::~CIAUpdateNode()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::~CIAUpdateNode() begin");

    iDependants.Reset();

    iExcessDependencyNodes.Reset();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::~CIAUpdateNode() end");

    }

// ---------------------------------------------------------------------------

// CIAUpdateBaseNode overloaded functions

// 

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// CIAUpdateNode::ContentSizeL

// 

// ---------------------------------------------------------------------------

//

TInt CIAUpdateNode::ContentSizeL() const

    {

    // Notice, here we give the total content size through the interface.

    // Here we want only the dependency nodes that are hidden.

    // Skip visible dependencies because those nodes are visible in UI

    // and their content size is separately shown and calculated in UI.

    return 

        Controller().

            ContentOperationManager().

                TotalContentSizeL( *this, ETrue, EFalse, ETrue, EFalse );        

    }

// ---------------------------------------------------------------------------

// MIAUpdateNode functions

// 

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// CIAUpdateNode::Type

// 

// ---------------------------------------------------------------------------

//    

MIAUpdateNode::TPackageType CIAUpdateNode::Type() const

    {

    MIAUpdateNode::TPackageType packageType;

    if ( Mime().Compare( IAUpdateProtocolConsts::KMimeWidget ) == 0 )

        {

        packageType = MIAUpdateNode::EPackageTypeWidget;

        }

    else

        {

        packageType = Details().ContentType();

        }

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateNode::Type() = %d", 

                             packageType );

    return packageType;

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::IsSelfUpdate

// 

// ---------------------------------------------------------------------------

//

TBool CIAUpdateNode::IsSelfUpdate() const    

    {

    return EFalse;

    }        

// ---------------------------------------------------------------------------

// CIAUpdateNode::GetDependenciesL

// 

// ---------------------------------------------------------------------------

//       

void CIAUpdateNode::GetDependenciesL( 

    RPointerArray< MIAUpdateNode >& aDependencies,

    TBool aIncludeHidden ) const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::GetDependenciesL() begin");

    RPointerArray< CIAUpdateNode > dependencies;

    CleanupClosePushL( dependencies );

    GetDependencyNodesL( dependencies, aIncludeHidden );

    aDependencies.ReserveL( dependencies.Count() );    

    for ( TInt i = 0; i < dependencies.Count(); ++i )

        {

        aDependencies.AppendL( dependencies[ i ] );

        }

    CleanupStack::PopAndDestroy( &dependencies );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::GetDependenciesL() end");

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::GetDependantsL

// 

// ---------------------------------------------------------------------------

//    

void CIAUpdateNode::GetDependantsL( 

    RPointerArray< MIAUpdateNode >& aDependants,

    TBool aIncludeHidden ) const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::GetDependantsL() begin");

    aDependants.Reserve( iDependants.Count() );

    for( TInt i = 0; i < iDependants.Count(); ++i )

        {

        CIAUpdateNode* dependant( iDependants[ i ] );

        if ( aIncludeHidden 

             || !dependant->Hidden() )

            {

            aDependants.AppendL( iDependants[ i ] );

            }

        } 

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::GetDependantsL() end"); 	

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::IsDownloaded

// 

// ---------------------------------------------------------------------------

//

TBool CIAUpdateNode::IsDownloaded() const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::IsDownloaded() begin");

    TBool downloaded( EFalse );

    TRAP_IGNORE ( downloaded = IsDownloadedL() );

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateNode::IsDownloaded() end: %d",

                     downloaded);

    return downloaded;

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::IsInstalled

// 

// ---------------------------------------------------------------------------

//

TBool CIAUpdateNode::IsInstalled() const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::IsInstalled() begin");

    TBool installed( EFalse );

    TRAP_IGNORE ( installed = IsInstalledL() );

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateNode::IsInstalled() end: %d",

                     installed);

    return installed;

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::DownloadL

// 

// ---------------------------------------------------------------------------

//

void CIAUpdateNode::DownloadL( MIAUpdateNodeObserver& aObserver )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::DownloadL() begin");

    if( iOperationObserver )

        {

        User::Leave( KErrInUse );

        }

    // Instead of starting download operation here, we start purchase operation.

    // Purchase needs to be done before download. When purchase compeletes,

    // the call back function is called and that will start download operation.

    // Notice, that we can try to create the purchase even if it has already been

    // done. Then, the operation just finishes without repurchasing.

    // Use content operation manager.

    // It can handle the possible hidden node chain that requires operations 

    // for multiple nodes.

    Controller().

        ContentOperationManager().

            StartL( *this, 

                    CIAUpdateContentOperationManager::EPurchaseOperation, 

                    *this );

    iOperationObserver = &aObserver;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::DownloadL() end");

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::InstallL

// 

// ---------------------------------------------------------------------------

//

void CIAUpdateNode::InstallL( MIAUpdateNodeObserver& aObserver )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::InstallL() begin");

    if( iOperationObserver )

        {

        User::Leave( KErrInUse );

        }

    // Use content operation manager.

    // It can handle the possible hidden node chain that requires operations 

    // for multiple nodes.

    Controller().

        ContentOperationManager().

            StartL( *this, 

                    CIAUpdateContentOperationManager::EInstallOperation, 

                    *this );

    iOperationObserver = &aObserver;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::InstallL() end");

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::CancelOperation()

// 

// ---------------------------------------------------------------------------

//

void CIAUpdateNode::CancelOperation()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::CancelOperation() begin");

    // This will cancel the possible ongoing operation

    Controller().ContentOperationManager().Cancel();

    // Also, set the observer to NULL.

    // Because this value is used to check if operations are going on.

    iOperationObserver = NULL;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::CancelOperation() end");

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::Depth()

// 

// ---------------------------------------------------------------------------

//

TInt CIAUpdateNode::Depth() const

    {

    return iDepth;

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::NodeType

// 

// ---------------------------------------------------------------------------

//

MIAUpdateAnyNode::TNodeType CIAUpdateNode::NodeType() const

    {

    return MIAUpdateAnyNode::ENodeTypeNormal;

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::Base

// 

// ---------------------------------------------------------------------------

//

MIAUpdateBaseNode& CIAUpdateNode::Base()

    {

    return *this;   

    }

// ---------------------------------------------------------------------------

// MIAUpdateContentOperationObserver functions

// 

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// CIAUpdateNode::ContentOperationCompleteL

// 

// ---------------------------------------------------------------------------

//

void CIAUpdateNode::ContentOperationComplete( CIAUpdateBaseNode& /*aNode*/, 

                                              TInt aError )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::ContentOperationComplete() begin");

    // Get the observer to a temporary pointer. So, we can use it 

    // when informing observers. The member variable needs to be set to NULL

    // before callbacks are called.

    MIAUpdateNodeObserver* tmpObserver( iOperationObserver );

    const CIAUpdateContentOperationManager::TContentOperationType& operationType(

        Controller().ContentOperationManager().OperationType() );

    if ( operationType == CIAUpdateContentOperationManager::EPurchaseOperation )

        {

        IAUPDATE_TRACE_1("[IAUPDATE] Purchase operation complete: %d", aError);

        if ( aError == KErrNone )

            {

            // Purchase operation was successfull.

            // So, now try to download the actual content.

            TRAPD ( trapError, 

                    Controller().

                        ContentOperationManager().

                            StartL( *this, 

                                    CIAUpdateContentOperationManager::EDownloadOperation, 

                                    *this ); );

            IAUPDATE_TRACE_1("[IAUPDATE] download trap error code: %d", trapError );

            if ( trapError != KErrNone )

                {

                IAUPDATE_TRACE("[IAUPDATE] Could not create download operation.");

                // Something went wrong when initializing download operation.

                iOperationObserver = NULL;

                // Inform observer about the completion of operation.

                tmpObserver->DownloadComplete( *this, trapError );

                }            

            }

        else

            {

            IAUPDATE_TRACE("[IAUPDATE] Purchase was not success. Complete download.");

            // Operation was not successfull.

            // There is no reason to continue.

            // Inform observer about the completion of operation.

            iOperationObserver = NULL;

            tmpObserver->DownloadComplete( *this, aError );

            }

        }

    else if ( operationType == CIAUpdateContentOperationManager::EDownloadOperation )

        {

        IAUPDATE_TRACE("[IAUPDATE] Download operation complete");

        iOperationObserver = NULL;

        // Inform observer about the completion of operation.

        tmpObserver->DownloadComplete( *this, aError );

        }

    else if ( operationType == CIAUpdateContentOperationManager::EInstallOperation )

        {

        IAUPDATE_TRACE("[IAUPDATE] Install operation complete");

        iOperationObserver = NULL;

        // Inform observers about the completion of operation.

        tmpObserver->InstallComplete( *this, aError );        

        }

    else

        {

        // We should never come here.

        IAUPDATE_TRACE("[IAUPDATE] ERROR No operation was going on even if callback called");        

        iOperationObserver = NULL;

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::ContentOperationComplete() end");

    }

// ---------------------------------------------------------------------------

// CIAUpdateNode::ContentOperationProgress

// 

// ---------------------------------------------------------------------------

// 

void CIAUpdateNode::ContentOperationProgress( CIAUpdateBaseNode& /*aNode*/, 

                                              TInt aProgress, 

                                              TInt aMaxProgress )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::ContentOperationProgress() begin");

    // Inform the observer about the progress of download and install.

    // There is no need to inform about the purchase progress.

    switch( Controller().ContentOperationManager().OperationType() )

        {

        case CIAUpdateContentOperationManager::EDownloadOperation:

            IAUPDATE_TRACE("[IAUPDATE] Download operation progress");

            iOperationObserver->

                DownloadProgress( *this, aProgress, aMaxProgress );

            break;

        case CIAUpdateContentOperationManager::EInstallOperation:

            IAUPDATE_TRACE("[IAUPDATE] Install operation progress");

            iOperationObserver->

                InstallProgress( *this, aProgress, aMaxProgress );

            break;

        default:

            IAUPDATE_TRACE_1("[IAUPDATE] Do not inform observer: %d",

                             Controller().

                                ContentOperationManager().

                                    OperationType());

            break;

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNode::ContentOperationProgress() end");

    }

// ---------------------------------------------------------------------------

// Public functions

// 

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// CIAUpdateNode::Reset

// 

// ---------------------------------------------------------------------------

//

void CIAUpdateNode::Reset()

    {

    SetDependencyCheckStatus( 

        CIAUpdateNode::EDependencyCheckNotSet );