/*

* Copyright (c) 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:   ?Description

*

*/

#include <ncdnode.h>

#include <ncdnodeinstall.h>

#include "iaupdateservicepacknode.h"

#include "iaupdatecontrollerimpl.h"

#include "iaupdatecontentoperationmanager.h"

#include "iaupdatenodedetails.h"

#include "iaupdatenodedependencyimpl.h"

#include "iaupdatectrlnodeconsts.h"

#include "iaupdateutils.h"

#include "iaupdatedebug.h"

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

// CIAUpdateServicePackNode::NewLC

// 

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

//

CIAUpdateServicePackNode* CIAUpdateServicePackNode::NewLC( 

    MNcdNode* aNode,

    CIAUpdateController& aController )

    {

    CIAUpdateServicePackNode* self( 

        new( ELeave ) CIAUpdateServicePackNode( aController ) );

    CleanupStack::PushL( self );    

    self->ConstructL( aNode );

    return self;

    }

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

// CIAUpdateServicePackNode::NewL

// 

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

//    

CIAUpdateServicePackNode* CIAUpdateServicePackNode::NewL( 

    MNcdNode* aNode,

    CIAUpdateController& aController )

    {

    CIAUpdateServicePackNode* self(

        CIAUpdateServicePackNode::NewLC( aNode, aController ) );

    CleanupStack::Pop( self );

    return self;

    }

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

// CIAUpdateServicePackNode::CIAUpdateServicePackNode

// 

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

//

CIAUpdateServicePackNode::CIAUpdateServicePackNode( 

    CIAUpdateController& aController ) 

: CIAUpdateNode( aController )

    {

    }

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

// CIAUpdateServicePackNode::ConstructL

// 

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

//

void CIAUpdateServicePackNode::ConstructL( MNcdNode* aNode )

    {

    CIAUpdateNode::ConstructL( aNode );

    }

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

// CIAUpdateServicePackNode::~CIAUpdateServicePackNode

// 

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

//

CIAUpdateServicePackNode::~CIAUpdateServicePackNode()

    {

    }

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

// CIAUpdateServicePackNode::SetInstallStatusToPurchaseHistoryL

// 

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

//

void CIAUpdateServicePackNode::SetInstallStatusToPurchaseHistoryL( 

    TInt aErrorCode, TBool aForceVisibleInHistory )

    {

    IAUPDATE_TRACE_2("[IAUPDATE] CIAUpdateServicePackNode::SetInstallStatusToPurchaseHistoryL() begin: %d, %d",

                     aErrorCode, aForceVisibleInHistory);

    // Make sure that error code does not contain any base error value.

    TInt errorCode( 

        CIAUpdateContentOperationManager::CheckErrorCode( 

            aErrorCode ) );

    // Now update the error code with the correct base error value.

    // This base value will be used later to know that the last operation has been

    // install operation. This is service pack specific .

    errorCode += IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall;

    IAUPDATE_TRACE_1("[IAUPDATE] Error code: %d", errorCode);

    SetIdleErrorToPurchaseHistoryL( 

        errorCode, aForceVisibleInHistory );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateServicePackNode::SetInstallStatusToPurchaseHistoryL() end");

    }

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

// CIAUpdateServicePackNode::SetIdleErrorToPurchaseHistoryL

// 

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

//

void CIAUpdateServicePackNode::SetIdleErrorToPurchaseHistoryL( 

        TInt aError, TBool aForceVisibleInHistory )

    {

    IAUPDATE_TRACE_2("[IAUPDATE] CIAUpdateServicePackNode::SetIdleErrorToPurchaseHistoryL() begin: %d, %d",

                     aError, aForceVisibleInHistory);

    TInt newError( aError );

    TInt decodedError( 

        CIAUpdateContentOperationManager::CheckErrorCode( aError ) );

    // If aError already contains the base value, then the given value

    // can be directly saved into the purchase history.

    if ( newError == decodedError )

        {

        // Because error values were same, it means that aError did not contain

        // any base value. So, check if the base value should be included.

        // Get the last operation error code from the purchase history.

        TInt lastErrorCode( 

            LastUpdateErrorCodeFromPurchaseHistoryL() );

        // Get the decoded value of the error code.

        // So, it will not contain any base value.

        TInt decodedHistoryError(

            CIAUpdateContentOperationManager::CheckErrorCode( 

                lastErrorCode ) );

        // By subtracting the decoded error from the last purchase history error,

        // we get the error base value. Then, we can add the newly given error value

        // to the base value. Also, newly given error value is decoded before using it.

        newError =

            lastErrorCode - decodedHistoryError 

            + decodedError;

        }

    CIAUpdateNode::SetIdleErrorToPurchaseHistoryL(

        newError, aForceVisibleInHistory );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateServicePackNode::SetIdleErrorToPurchaseHistoryL() end");

    }

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

// CIAUpdateServicePackNode::Type

// 

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

//

MIAUpdateNode::TPackageType CIAUpdateServicePackNode::Type() const

    {

    return MIAUpdateNode::EPackageTypeServicePack;

    }

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

// CIAUpdateServicePackNode::IsPurchasedL

// 

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

//

TBool CIAUpdateServicePackNode::IsPurchasedL() const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateServicePackNode::IsPurchasedL()");

    // Notice, this function should not be called before dependency chains

    // are created.

    // Notice, that service pack itself is never purchased but its dependency

    // items are. Here we trust that the node dependency chains have already

    // been created. So, we use the dependency nodes to check if this

    // service pack can be thought as purchased. Also, this function trusts

    // that while dependency chains were created also loops were removed.

    TBool purchased( ETrue );

    RPointerArray< CIAUpdateNode > dependencies;

    CleanupClosePushL( dependencies );

    // Accept hidden and visible nodes here.

    // So, if IAD is shown in the UI but it depends on the hidden

    // self updater, the self updater is still included inside the

    // service pack.

    CIAUpdateContentOperationManager::GetOperationNodesL(

        *this, dependencies, ETrue, ETrue );

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

        {

        CIAUpdateNode& node( *dependencies[ i ] );

        // Notice, that if the dependency node is a service pack itself

        // then its dependencies are checked like its done in here.

        // Notice! Here we skip self update nodes because at the moment

        // IAD Engine does not support self updates inside service packs.

        // Self update nodes are always shown outside of service pack in 

        // the UI.

        // Because we have the whole hierarchy already in dependencies array,

        // do not call IsPurchased function for other sub service packs.

        if ( MIAUpdateNode::EPackageTypeServicePack != node.Type() 

             && !node.IsSelfUpdate()

             && !node.IsPurchased() )

            {

            IAUPDATE_TRACE("[IAUPDATE] Item not downloaded."); 

            // At least one dependency node was not purchased.

            // So, think service pack as not purchased also.

            purchased = EFalse;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &dependencies );    

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateServicePackNode::IsPurchasedL() end: %d",

                     purchased);

    return purchased;

    }

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

// CIAUpdateServicePackNode::IsDownloadedL

// 

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

//

TBool CIAUpdateServicePackNode::IsDownloadedL() const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateServicePackNode::IsDownloadedL() begin");

    // Notice, this function should not be called before dependency chains

    // are created.

    // Notice, that service pack itself is never downloaded but its dependency

    // items are. Here we trust that the node dependency chains have already

    // been created. So, we use the dependency nodes to check if this

    // service pack can be thought as downloaded. Also, this function trusts

    // that while dependency chains were created also loops were removed.

    TBool downloaded( ETrue );

    RPointerArray< CIAUpdateNode > dependencies;

    CleanupClosePushL( dependencies );

    // Accept hidden and visible nodes here.

    // So, if IAD is shown in the UI but it depends on the hidden

    // self updater, the self updater is still included inside the

    // service pack.

    CIAUpdateContentOperationManager::GetOperationNodesL(

        *this, dependencies, ETrue, ETrue );

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

        {

        CIAUpdateNode& node( *dependencies[ i ] );

        // Notice! Here we skip self update nodes because at the moment

        // IAD Engine does not support self updates inside service packs.

        // Self update nodes are always shown outside of service pack in 

        // the UI.

        // Because we have the whole hierarchy already in dependencies array,

        // do not call IsDownloaded function for other sub service packs.

        if ( MIAUpdateNode::EPackageTypeServicePack != node.Type() 

             && !node.IsSelfUpdate()

             && !node.IsDownloaded() )

            {

            IAUPDATE_TRACE("[IAUPDATE] Item not downloaded."); 

            // At least one dependency node was not downloaded.

            // So, think service pack as not downloaded also.

            downloaded = EFalse;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &dependencies );    

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateServicePackNode::IsDownloadedL() end: %d",

                     downloaded);

    return downloaded;

    }

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

// CIAUpdateServicePackNode::IsInstalledL

// 

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

//

TBool CIAUpdateServicePackNode::IsInstalledL() const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateServicePackNode::IsInstalledL() begin");

    // Notice, this function should not be called before dependency chains

    // are created.

    // Notice, that service pack itself is never installed but its dependency

    // items are. While operations are done, the state and the error code

    // will be updated for the service pack in purchase history.

    // With this implementation if the service pack is successfully installed

    // and after that some of its items are uninstalled, the service pack will

    // still be shown in the UI instead of the items.

    // Notice, that here we suppose that if some dependency node is uninstalled,

    // then all its dependants are also been uninstalled by the installer. Therefore,

    // this information will be known also in head service pack, when installation

    // status is checked. 

    // Notice, here we trust that while dependency chains were created also loops 

    // were removed.

    TBool installed( ETrue );

    RPointerArray< CIAUpdateNode > dependencies;

    CleanupClosePushL( dependencies );

    // Accept hidden and visible nodes here.

    // So, if IAD is shown in the UI but it depends on the hidden

    // self updater, the self updater is still included inside the

    // service pack.

    CIAUpdateContentOperationManager::GetOperationNodesL(

        *this, dependencies, ETrue, ETrue );

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

        {

        CIAUpdateNode& node( *dependencies[ i ] );

        // Because we have the whole hierarchy already in dependencies array,

        // do not call IsInstalled function for other sub service packs.

        if ( MIAUpdateNode::EPackageTypeServicePack != node.Type()

             && !node.IsSelfUpdate()

             && !node.IsInstalled() )

            {

            IAUPDATE_TRACE("[IAUPDATE] Item not installed."); 

            // If we come here at least one dependency node was not thougth as

            // installed. So, think service pack as not installed also.

            // Notice! Here we skip self update nodes because at the moment

            // IAD Engine does not support self updates inside service packs.

            // Self update nodes are always shown outside of service pack in 

            // the UI. So, if all the nodes inside service pack are self

            // updates, think service pack as installed. Then, seemingly empty

            // service pack itself will be left out of the UI but the

            // self update items would be anyways shown in the UI and they

            // are still available.

            // When service pack has an item that does not require self update,

            // it is not thought as empty any more.

            installed = EFalse;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &dependencies );

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateServicePackNode::IsInstalledL() end: %d",

                     installed);

    return installed;

    }