/*

* Copyright (c) 2008-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:   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 <avkon.hrh>

#include <StringLoader.h> 

#include <iaupdate.rsg>

#include <data_caging_path_literals.hrh>

#include <bautils.h>

#include <apgtask.h>

#include <sysversioninfo.h>  //sysversioninfo

#include <featurecontrol.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(KIAUpdateResourceFile, "iaupdate.rsc");

_LIT(KIAUpdateLauncherExe, "iaupdatelauncher.exe" );

_LIT(KImageFile, "qgn_note_swupdate_notification.svg");

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

    iReminderTimer = CIAUpdateBGReminderTimer::NewL( this );

    iUpdate = NULL;

    iParameters = NULL;

    iIAUpdateCRSession = NULL; 

    iNotifyHandler = NULL;

    iControllerFile = CIAUpdateBGControllerFile::NewL();

    iInternalFile = CIAUpdateBGInternalFileHandler::NewL();

    iSoftNotification = CIAUpdateBGSoftNotification::NewL( this, iInternalFile );

    iSoftNotification->StartObservingIfNeededL();

    // Get resource file path

    TFileName fileName;

    fileName.Copy(TParsePtrC(RProcess().FileName()).Drive());

    fileName.Append(KDC_APP_RESOURCE_DIR);

    fileName.Append(KIAUpdateResourceFile);

    User::LeaveIfError(iFs.Connect());

    // Get language of resource file        

    BaflUtils::NearestLanguageFile( iFs, fileName );

    // Open resource file

    iResourceFile.OpenL( iFs, fileName );

    iResourceFile.ConfirmSignatureL();    

    }

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

// CIAUpdateBGTimer::~CIAUpdateBGTimer()

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

CIAUpdateBGTimer::~CIAUpdateBGTimer()

    {

    Cancel();

    delete iUpdate; 

    delete iParameters;

    delete iReminderTimer;

    if ( iNotifyHandler ) 

        {

        iNotifyHandler->StopListening();

        delete iNotifyHandler;

        }

    delete iIAUpdateCRSession; 

    delete iControllerFile;

    delete iInternalFile;

    delete iSoftNotification;

    iResourceFile.Close();

    iFs.Close();

    }

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

// CIAUpdateBGTimer::StartProcessL()

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

void CIAUpdateBGTimer::StartProcessL()

    {

    FLOG("[bgchecker] StartProcessL");

    iMode = ModeL();

    switch ( iMode )

        {

        case EFirstTimeMode:

        case EFirstTimeRemindMode:    

            {

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

            RunL();

            break;

            }

        case EFirstTimeMode3:

            {

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

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

            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::IsAskedAlreadyL()

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

TBool CIAUpdateBGTimer::IsAskedAlreadyL()

    {

    CIAUpdateBGFirstTimeHandler* fthandler  = CIAUpdateBGFirstTimeHandler::NewL();

    CleanupStack::PushL( fthandler );

    TBool result = fthandler->AgreementAskedL();

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

            //start reminder timer also if user choose later before reboot

            //check the value from private folder

              if ( ReminderOnL() )

                  {

                  TTime currenttime;

                  currenttime.UniversalTime();

                  FTIME( currenttime );

                  TTime nextremindtime = NextRemindTimeL();

                  FTIME( nextremindtime );

                  TTimeIntervalMinutes timetogo;

                  nextremindtime.MinutesFrom( currenttime, timetogo );

                  FLOG_NUM("time to go = %d", timetogo.Int() );

                  if ( timetogo.Int() <= 0 )

                      {

                      //pop up the reminder directly

                      ReminderTimerCallBack();

                      }

                  else

                      {

                      iReminderTimer->StartReminderTimerL( timetogo );

                      }

                  }

            }

    }

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

// 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::NextRemindTimeL()

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

TTime CIAUpdateBGTimer::NextRemindTimeL()

    {

    iInternalFile->ReadControllerDataL();

    return iInternalFile->NextRemindTime();

    }

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

// CIAUpdateBGTimer::SetNextRemindTimeL()

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

TInt CIAUpdateBGTimer::SetNextRemindTimeL( TTime aTime )

    {

    iInternalFile->SetNextRemindTime( aTime );

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

    return err;

    }

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

// CIAUpdateBGTimer::ReminderOnL()

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

TBool CIAUpdateBGTimer::ReminderOnL()

    {

    iInternalFile->ReadControllerDataL(); 

    return iInternalFile->ReminderOn();

    }

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

// CIAUpdateBGTimer::SetReminderL()

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

TInt CIAUpdateBGTimer::SetReminderL( TBool aOn )

    {

    iInternalFile->SetReminder( aOn );

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

    return err;