/*

* Copyright (c) 2008-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:   Implementation of background checker

*

*/

#include <e32std.h>

//IAD API

#include <iaupdate.h>

#include <iaupdateparameters.h>

#include <iaupdateresult.h>

#include <w32std.h>

#include <apgwgnam.h>

#include <apgcli.h>

#include <apacmdln.h>

#include <bautils.h>

#include <apgtask.h>

#include <sysversioninfo.h>  //sysversioninfo

#include <featurecontrol.h>

#include <hb/hbcore/hbtextresolversymbian.h>

#include "iaupdateprivatecrkeys.h"

#include "iaupdate.hrh"

#include "iaupdatebgrefreshtimer.h"

#include "iaupdatebglogger.h"

#include "iaupdatebgfirsttimehandler.h"

#include "iaupdatebginternalfilehandler.h"

#include "iaupdatebgconst.h"

//MACROS

_LIT8( KRefreshFromNetworkDenied, "1" );

_LIT(KIAUpdateLauncherExe, "iaupdatelauncher.exe" );

//CONSTANTS

const TUint KIADUpdateLauncherUid( 0x2001FE2F );

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

// CIAUpdateBGTimer::NewL()

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

CIAUpdateBGTimer* CIAUpdateBGTimer::NewL()

    {

    CIAUpdateBGTimer* self = new(ELeave)CIAUpdateBGTimer();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CIAUpdateBGTimer::ConstructL()

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

void CIAUpdateBGTimer::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    iUpdate = NULL;

    iParameters = NULL;

    iIAUpdateCRSession = NULL; 

    iNotifyHandler = NULL;

    iControllerFile = CIAUpdateBGControllerFile::NewL();

    iInternalFile = CIAUpdateBGInternalFileHandler::NewL();

    iSoftNotification = CIAUpdateBGSoftNotification::NewL( this ); 

    // loc: initialize localisation text loader

    /*

    TBool res = HbTextResolverSymbian::Init(KLocFile, KLocFilePath);

    if ( res != KErrNone )

        {

        // nothing to do

        }

    */

    }

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

// CIAUpdateBGTimer::~CIAUpdateBGTimer()

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

CIAUpdateBGTimer::~CIAUpdateBGTimer()

    {

    Cancel();

    delete iUpdate; 

    delete iParameters;

    if ( iNotifyHandler ) 

        {

        iNotifyHandler->StopListening();

        delete iNotifyHandler;

        }

    delete iIAUpdateCRSession; 

    delete iControllerFile;

    delete iInternalFile;

    delete iSoftNotification;

    }

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

// CIAUpdateBGTimer::StartProcessL()

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

void CIAUpdateBGTimer::StartProcessL()

    {

    FLOG("[bgchecker] StartProcessL");

    iMode = ModeL();

    switch ( iMode )

        {

        case EFirstTimeMode:

            {

            // while not released keep in sleep mode

            int test = 0;

            if ( test == 0 )

                {

                ListenAutoUpdateSettingsL();

                iMode = ESleepMode;

                SetModeL( iMode );

                return;

                }

            if ( IsFirstTimeDialogDisabledL() )

                {

                //this should only happen in testing

                FLOG("[bgchecker] StartProcessL Firs time dialog is disabled, this should only happen in testing");

                //subscribe to automatic checking settings

                //subscribe to cenrep key for automatic checking for wake up from sleep mode

                if (iIAUpdateCRSession == NULL )

                    {

                    iIAUpdateCRSession = CRepository::NewL( KCRUidIAUpdateSettings ); 

                    }

                if (iNotifyHandler == NULL )

                    {

                    iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iIAUpdateCRSession ); 

                    }

                FLOG("[bgchecker] StartProcessL go to sleep mode directly");    

                iNotifyHandler->StartListeningL();  

                iMode = ESleepMode;

                SetModeL( iMode );

                return;

                }

            FLOG("[bgchecker] StartProcessL EFirstTimeMode");

            //Wait for some days before activate the first time mode

            TTimeIntervalMinutes timetowait =

                    TimeIntervalFromNextShowOfNewFeatureDialogL();

                FLOG_NUM( " time to wait = %d", timetowait.Int() );

            if (timetowait.Int() <= 0)

                {

                    FLOG("[bgchecker] StartProcessL now");

                //start immediately

                //if agreement is not accepted but auto update is enabled,

                //jump to normal mode

                if (!IsAgreementAcceptedL() && !IsAutoUpdateDisabledL())

                    {

                    iMode = ENormalMode;

                    SetModeL(iMode);

                        FLOG("[bgchecker] Agreement is NOT accepted but AutoUpdate is enabled, Go to Normal mode");

                    StartUpdatesCheckingL();

                    return;

                    }

                TTimeIntervalMinutes timetowait =

                        TimeIntervalFromNextRefreshL();

                if (IsAgreementAcceptedL() && !IsAutoUpdateDisabledL()

                        && timetowait.Int() <= 0 )

                    {

                    //in this case, background checker will connect to server for refreshing

                    //put one minute delay here.

                    StartL(StartAfterOneMin );

                    }

                else

                    {

                    StartL( StartNow );

                    }

                }

            else

                {

                FLOG("[bgchecker] StartProcessL later");

                StartL( timetowait );   

                }    

            break;

            }

        case EFirstTimeMode2:

            {

            FLOG("[bgchecker] StartProcessL EFirstTimeMode 2");

            //if user accepted the disclaimer already and reboot the phone, 

            //this mode could go to network immediately after boot

            //We put one min delay here to wait for network ready.

            StartL(StartAfterOneMin);

            break;

            }

        case ESleepMode:

            {

            FLOG("[bgchecker] StartProcessL EFirstTimeMode 4");

            //subscribe to automatic checking settings

            //subscribe to cenrep key for automatic checking for wake up from sleep mode

            if (iIAUpdateCRSession == NULL )

                {

                iIAUpdateCRSession = CRepository::NewL( KCRUidIAUpdateSettings ); 

                }

            if (iNotifyHandler == NULL )

                {

                iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iIAUpdateCRSession ); 

                }

            iNotifyHandler->StartListeningL();  

            if ( !IsAgreementAcceptedL() )

                {

                FLOG("[bgchecker] EFirstTimeMode4 ShowIndicator");

                // Set number of updates; zero for first case

                iSoftNotification->SetNrOfUpdates( 0 );

                // do not show indicator when testing

                int test = 0;

                if ( test == 1)

                  iSoftNotification->ShowIndicatorL();

                }

            break;

            }

        case ENormalMode:

        case ERetryMode:

            {

            StartUpdatesCheckingL();

            break;

            }

        default:

            break;

        }

    }

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

// CIAUpdateBGTimer::IsAgreementAcceptedL()

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

TBool CIAUpdateBGTimer::IsAgreementAcceptedL()

    {

    CIAUpdateBGFirstTimeHandler* fthandler  = CIAUpdateBGFirstTimeHandler::NewL();

    CleanupStack::PushL( fthandler );

    TBool result = fthandler->AgreementAcceptedL();

    CleanupStack::PopAndDestroy( fthandler );

    return result;

    }

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

// CIAUpdateBGTimer::StartUpdatesCheckingL()

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

void CIAUpdateBGTimer::StartUpdatesCheckingL()  

    {       

    // check what is current setting from user.

    //if user disable the auto checking, we simply start the cenrep listener

    if ( IsAutoUpdateDisabledL() )

        {

        ListenAutoUpdateSettingsL();

        iMode = ESleepMode;

        SetModeL( iMode );

        return;

        }

    FLOG("[bgchecker] checking frequency is set by user");

    TTimeIntervalMinutes timetowait = TimeIntervalFromNextRefreshL(); 

    FLOG_NUM(" Next checking update starts after %d minuts", timetowait.Int() );

    if ( timetowait.Int() <= 0 )   

        {

        FLOG( "Start checking update now.");

        //this supposes to start immediately but we put 1 min delay here to wait for network registration

        StartL( StartAfterOneMin );

        //don't turn on the reminder since the refresh is started right now

        //if there is new update, the dialog will pop up. User can start remind timer

        //via the dialog

        }

    else

        {

            FLOG_NUM( "Start checking update after %d minutes", timetowait.Int());

            StartL( timetowait );

         }

    }

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

// CIAUpdateBGTimer::DoHandleNotifyGeneric()

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

void CIAUpdateBGTimer::DoHandleNotifyGenericL( TUint32 aId )

    {

    FLOG("[bgchecker] HandleNotifyGeneric");

    if ( !IAUpdateEnabledL() )

        {

        Shutdown();

        return;

        }

    switch ( iMode )

        {

        case ESleepMode:

            {

            FLOG_NUM("[bgchecker] HandleNotifyGeneric ESleepMode with Id = %d", aId );

            if ( aId == KIAUpdateAutoUpdateCheck )

                {

                if ( IsAutoUpdateDisabledL() ) 

                    {

                    FLOG("[bgchecker] HandleNotifyGeneric ESleepMode: Autoupdate is disabled");

                    iMode = ESleepMode;

                    SetModeL( iMode );

                    ListenAutoUpdateSettingsL();

                    }

                else

                    {

                    FLOG("[bgchecker] HandleNotifyGeneric ESleepMode: Autoupdate is enabled");

                    //restart the refresh timer according to checking frequency

                    StopListeningAutoUpdateSettingsL();

                    FLOG("[bgchecker] HandleNotifyGeneric ESleepMode: Stop listenning");

                    TTimeIntervalMinutes interval( TimeIntervalFromNextRefreshL() );

                    FLOG("[bgchecker] HandleNotifyGeneric ESleepMode: Start the timer according to interval counted from last refresh");                                                                           

                    if ( interval.Int() <= 0 )

                        {

                        FLOG("[bgchecker] HandleNotifyGeneric ESleepMode: Start now");

                        StartL( StartNow );

                        }

                    else

                        {

                        FLOG("[bgchecker] HandleNotifyGeneric ESleepMode: Start later");

                        StartL( interval );

                        }

                    FLOG("[bgchecker] HandleNotifyGeneric ESleepMode: Set Normal mode");               

                    //in normal mode now

                    iMode = ENormalMode;

                    SetModeL( ENormalMode );  

                    if ( iNotifyHandler )

                        {

                        delete iNotifyHandler;

                        iNotifyHandler = NULL;

                        }

                    if ( iIAUpdateCRSession )

                        {

                        delete iIAUpdateCRSession;

                        iIAUpdateCRSession = NULL;

                        }

                    }

                }

            }

            break;

        default:

            break;

        };        

    }

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

// CIAUpdateBGTimer::HandleNotifyGeneric()

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

void CIAUpdateBGTimer::HandleNotifyGeneric( TUint32 aId ) 

    {

    TRAP_IGNORE( DoHandleNotifyGenericL( aId ) );

    } 

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

// CIAUpdateBGTimer::GetLastUpdateTimeL()

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

TTime CIAUpdateBGTimer::GetLastRefreshTimeL()

    {    

    iControllerFile->ReadControllerDataL();

    return iControllerFile->RefreshTime();

    }

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

// CIAUpdateBGTimer::SetLastUpdateTime()

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

TInt CIAUpdateBGTimer::SetLastRefreshTime()

    {

    iControllerFile->SetCurrentRefreshTime();

    TRAPD( err, iControllerFile->WriteControllerDataL() );

    FLOG_NUM("SetLastRefreshTime err = %d", err );

    return err;

    }

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

// CIAUpdateBGTimer::GetLastTimeShowNewFeatureDialogL()

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

TTime CIAUpdateBGTimer::GetLastTimeShowNewFeatureDialogL()

    {

    iInternalFile->ReadControllerDataL();

    return iInternalFile->LastTimeShowNewFeatureDialog();

    }

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

// CIAUpdateBGTimer::SetTimeShowNewFeatureDialogL()

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

TInt CIAUpdateBGTimer::SetLastTimeShowNewFeatureDialogL( TTime aTime )

    {

    iInternalFile->SetLastTimeShowNewFeatureDialog( aTime );

    TRAPD( err,iInternalFile->WriteControllerDataL() );

    return err;

    }

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

// CIAUpdateBGTimer::ModeL()

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

TIAUpdateBGMode CIAUpdateBGTimer::ModeL()

    {

    iInternalFile->ReadControllerDataL();

    return iInternalFile->Mode();

    }

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

// CIAUpdateBGTimer::SetModeL()

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

TInt CIAUpdateBGTimer::SetModeL( TIAUpdateBGMode aMode )

    {

    iInternalFile->SetMode( aMode  );

    TRAPD( err,iInternalFile->WriteControllerDataL() );

    return err;

    }

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

// CIAUpdateBGTimer::RetryTimesL()

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

TInt CIAUpdateBGTimer::RetryTimesL()

    {

    iInternalFile->ReadControllerDataL();

    return iInternalFile->RetryTimes();

    }

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

// CIAUpdateBGTimer::SetRetryTimesL()

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

TInt CIAUpdateBGTimer::SetRetryTimesL( TInt aRetry )

    {

    iInternalFile->SetRetryTimes( aRetry  );

    TRAPD( err,iInternalFile->WriteControllerDataL() );

    return err;

    }

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

// CIAUpdateBGTimer::ConvertToMicroseconds()

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

TTimeIntervalMicroSeconds32 CIAUpdateBGTimer::ConvertToMicroseconds( TTimeIntervalMinutes aInterval )

    {

    return aInterval.Int()*60*1000*1000;

    }