/*

* 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 

*                CIAUpdateController class member functions.

*

*/

// For the NCD Engine ECOM session closing.

#include <ecom/ecom.h>

#include <catalogsuids.h>

#include <catalogsutils.h>

#include <catalogsengine.h>

#include <ncdprovider.h>

#include <ncdutils.h>

#include <ncdconfigurationkeys.h>

#include <ncdcapabilities.h>

#include <ncdprogress.h>

#include <ncdnode.h>

#include <ncdnodecontainer.h>

#include <ncdconnectionmethod.h>

#include <ncdserverreportoperation.h>

#include <ncdserverreportmanager.h>

#include <ncdquery.h>

#include <ncdpurchasehistory.h>

#include <ncdutils.h>

#include <ncdprovideroptions.h>

#include <ncdoperation.h>

#include <ncddownloadoperation.h>

#include <ncderrors.h>

// Required for NCD debug logging.

#include <catalogsdebug.h>

#include "iaupdatecontrollerimpl.h"

#include "iaupdateloader.h"

#include "iaupdatenodecontainer.h"

#include "iaupdatenodefactory.h"

#include "iaupdatenodeimpl.h"

#include "iaupdatefwnodeimpl.h"

#include "iaupdateutils.h"

#include "iaupdatehistoryimpl.h"

#include "iaupdateenginexmlparser.h"

#include "iaupdateengineconfigdata.h"

#include "iaupdatectrlconsts.h"

#include "iaupdateprotocolconsts.h"

#include "iaupdatectrlfileconsts.h"

#include "iaupdateselfupdaterctrl.h"

#include "iaupdatecontentoperationmanager.h"

#include "iaupdatecachecleaner.h"

#include "iaupdatecontrollerfile.h"

#include "iaupdateridentifier.h"

#include "iaupdateerrorcodes.h"

#include "iaupdatetimer.h"

#include "iaupdatedebug.h"

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

// CIAUpdateController::NewLC

// Two-phased constructor.

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

// 

CIAUpdateController* CIAUpdateController::NewLC( 

    const TUid& aFamilyUid, 

    MIAUpdateControllerObserver& aObserver )

    {

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

    CIAUpdateController* self = 

        new( ELeave ) CIAUpdateController( aFamilyUid, aObserver );

    CleanupStack::PushL(self);

    self->ConstructL();

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

    return self;

    }

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

// CIAUpdateController::NewL

// Two-phased constructor.

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

//    

CIAUpdateController* CIAUpdateController::NewL( 

    const TUid& aFamilyUid, 

    MIAUpdateControllerObserver& aObserver )

    {

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

    CIAUpdateController* self = 

        CIAUpdateController::NewLC( aFamilyUid, aObserver );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CIAUpdateController::CIAUpdateController

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

// might leave.

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

//

CIAUpdateController::CIAUpdateController( 

    const TUid& aFamilyUid,

    MIAUpdateControllerObserver& aObserver ) 

: CActive( CActive::EPriorityStandard ),

  iFamilyUid( aFamilyUid ),

  iObserver( aObserver ),

  iControllerState( ENotRunning )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::CIAUpdateController() begin");

    // Required for NCD debug logging.

    DLINIT;

    CActiveScheduler::Add( this );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::CIAUpdateController() end");

    }

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

// CIAUpdateController::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIAUpdateController::ConstructL()

    {

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

    iEngine = CCatalogsEngine::NewL( *this );

    if ( !iEngine )

        {

        IAUPDATE_TRACE("[IAUPDATE] !iEngine");

        User::Leave( KErrNotFound );

        }

    iNodeContainer = CIAUpdateNodeContainer::NewL( *this );

    iSelfUpdaterCtrl = CIAUpdateSelfUpdaterCtrl::NewL( *this );

    iContentOperationManager = CIAUpdateContentOperationManager::NewL();

    // Notice, that this will read the data from the file 

    // and adjust variables from the file if the file exists.

    iCacheClearFile =

        CIAUpdateControllerFile::NewL( 

            IAUpdateCtrlFileConsts::KCacheClearFile );

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

    }    

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

// CIAUpdateController::~CIAUpdateController

// Destructor

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

//    

CIAUpdateController::~CIAUpdateController()

    {

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

    // This is always a good thing to do with active objects.

    Cancel();

    // Also cancel possible report operation.

    CancelReporting();

    delete iReportTimer;

    delete iContentOperationManager;

    delete iLoader;    

    delete iNodeContainer;

    delete iCacheCleaner;

    delete iCacheClearFile;

    // Before releasing engine, be sure to release or

    // delete all other objects that may contain connetions

    // to the engine.

    // History uses the services that are provided throught the provider.

    // So, delete history here before releasing the provider and closing

    // the engine.

    delete iHistory;

    // Do not delete the contents here.

    // This array does not own the content.

    iNodes.Reset();

    delete iSelfUpdaterCtrl;

    if ( iServerReportManager )

        {

        iServerReportManager->Release();

        }

    if ( iProvider )

        {

        iProvider->Release();

        }

    if ( iBaseProvider )

        {

        iBaseProvider->Release();

        }

    if ( iEngine )

        {

        iEngine->Close();

        delete iEngine;

        }    

    // Make sure that the NCD Engine ECOM session is closed. 

    // SKD help describes this:

    // Direct users of ECOM plugins must call this method when all 

    // implementations they have created have been destroyed and they 

    // are finished using ECOM e.g. library shutdown. It will garbage 

    // collect the last previously destroyed implementation and close 

    // the REComSession if no longer in use.

    REComSession::FinalClose();

    // Required for NCD debug logging.

    DLUNINIT;

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

    }

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

// CIAUpdateController::FamilyUid

//

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

//    

const TUid& CIAUpdateController::FamilyUid() const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::FamilyUid()");

    IAUPDATE_TRACE_1("[IAUPDATE] family uid: %x", iFamilyUid.iUid );

    return iFamilyUid;

    }

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

// CIAUpdateController::ProviderL

// 

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

//

MNcdProvider& CIAUpdateController::ProviderL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::ProviderL() begin");

    if ( !iProvider )

        {

        User::Leave( KErrNotFound );

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::ProviderL() end");

    return *iProvider;

    }

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

// CIAUpdateController::SelfUpdaterCtrl

// 

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

//

CIAUpdateSelfUpdaterCtrl& CIAUpdateController::SelfUpdaterCtrl()

    {

    return *iSelfUpdaterCtrl;

    }

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

// CIAUpdateController::ContentOperationManager

// 

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

//

CIAUpdateContentOperationManager& CIAUpdateController::ContentOperationManager()

    {

    return *iContentOperationManager;

    }

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

// CIAUpdateController::Startup

// 

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

//

TInt CIAUpdateController::Startup()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::Startup() begin");

    if ( iControllerState == EStarting )

        {

        IAUPDATE_TRACE("[IAUPDATE] Error code: KErrInUse");        

        return KErrInUse;

        }

    else if ( iControllerState != ENotRunning )

        {

        IAUPDATE_TRACE("[IAUPDATE] Error code: KErrAlreadyExists");

        return KErrAlreadyExists;

        }

    // Turn off the cache cleaner because we do not want it to remove any items

    // even if allowed db size is exceeded.

    // Make sure that IMEI is send in server requests.

    // Disable HEAD requests for optimization. With SISX content this is 

    // safe to do.

    TUint32 providerOptions( ENcdProviderDisableNodeCacheCleaner

                             | ENcdProviderSendImei

                             | ENcdProviderDisableHttpHeadRequest );

    TInt connectErr = iEngine->Connect( FamilyUid() );

    if ( connectErr != KErrNone )

        {

        return connectErr;

        }

    TRAPD ( err, 

            iEngine->CreateProviderL( KNcdProviderUid, 

                                      iBaseProvider, 

                                      iStatus, 

                                      providerOptions ) );

    IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", err );        

    if ( err != KErrNone )

        {

        return err;

        }

    SetActive();

    iControllerState = EStarting;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::Startup() end");

    return KErrNone;

    }

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

// CIAUpdateController::StartRefreshL

//

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

//

void CIAUpdateController::StartRefreshL( TBool aAllowNetConnection )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::StartRefreshL() begin");

    IAUPDATE_TRACE_2("[IAUPDATE] iControllerState %d allow net connection %d", iControllerState, aAllowNetConnection );

    if ( iControllerState == ENotRunning )

        {

        User::Leave( KErrNotReady );

        }

    else if ( iControllerState != EIdle )

        {

        User::Leave( KErrInUse );

        }

    if ( !iLoader )

        {

        IAUPDATE_TRACE("[IAUPDATE] Create loader");

        iLoader = CIAUpdateLoader::NewL( *iProvider, *this );

        // For optimization reasons, skip child count refreshes.

        iLoader->SetSkipChildCountRefresh( ETrue );       

        }

    // Reset the node list. New one will be created when this completes. 

    // Notice, that the array content is not owned by this array.

    iNodeContainer->Clear();

    iNodes.Reset();

    if ( aAllowNetConnection )

        {

        IAUPDATE_TRACE("[IAUPDATE] Net connection allowed");

        if ( iLoader->RootExpiredL() )

            {

            IAUPDATE_TRACE("[IAUPDATE] Root has expired");

            // Notice, that we will clean the cache only if the

            // root load is required. Otherwise, if cache was cleaned,

            // the root would be reloaded also. Then, unwanted

            // CDB connections would occur.

            // Update the data from the file just in case.

            // Actually the data was already read when the object

            // was created if the file exists. But, this way we

            // can be sure that the data matches the file even if

            // in some situation the write operation has failed

            // and the object data could not be synchronized into

            // the file.

            iCacheClearFile->ReadControllerDataL();

            TLanguage currentLanguage = User::Language();

            TLanguage lastTimeLanguage = iCacheClearFile->Language();

            TTime lastClearTime( iCacheClearFile->RefreshTime() );

            const TTimeIntervalDays KCacheClearInterval( 

                IAUpdateCtrlConsts::KCacheClearIntervalDays );

            TTime expireTime( lastClearTime + KCacheClearInterval );

            TTime universalTime;

            universalTime.UniversalTime();

            if ( currentLanguage != lastTimeLanguage

                 || expireTime < universalTime

                 || lastClearTime > universalTime  )

                {

                IAUPDATE_TRACE("[IAUPDATE] Clear cache");

                // Database is expired because languages do not match

                // or current time has passed the expiration time. 

                // Also, sanity check is made. If last refresh time is larger 

                // than current time, then the last refresh value has been set wrong, 

                // and the database can be thought as expired. This might be the case 

                // if the user has changed the time in the phone.

                // Before starting to load data from the net,

                // clear an old cache. This way files related to unfinished

                // updates will be deleted and there is no danger of them becoming

                // hanging data that can not be handled when old nodes are removed.

                if ( !iCacheCleaner )

                    {

                    iCacheCleaner = CIAUpdateCacheCleaner::NewL( *iProvider );

                    }

                iCacheCleaner->ClearL( iStatus );

                SetActive();

                iControllerState = EInClearCache;

                }

            }

        if ( iControllerState == EIdle )

            {

            IAUPDATE_TRACE("[IAUPDATE] Refresh directly from net");

            // Because controller state is still idle, we did not start

            // cache cleaning above.

            // There is no need to clean the cache here. 

            // So, skip that step and start loading directly.     

            // This starts an asynchronous operation which will end

            // when callback is called.

            iLoader->LoadNodesL();

            iControllerState = EInLoadOperation;

            }

        }

    else

        {

        IAUPDATE_TRACE("[IAUPDATE] Start local refresh");

        // Load should be done locally.

        // So, just delegate the thing to the RunL which will handle

        // the local getting of the data in a next asynchronous step.

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* ptrStatus = &iStatus;

        User::RequestComplete( ptrStatus, KErrNone );

        iControllerState = EInLocalLoadOperation;

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::StartRefreshL() end");    

    }

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

// CIAUpdateController::CancelRefresh

//

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

//

void CIAUpdateController::CancelRefresh()

    {

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateController::CancelRefresh() begin: %d",

                     iControllerState);

    switch ( iControllerState )

        {

        case EInClearCache:

            // Cache cleaner is responsible of this operation.

            iCacheCleaner->Cancel();

            break;

        case EInLoadOperation:

            // Loader is responsible of this operation.

            iLoader->Cancel();

            break;

        case EInLocalLoadOperation:

            // Use the normal cancellation of this active class because 

            // these operations are handled by this active object itself.

            Cancel();

            break;

        default:

            break;

        }

    // New state should be idle.

    iControllerState = EIdle;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::CancelRefresh() end");

    }

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

// CIAUpdateController::CancelReporting

//

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

//

void CIAUpdateController::CancelReporting()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateController::CancelReport() begin");

    // Because report operation is cancelled, no need for the timer

    // anymore. So, delete timer if it exists. Deletion will automatically

    // cancel the timer operation. The timer may be started for some special

    // cases even if report operation was not created. So, try to delete it

    // here just in case.

    delete iReportTimer;

    iReportTimer = NULL;

    if ( iReportOperation )

        {

        // Set this for the callback because operation call operation complete

        // when the operation is cancelled. We do not want to call ui callback there.

        iCancellingReportOperation = ETrue;