/*

 * Copyright (c) 2009-2010 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 IAUpdateEngine

 *                class member functions.

 *

 */

#include <qapplication.h>

#include <hbmessagebox.h>

#include <hbaction.h>

#include <eikenv.h>

#include <centralrepository.h>

#include <cmmanager.h>

#include <cmdestination.h>

#include <rconnmon.h>

#include <apgwgnam.h>

#include <starterclient.h>

#include "iaupdateengine.h"

#include "iaupdateserviceprovider.h"

#include "iaupdateuicontroller.h"

#include "iaupdatefwupdatehandler.h"

#include "iaupdategloballockhandler.h"

#include "iaupdatenodefilter.h"

#include "iaupdateresult.h"

#include "iaupdateprivatecrkeys.h"

#include "iaupdateuiconfigdata.h"

#include "iaupdatequeryhistory.h"

#include "iaupdateparameters.h"

#include "iaupdateagreement.h"

#include "iaupdateautomaticcheck.h"

#include "iaupdateresultsdialog.h"

#include "iaupdatedebug.h"

IAUpdateEngine::IAUpdateEngine(QObject *parent) :

    QObject(parent)

    {

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

    iController = NULL;

    iFwUpdateHandler = NULL;

    iGlobalLockHandler = NULL;

    iAutomaticCheck = NULL;

    iIdle = NULL;

    iIdleAutCheck = NULL;

    iEikEnv = CEikonEnv::Static();

    mUpdateNow = false;

    mRequestIssued = false;

    mStartedFromApplication = false;

    mUiRefreshAllowed = true;

    mWgId = 0;

    mUpdatequeryUid = 0;

    mDialogState = NoDialog;

    mResultsDialog = NULL;

    mServiceProvider = NULL;

    mServiceProvider = new IAUpdateServiceProvider(*this);

    connect(mServiceProvider, SIGNAL(clientDisconnected()), this,

            SLOT(handleAllClientsClosed()));

    TRAP_IGNORE( iController = CIAUpdateUiController::NewL( *this ));

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

    }

IAUpdateEngine::~IAUpdateEngine()

    {

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

    InformRequestObserver(KErrCancel);

    if (iIdle)

        {

        delete iIdle;

        }

    if (iIdleAutCheck)

        {

        delete iIdleAutCheck;

        }

    if (iGlobalLockHandler)

        {

        delete iGlobalLockHandler;

        }

    if (iAutomaticCheck)

        {

        delete iAutomaticCheck;

        }

    if (iController)

        {

        delete iController;

        }

    if (iFwUpdateHandler)

        {

        delete iFwUpdateHandler;

        }

    if (mServiceProvider)

        {

        delete mServiceProvider;

        }

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

    }

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

// IAUpdateEngine::StartedByLauncherL

// 

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

//

void IAUpdateEngine::StartedByLauncherL(bool aRefreshFromNetworkDenied)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartedByLauncherL() begin");

    mRequestIssued = true;

    mRequestType = IAUpdateUiDefines::ENoRequest;

    iController->SetRequestType(mRequestType);

    SetVisibleL(true);

    CIAUpdateParameters* params = iController->ParamsReadAndRemoveFileL();

    iController->CheckUpdatesDeferredL(params, aRefreshFromNetworkDenied);

    }

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

// IAUpdateEngine::CheckUpdatesRequestL

// 

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

//

void IAUpdateEngine::CheckUpdatesRequestL(int wgid,

        CIAUpdateParameters* aFilterParams, bool aForcedRefresh)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::CheckUpdatesRequestL() begin");

    SetClientWgId(wgid);

    mRequestIssued = true;

    mStartedFromApplication = true;

    CleanupStack::PushL(aFilterParams);

    if (wgid > 0)

        {

        HideApplicationInFSWL(true);

        }

    CleanupStack::Pop(aFilterParams);

    if (!aFilterParams->ShowProgress())

        {

        iEikEnv->RootWin().SetOrdinalPosition(-1, ECoeWinPriorityNeverAtFront);

        }

    mRequestType = IAUpdateUiDefines::ECheckUpdates;

    iController->SetRequestType(mRequestType);

    iController->SetForcedRefresh(aForcedRefresh);

    iController->CheckUpdatesDeferredL(aFilterParams, false);

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::CheckUpdatesRequestL() end");

    }

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

// IAUpdateEngine::ShowUpdatesRequestL

// 

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

// 

void IAUpdateEngine::ShowUpdatesRequestL(int wgid,

        CIAUpdateParameters* aFilterParams)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdatesRequestL() begin");

    SetClientWgId(wgid);

    mRequestIssued = true;

    //    delete iBackgroundTimer;

    //    iBackgroundTimer = NULL;

    mStartedFromApplication = true;

    CleanupStack::PushL(aFilterParams);

    if (wgid > 0)

        {

        HideApplicationInFSWL(true);

        }

    //StatusPane()->MakeVisible( true );

    iEikEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityNormal);

    //iRequestObserver = &aObserver;

    mRequestType = IAUpdateUiDefines::EShowUpdates;

    iController->SetRequestType(mRequestType);

    //if ( !iMainView )

    //    {

    //    iMainView  = CIAUpdateMainView::NewL( ClientRect() ); 

    //    AddViewL( iMainView );

    //    }

    // by pushing object to cleanup stack its destructor is called if leave happens

    // so global lock issued by this instance can be released in destructor of CIAUpdateGlobalLockHandler

    CIAUpdateGlobalLockHandler* globalLockHandler =

            CIAUpdateGlobalLockHandler::NewLC();

    if (!globalLockHandler->InUseByAnotherInstanceL())

        {

        globalLockHandler->SetToInUseForAnotherInstancesL(true);

        CleanupStack::Pop(globalLockHandler);

        CleanupStack::Pop(aFilterParams);

        CleanupStack::PushL(globalLockHandler);

        iController->CheckUpdatesDeferredL(aFilterParams, false);

        CleanupStack::Pop(globalLockHandler);

        delete iGlobalLockHandler;

        iGlobalLockHandler = globalLockHandler;

        //now possible deletion of iGlobalLockHandler in leave situation is handled

        //in HandleLeaveErrorL() and HandleLeaveErrorWithoutLeave methods. 

        }

    else

        {

        CleanupStack::PopAndDestroy(globalLockHandler);

        CleanupStack::PopAndDestroy(aFilterParams);

        // locked by another IAD instance, nothing else to do than just complete client's request.  

        InformRequestObserver(KErrNone);

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdatesRequestL() end");

    }

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

// IAUpdateEngine::ShowUpdateQueryRequestL

// 

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

//     

void IAUpdateEngine::ShowUpdateQueryRequestL(int wgid, uint aUid)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdateQueryRequestL begin");

    SetClientWgId(wgid);

    mRequestIssued = true;

    mStartedFromApplication = true;

    mUpdatequeryUid = aUid;

    mUpdateNow = false;

    if (wgid > 0)

        {

        HideApplicationInFSWL(true);

        }

    mRequestType = IAUpdateUiDefines::EUpdateQuery;

    delete iIdle;

    iIdle = NULL;

    iIdle = CIdle::NewL(CActive::EPriorityIdle);

    iIdle->Start(TCallBack(UpdateQueryCallbackL, this));

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdateQueryRequestL end")

    }

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

// IAUpdateEngine::StartUpdate

// 

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

//

void IAUpdateEngine::StartUpdate(bool aFirmwareUpdate)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartUpdate() begin");

    if (aFirmwareUpdate)

        {

        if (!iFwUpdateHandler)

            {

            TRAP_IGNORE( CIAUpdateFWUpdateHandler::NewL() );

            }

        if (iFwUpdateHandler)

            {

            iFwUpdateHandler->FirmWareUpdatewithFOTA();

            }

        }

    else

        {

        // by pushing object to cleanup stack it's destructor is called if leave happens

        // so global lock issued by this instance can be released in destructor of CIAUpdateGlobalLockHandler

        CIAUpdateGlobalLockHandler* globalLockHandler =

                CIAUpdateGlobalLockHandler::NewLC();

        if (!globalLockHandler->InUseByAnotherInstanceL())

            {

            globalLockHandler->SetToInUseForAnotherInstancesL(true);

            // No need to be totally silent since the updating is started

            // by user.

            SetDefaultConnectionMethodL(false);

            iController->StartUpdateL();

            CleanupStack::Pop(globalLockHandler);

            delete iGlobalLockHandler;

            iGlobalLockHandler = globalLockHandler;

            //now possible deletion of iGlobalLockHandler in leave situation is handled

            //in HandleLeaveErrorL() and HandleLeaveErrorWithoutLeave methods. 

            }

        else

            {

            CleanupStack::PopAndDestroy(globalLockHandler);

            }

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartUpdate() end");

    }

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

// IAUpdateEngine::SetVisibleL

// 

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

//  

void IAUpdateEngine::SetVisibleL(bool /*aVisible*/)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::SetVisibleL() begin");

    //IAUPDATE_TRACE_1("[IAUPDATE] visible: %d", aVisible );

    /*if ( aVisible )

     {

     if ( iEikonEnv->RootWin().OrdinalPosition() != 0 || iEikonEnv->RootWin().OrdinalPriority() != ECoeWinPriorityNormal )

     {

     iEikonEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal );

     }

     StatusPane()->MakeVisible( ETrue );

     iMainView  = CIAUpdateMainView::NewL( ClientRect() ); 

     AddViewL( iMainView );

     ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) );

     }

     else

     {

     iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront );

     StatusPane()->MakeVisible( EFalse );

     }*/

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::SetVisibleL() end");

    }

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

// IAUpdateEngine::SetClientWgId

// 

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

// 

void IAUpdateEngine::SetClientWgId(int aWgId)

    {

    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::SetClientWgId() wgId %d", aWgId );

    mWgId = aWgId;

    }

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

// IAUpdateEngine::ClientInBackgroundL

// 

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

// 

bool IAUpdateEngine::ClientInBackgroundL() const

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ClientInBackgroundL() begin");

    bool inBackground = false;

    if (mWgId > 0)

        {

        CArrayFixFlat<int>* wgArray = new (ELeave) CArrayFixFlat<int> (10);

        CleanupStack::PushL(wgArray);

        User::LeaveIfError(iEikEnv->WsSession().WindowGroupList(0, wgArray));

        int ownWgId = iEikEnv->RootWin().Identifier();

        if ((wgArray->At(0) != ownWgId) && (wgArray->At(0) != mWgId))

            {

            inBackground = true;

            }

        CleanupStack::PopAndDestroy(wgArray);

        }

    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::ClientInBackgroundL() inBackground: %d", inBackground );

    return inBackground;

    }

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

// IAUpdateEngine::handleAllClientsClosed()

// 

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

//

void IAUpdateEngine::handleAllClientsClosed()

    {

    qApp->quit();

    }

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

// IAUpdateEngine::dialogFinished

// Called when dialog is finished.

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

//

void IAUpdateEngine::dialogFinished(HbAction *action)

    {

    DialogState dialogState = mDialogState;

    mDialogState = NoDialog;

    switch (dialogState)

        {

        case Results:

            mUiRefreshAllowed = true;

            if (iController->ResultsInfo().iRebootAfterInstall)

                {

                ShowRebootDialogL();

                }

            else

                {

                if (!DoPossibleApplicationClose())

                    {

                    iController->RefreshNodeList();

                    RefreshUI();

                    }

                }

            break;

        case RebootQuery:

            if (action == mPrimaryAction)

                {

                RStarterSession startersession;

                if (startersession.Connect() == KErrNone)

                    {

                    startersession.Reset(RStarterSession::EUnknownReset);

                    startersession.Close();

                    }

                }

            else

                {

                if (!DoPossibleApplicationClose())

                    {

                    iController->RefreshNodeList();

                    RefreshUI();

                    }

                }

            break;

        case ShowUpdateQuery:

            if (action == mPrimaryAction)

                {

                IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::dialogFinished() Now");

                mUpdateNow = true;

                }

            else if (action == mSecondaryAction)

                {

                IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::dialogFinished() Later");

                CIAUpdateQueryHistory* updateQueryHistory =

                        CIAUpdateQueryHistory::NewL();

                CleanupStack::PushL(updateQueryHistory);

                updateQueryHistory->SetTimeL(mUpdatequeryUid);

                CleanupStack::PopAndDestroy(updateQueryHistory);

                }

            InformRequestObserver(KErrNone);

            break;

        default:

            break;

        }

    }

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

// IAUpdateEngine::StartupComplete

// 

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

//    

void IAUpdateEngine::StartupComplete(TInt aError)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupComplete() begin");

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

    if (aError != KErrNone)

        {

        HandleLeaveErrorWithoutLeave(aError);

        }

    else

        {

        TRAPD( err, StartupCompleteL() );

        if (err != KErrNone)

            {

            HandleLeaveErrorWithoutLeave(err);

            }

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupComplete() end");

    }

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

// IAUpdateEngine::StartupCompleteL

// 

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

//    

void IAUpdateEngine::StartupCompleteL()

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupCompleteL() begin");

    delete iGlobalLockHandler;

    iGlobalLockHandler = NULL;

    iGlobalLockHandler = CIAUpdateGlobalLockHandler::NewL();

    if (!iGlobalLockHandler->InUseByAnotherInstanceL())

        {

        bool totalSilent(false);

        if (mRequestType == IAUpdateUiDefines::ECheckUpdates)

            {

            if (iController->Filter())

                {

                if (iController->Filter()->FilterParams())

                    {

                    if (iController->Filter()->FilterParams()->Refresh())

                        {

                        if (!iController->ForcedRefresh())

                            {

                            //from bgchecker, make it silent

                            totalSilent = true;

                            }

                        }

                    }

                }

            }

        SetDefaultConnectionMethodL(totalSilent);

        iGlobalLockHandler->SetToInUseForAnotherInstancesL(true);

        iController->StartRefreshL();

        }

    else

        {

        RefreshCompleteL(true, KErrServerBusy);

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupCompleteL() end");

    }

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

// IAUpdateEngine::HandleLeaveErrorL

// 

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

//        

void IAUpdateEngine::HandleLeaveErrorL(TInt aError)

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HandleLeaveErrorL() begin");

    //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances

    delete iGlobalLockHandler;

    iGlobalLockHandler = NULL;

    // client request is completed before leave in case of leave error

    if (aError != KErrNone)

        {

        InformRequestObserver(aError);

        User::Leave(aError);

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HandleLeaveErrorL() end");

    }

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

// IAUpdateEngine::HandleLeaveErrorWithoutLeave

// 

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