/*

* 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 

*

*/

#include <ncdpurchasedetails.h>

#include "iaupdatecontentoperationmanager.h"

#include "iaupdatenodeimpl.h"

#include "iaupdateoperation.h"

#include "iaupdatepurchaseoperation.h"

#include "iaupdatedownloadoperation.h"

#include "iaupdateinstalloperation.h"

#include "iaupdateselfupdateinitoperation.h"

#include "iaupdatectrlnodeconsts.h"

#include "iaupdatenodefactory.h"

#include "iaupdatedebug.h"

// Const value for the progress init value.

const TInt KInitProgress( 0 );

// This is a static function that is used with RPointerArray::Sort to sort

// the nodes according to their node depths.

TInt NodeArraySorter( const CIAUpdateNode& aNode1, const CIAUpdateNode& aNode2 )

    {

    // The leaf should be in the end of the array and the root in the beginning.

    // The depth value informs how deep in the hierarchy the node is. A depth

    // value zero means that the node is a root. If multiple branches lead to

    // a same node, then the greatest depth value is used for the node.

    return ( aNode1.Depth() - aNode2.Depth() );

    }

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

// CIAUpdateContentOperationManager::::NewL

// 

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

// 

CIAUpdateContentOperationManager* CIAUpdateContentOperationManager::NewL()

    {

    CIAUpdateContentOperationManager* self = 

        CIAUpdateContentOperationManager::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CIAUpdateContentOperationManager::::NewLC

// 

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

// 

CIAUpdateContentOperationManager* CIAUpdateContentOperationManager::NewLC()

    {

    CIAUpdateContentOperationManager* self =

        new( ELeave ) CIAUpdateContentOperationManager();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CIAUpdateContentOperationManager::CIAUpdateContentOperationManager

// 

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

// 

CIAUpdateContentOperationManager::CIAUpdateContentOperationManager()

: CActive( CActive::EPriorityStandard )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::CIAUpdateContentOperationManager");

    }

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

// CIAUpdateContentOperationManager::ConstructL

// 

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

// 

void CIAUpdateContentOperationManager::ConstructL()

    {

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

    CActiveScheduler::Add( this );

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

    }

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

// CIAUpdateContentOperationManager::~CIAUpdateContentOperationManager

// 

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

// 

CIAUpdateContentOperationManager::~CIAUpdateContentOperationManager()

    {

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

    // It is always good to call this in active object destructor 

    // to be sure that no operations are left hanging. 

    // This will also reset and delete all the necessary data if needed.

    Cancel();

    // Reset the array to be sure.

    // If the operation has left during startup, the array may not be reseted.

    iNodes.Reset();

    // Delete operation to make sure that it is also deleted.

    delete iOperation;

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

    }

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

// CIAUpdateContentOperationManager::CheckErrorCode

// 

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

// 

TInt CIAUpdateContentOperationManager::CheckErrorCode( TInt aError )

    {

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateContentOperationManager::CheckErrorCode begin: %d",

                     aError);

    if ( aError > ( IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall 

                    - IAUpdateCtrlNodeConsts::KErrBaseRange ) 

         && aError <= IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall )

        {

        IAUPDATE_TRACE("[IAUPDATE] Service pack install");

        aError -= IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall;

        }

    else if ( aError > IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall 

              && aError <= IAUpdateCtrlNodeConsts::KErrBaseServicePackDownload )

        {

        IAUPDATE_TRACE("[IAUPDATE] Service pack download");

        aError -= IAUpdateCtrlNodeConsts::KErrBaseServicePackDownload;

        }

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateContentOperationManager::CheckErrorCode end: %d",

                     aError);

    return aError;

    }

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

// CIAUpdateContentOperationManager::CheckErrorCode

// 

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

// 

CIAUpdateContentOperationManager::TContentOperationType 

    CIAUpdateContentOperationManager::ServicePackOperationType( 

        MNcdPurchaseDetails& aNodeDetails )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::CheckErrorCode begin");

    if ( !IAUpdateNodeFactory::IsServicePack( 

            aNodeDetails.AttributeString( 

                MNcdPurchaseDetails::EPurchaseAttributeContentMimeType ) ) )

        {

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::CheckErrorCode end: ENoContentOperation");

        return ENoContentOperation;

        }

    TContentOperationType type( EPurchaseOperation );

    TInt errorCode( aNodeDetails.LastOperationErrorCode() );

    if ( errorCode > ( IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall 

                       - IAUpdateCtrlNodeConsts::KErrBaseRange ) 

         && errorCode <= IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall )

        {

        IAUPDATE_TRACE("[IAUPDATE] Service pack install");

        type = EInstallOperation;

        }

    else if ( errorCode > IAUpdateCtrlNodeConsts::KErrBaseServicePackInstall 

              && errorCode <= IAUpdateCtrlNodeConsts::KErrBaseServicePackDownload )

        {

        IAUPDATE_TRACE("[IAUPDATE] Service pack download");

        type = EDownloadOperation;

        }

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateContentOperationManager::CheckErrorCode end: %d",

                     type);

    return type;     

    }

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

// CIAUpdateContentOperationManager::SortNodeArray

// 

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

// 

void CIAUpdateContentOperationManager::SortNodeArray( 

    RPointerArray< CIAUpdateNode >& aNodes )

    {

    // Use that static function to sort the array.

    aNodes.Sort( TLinearOrder< CIAUpdateNode >( &NodeArraySorter ) );

    }

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

// CIAUpdateContentOperationManager::GetOperationNodesL

// 

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

// 

void CIAUpdateContentOperationManager::GetOperationNodesL( 

    const CIAUpdateNode& aNode, RPointerArray< CIAUpdateNode >& aNodes,

    TBool aAcceptHiddenDependencyNodes, TBool aAcceptVisibleDependencyNodes )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::CreateOperationNodeArrayL() begin");

    // Reset the array.

    // So, new nodes can be inserted into it.

    aNodes.Reset();

    // We need to get the array of the nodes that this node depends on.

    // Notice, that here we just want the specific type of nodes that belong 

    // to this node. If another dependency node does not match the criteria then 

    // ignore that branch starting from that node.

    HandleDependenciesL( aNode, aNodes,

                         aAcceptHiddenDependencyNodes, 

                         aAcceptVisibleDependencyNodes );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::CreateOperationNodeArrayL() end");

    }

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

// CIAUpdateContentOperationManager::TotalContentSizeL

// 

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

//     

TInt CIAUpdateContentOperationManager::TotalContentSizeL( 

    const CIAUpdateNode& aNode,

    TBool aIncludeDownloaded,

    TBool aIncludeInstalled,

    TBool aAcceptHiddenDependencyNodes,

    TBool aAcceptVisibleDependencyNodes )

    {

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

    RPointerArray< CIAUpdateNode > nodes;

    CleanupClosePushL( nodes );

    GetOperationNodesL( 

        aNode, nodes,

        aAcceptHiddenDependencyNodes, 

        aAcceptVisibleDependencyNodes );

    TInt totalContentSize( 

        ArrayTotalContentSizeL( 

            nodes, aIncludeDownloaded, aIncludeInstalled ) );

    CleanupStack::PopAndDestroy( &nodes );

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

                     totalContentSize);

    return totalContentSize;

    }

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

// CIAUpdateContentOperationManager::StartL

// 

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

//     

void CIAUpdateContentOperationManager::StartL( 

    MIAUpdateContentOperationObserver& aObserver,

    const CIAUpdateContentOperationManager::TContentOperationType& aOperationType,

    CIAUpdateNode& aNode )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::StartL begin");

    if ( iOperation || IsActive() )

        {

        IAUPDATE_TRACE("[IAUPDATE] ERROR Operation already existed");

        User::Leave( KErrInUse );

        }

    else if ( aNode.Hidden()  )

        {

        // The main node is not allowed to be hidden.

        IAUPDATE_TRACE("[IAUPDATE] ERROR: Hidden node given");

        User::Leave( KErrArgument );

        }

    else if ( aOperationType != EPurchaseOperation

              && aOperationType != EDownloadOperation

              && aOperationType != EInstallOperation )

        {

        // The main node is not allowed to be hidden.

        IAUPDATE_TRACE("[IAUPDATE] ERROR Operation type not supported");

        User::Leave( KErrNotSupported );

        }

    // Reset member variables

    iSuccessCount = 0;

    // Set progress values to defaults.

    ResetProgress();

    // Notice, that this will also set the main node.

    SetNodeArrayL( aNode );

    // Progress values were resetted above.

    // Now, set the expected total maximum value for the progress.

    InitTotalMaxProgressL( aOperationType );

    // Set the observer

    iObserver = &aObserver;

    // Set the operation type

    iOperationType = aOperationType;

    // Start the operation by calling the first round for active loop.

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* ptrStatus = &iStatus;

    User::RequestComplete( ptrStatus, KErrNone );                

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::StartL end");

    }

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

// CIAUpdateContentOperationManager::OperationType

// 

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

// 

const CIAUpdateContentOperationManager::TContentOperationType& 

    CIAUpdateContentOperationManager::OperationType() const

    {

    return iOperationType;

    }

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

// CIAUpdateContentOperationManager::ContentOperationComplete

// 

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

//

void CIAUpdateContentOperationManager::ContentOperationComplete( 

    CIAUpdateBaseNode& /*aNode*/,

    TInt aError )

    {

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

    // Content operation has completed.

    // In normal cases, start new active loop. So, RunL will be called.

    // Notice, that if Cancel was called, this callback function is called from the

    // operation when its cancel is synchronously completed. Because Cancel is waiting 

    // for DoCancel function to complete the request, let it complete here. So, 

    // actual cancel can finish its job. We do not want to call callbacks of the observer 

    // of this operation manager after Cancel.

    if ( aError == KErrNone )

        {

        ++iSuccessCount;

        IAUPDATE_TRACE_1("[IAUPDATE] Successfull operation: %d",

                         iSuccessCount); 

        // Check that the node MIME is set correctly.

        // Then, the history will be shown also correctly for the nodes.

        // By updating the purchase history, also the correct MIME type

        // is set, for example, if node is hidden.

        IAUPDATE_TRACE("[IAUPDATE] Update purchase history for current node.");

        UpdatePurchaseHistory( *iCurrentNode, aError );

        }

    TRequestStatus* ptrStatus = &iStatus;

    User::RequestComplete( ptrStatus, aError );

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

    }

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

// CIAUpdateContentOperationManager::ContentOperationProgress

// 

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

//

void CIAUpdateContentOperationManager::ContentOperationProgress( 

    CIAUpdateBaseNode& /*aNode*/, 

    TInt aProgress, 

    TInt aMaxProgress )

    {

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

    UpdateProgress( aProgress, aMaxProgress );

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

    }

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

// CIAUpdateContentOperationManager::DoCancel

// 

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

// 

void CIAUpdateContentOperationManager::DoCancel()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::DoCancel() begin");

    // If we are here, then there should always be an operation going on.

    // Notice, that if disclaimers are shown, for example,

    // when installing, then the KErrCancel can be gotten from

    // the operation even if the cancellation was not started from here.

    // But, then the RunL is called and the operation is finished correctly.

    // But, if cancellation is started here, the RunL is not called and the 

    // cancellation proceedes correctly. Instead then, operations call directly

    // ContentOperationComplete callback function that completes the request that

    // active object Cancel is listening to complete its actions.

    // Cancel the current operation by deleting it.

    delete iOperation;

    iOperation = NULL;

    // No need for the observer anymore.

    iObserver = NULL;

    // Because, the main node is the one that is visible, its error code

    // needs to be updated here separately. Also, the current node needs

    // to be updated. So, set them by hand. If other nodes were not operated,

    // no need to update their info to purchase history because they should

    // not be shown in the history view anyways.

    // Notice, that even if the operations may have updated the purchase history

    // by themselves in NCD Engine side, the purchase history MIME type may

    // need to be updated according to the IAD node values. So, that is why

    // we update the purchase history here one more time.

    // Notice, that in case of service packs and other service packs 

    // inside them, also then just set the purchase history for the head

    // service pack.

    if ( iNode != iCurrentNode )

        {

        IAUPDATE_TRACE("[IAUPDATE] Update current node purchase history with KErrCancel");

        UpdatePurchaseHistory( *iCurrentNode, KErrCancel );

        }

    IAUPDATE_TRACE("[IAUPDATE] Update head node purchase history with KErrCancel");

    UpdatePurchaseHistory( *iNode, KErrCancel );

    // No need for nodes

    iNodes.Reset();

    iNode = NULL;

    iCurrentNode = NULL;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::DoCancel() end");

    }

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

// CIAUpdateContentOperationManager::RunL

// 

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

//     

void CIAUpdateContentOperationManager::RunL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperationManager::RunL() begin");

    // Reset progress for current operation.

    ResetCurrentProgress();

    // Delete old operation.

    // Later a new and correct type of operation will be created for

    // the new node if one is found.

    delete iOperation;

    iOperation = NULL;

    // When the operation flow is started, the error code is always KErrNone.    

    // We only get errors to status if content operation is going on.

    User::LeaveIfError( iStatus.Int() );

    // Handle the next content in the array.

    if ( iNodes.Count() > 0 )

        {

        // Handle next node.

        SetCurrentNodeL();

        if ( IsServicePack( *iNode ) 

             && iCurrentNode->IsSelfUpdate() )

            {

            // Because operation was created, it means that the self update inside

            // the service pack is not installed yet. Because we do not support

            // self updates inside service packs, leave from here.

            // Note for future improvements: 

            // If service packs support for self update is added, remove

            // the if clause and always append nodes.

            // Also, remember to update CIAUpdateServicePackNode::IsSelfUpdate 

            // function if UI side should know about the self updates inside

            // the service pack. Then, most likely service pack should be thought 

            // as self update if any of the items gotten in the dependency hierarchy

            // is a self update.

            IAUPDATE_TRACE("[IAUPDATE] Service pack does not support self updates");

            User::Leave( KErrNotSupported );

            }

        // Notice, that in case of service packs, the operation is not created.

        // Skip, service pack items themself and only handle operations for 

        // their dependencies.

        TBool operationStarted( EFalse );      

        iOperation = CreateOperationL( iOperationType, *iCurrentNode );

        if ( iOperation )

            {

            IAUPDATE_TRACE("[IAUPDATE] Operation existed");