/*

* 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 <cmmanagerext.h>

#include <cmdestinationext.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 );

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

    }

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

// 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

                {

                }

            break;

        case RebootQuery:    

            if (action == mPrimaryAction )

                {

                RStarterSession startersession;

                if( startersession.Connect() == KErrNone )

                    {

                    startersession.Reset( RStarterSession::EUnknownReset );

                    startersession.Close();

                    }

                }

            else

                {

                }

            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 );

        }