diff -r 000000000000 -r ba25891c3a9e iaupdate/IAD/backgroundchecker/src/iaupdatebgrefreshtimer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/iaupdate/IAD/backgroundchecker/src/iaupdatebgrefreshtimer.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,1814 @@ +/* +* 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 +//IAD API +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include //sysversioninfo +#include + +#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; + } + + +// ---------------------------------------------------------- +// 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; + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::DoUpdatesCheckingL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::DoUpdatesCheckingL( const TBool& aUpdateFromServer ) + { + FLOG( "DoUpdatesCheckingL update"); + //turn off the reminder, user will decide whether to turn if on or off + //The user's decision will be checked in soft notification callback function + + if ( ReminderOnL()) + { + FLOG( "Do CheckUpdates 3"); + iReminderTimer->CancelReminderTimerL(); + SetReminderL( EFalse ); + } + + if( !iUpdate ) + { + iUpdate = CIAUpdate::NewL( *this ); + } + if ( !iParameters ) + { + iParameters = CIAUpdateParameters::NewL(); + } + + if ( aUpdateFromServer ) + { + iParameters->SetRefresh( ETrue ); + + FLOG("Polling from Server!"); + if ( !IsAgreementAcceptedL() ) + { + FLOG("First time, bigger searching scale"); + //The bigger searching scale will be used until user see the searching result + // meaning open IAD maiview + iParameters->SetImportance( CIAUpdateParameters::ECritical | + CIAUpdateParameters::EMandatory | + CIAUpdateParameters::ERecommended | + CIAUpdateParameters::ENormal ); + } + else + { + FLOG("Not first time, smaller searching scale"); + iParameters->SetImportance( CIAUpdateParameters::ECritical | CIAUpdateParameters::EMandatory ); + } + } + else + { + FLOG("Use cache, use smaller searching scale!"); + iParameters->SetRefresh( EFalse ); + iParameters->SetImportance( CIAUpdateParameters::ECritical | CIAUpdateParameters::EMandatory ); + } + + iUpdate->CheckUpdates( *iParameters ); + //call back function will be called when checking is done + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::DoCheckUpdatesComplete() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::DoCheckUpdatesCompleteL( TInt aErrorCode, TInt aAvailableUpdates ) + { + FLOG_NUM( "CheckUpdatesComplete aErrorCode = %d", aErrorCode ); + FLOG_NUM( "CheckUpdatesComplete aAvailableUpdates = %d", aAvailableUpdates ); + if ( !IAUpdateEnabledL() ) + { + Shutdown(); + return; + } + TBool checkupdatefromserver = EFalse; + + if ( iUpdate ) + { + delete iUpdate; + iUpdate = NULL; + } + + if ( iParameters ) + { + checkupdatefromserver = iParameters->Refresh(); + delete iParameters; + iParameters = NULL; + } + + if ( ModeL() == ERetryMode ) + { + TInt retry = RetryTimesL(); + //increasing the retry times + retry++; + SetRetryTimesL( retry ); + } + + FLOG( "CheckUpdatesComplete"); + + if ( aErrorCode == KErrNone ) + { + FLOG( "CheckUpdatesComplete 1"); + + //Set to normal mode + iMode = ENormalMode; + SetModeL( ENormalMode ); + //clear the retry times + SetRetryTimesL( 0 ); + + if ( aAvailableUpdates > 0 ) + { + FLOG( "CheckUpdatesComplete 4"); + + LaunchSoftNotificationL(R_IAUPDATE_UPDATE_AVAILABLE, + R_TEXT_SOFTKEY_SHOW, R_TEXT_SOFTKEY_LATER ); + } + + FLOG( "CheckUpdatesComplete 5"); + + // if update checking is from server, restart the refresh timer + // if update checking is from cache, do nothing + if ( checkupdatefromserver ) + { + // for firmware changed case, we also refresh after 1 month + TTimeIntervalMinutes interval( CheckingFrequencyInMinutesL() ); + + FLOG_NUM("interval = %d", interval.Int()); + + FLOG( "CheckUpdatesComplete 6"); + + //recheck after the interval + StartL( interval ); + + FLOG( "CheckUpdatesComplete 7"); + //update the last-checking time in iaupdate private file + SetLastRefreshTime(); + } + } + else + { + FLOG( "CheckUpdatesComplete Complete with error"); + + iMode = ERetryMode; + SetModeL( ERetryMode ); + + TInt retry = RetryTimesL(); + + if ( retry >= KMaxRetry ) + { + //if 4 tries failed, stop retrymode and back to normal mode + //just start a new interval + iMode = ENormalMode; + SetModeL( ENormalMode ); + + FLOG( "CheckUpdatesComplete reach the max retry times"); + if ( checkupdatefromserver ) + { + TTimeIntervalMinutes interval( CheckingFrequencyInMinutesL() ); + StartL( interval ); + SetLastRefreshTime(); + } + else + { + //don't show soft notification and restart the timer. + TTimeIntervalMinutes oneweek( UpdateAvailableReminderIntervalInMinutesL() ); + TTime currenttime; + currenttime.UniversalTime(); + TTime nextRemindTime = currenttime + oneweek; + + SetReminderL( ETrue ); + SetNextRemindTimeL( nextRemindTime ); + + iReminderTimer->StartReminderTimerL( oneweek ); + } + //clear the retry time + SetRetryTimesL( 0 ); + } + else + { + FLOG( "CheckUpdatesComplete doesn't reach the max retry times, continue.."); + //continue retrying + switch ( retry ) + { + case 0: + case 1: + { + //first or second failure, retry after 30mins + TTimeIntervalMinutes halfhour( KFirstSecondRetryInterval ); + StartL( halfhour ); + } + break; + + case 2: + case 3: + { + //third failure, retry after 24 hours + TTimeIntervalMinutes oneday( KThirdFourthRetryInterval ); + StartL( oneday ); + } + break; + + default: + break; + }; + } + } + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::CheckUpdatesComplete() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::CheckUpdatesComplete( TInt aErrorCode, TInt aAvailableUpdates ) + { + TRAP_IGNORE( DoCheckUpdatesCompleteL( aErrorCode, aAvailableUpdates ) ); + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::UpdateComplete() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::UpdateComplete( TInt /*aErrorCode*/, CIAUpdateResult* /*aResult*/ ) + { + FLOG( "UpdateComplete"); + //no implementation + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::UpdateQueryComplete() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::UpdateQueryComplete( TInt /*aErrorCode*/, TBool /*aUpdateNow*/ ) + { + FLOG( "UpdateQueryComplete"); + //no implementation + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::CIAUpdateBGTimer() +// ---------------------------------------------------------- +CIAUpdateBGTimer::CIAUpdateBGTimer():CTimer( EPriorityStandard ) + { + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::RunL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::RunL() + { + FLOG("[bgchecker]RunL() "); + if ( !IAUpdateEnabledL() ) + { + Shutdown(); + return; + } + User::LeaveIfError( iStatus.Int() ); + //Check the mode again, in case the mode is changed while waiting. + iMode = ModeL(); + + switch ( iMode ) + { + case ENormalMode: + case ERetryMode: + { + FLOG("[bgchecker]RunL() ENormalMode"); + //roaming case is checked in IAUpdate server side + if ( IsAutoUpdateDisabledL() ) + { + ListenAutoUpdateSettingsL(); + + iMode = ESleepMode; + SetModeL( iMode ); + + //the program is waked up when automatic checking is changed by user. + //cenrep call back will be used. + return; + } + + FLOG("[bgchecker]RunL() ENormalMode 1"); + + if(iRuns == 0) + { + FLOG("[bgchecker]RunL() ENormalMode 2"); + // if user did the refresh from server while waiting, restart the timer. + // the last refresh time is read from the private file of IAUpdate server. + TTimeIntervalMinutes timetowait = + TimeIntervalFromNextRefreshL(); + + if (timetowait.Int() <= 0 ) + { + DoUpdatesCheckingL( ETrue ); + } + else + { + StartL( timetowait ); + } + FLOG("[bgchecker]RunL() ENormalMode 3"); + } + else + { + FLOG("[bgchecker]RunL() ENormalMode 4"); + TTimeIntervalMinutes timetowait = TimeIntervalFromNextRefreshL(); + + if ( timetowait.Int() <= 0 ) + { + StartL( StartNow ); + } + else + { + StartL( timetowait ); + } + FLOG("[bgchecker]RunL() ENormalMode 5"); + } + } + break; + + case EFirstTimeMode: + case EFirstTimeRemindMode: + { + FLOG("[bgchecker] runl EFirstTimeMode"); + + if ( iRuns == 0 ) + { + FLOG("[bgchecker] runl run = 0"); + HandlerFirstTimeL(); + } + else + { + FLOG("[bgchecker] runl still wait"); + TTimeIntervalMinutes timetowait = TimeIntervalFromNextShowOfNewFeatureDialogL(); + + if ( timetowait.Int() <= 0 ) + { + StartL( StartNow ); + } + else + { + StartL( timetowait ); + } + } + } + break; + + case EFirstTimeMode2: + { + FLOG("[bgchecker] runl EFirstTimeMode2"); + LaunchSoftNotificationL(R_IAUPDATE_REMIND_LATER, R_TEXT_SOFTKEY_YES, R_TEXT_SOFTKEY_NO ); + } + break; + + case EFirstTimeMode3: + { + FLOG("[bgchecker] runl EFirstTimeMode3"); + //disclaimer is not accepted + + if ( !IsAgreementAcceptedL() ) + { + FLOG("[bgchecker] runl EFirstTimeMode reject disclaimer"); + //user accepte the new feature dialog but user reject sthe disclaimer + //in sleep mode now + iMode = ESleepMode; + SetModeL( iMode ); + //subscribe to cenrep key for automatic checking for wake up from sleep mode + ListenAutoUpdateSettingsL(); + } + else + { + FLOG("[bgchecker] runl EFirstTimeMode go to normal mode"); + //Set to Normal mode + //check autochecksetting in Runl later + iMode = ENormalMode; + SetModeL( iMode ); + StartL( StartNow ); + } + } + break; + + default: + break; + }; + + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::HandlerFirstTimeL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::HandlerFirstTimeL() + { + // this checking is in case when accept disclaimer from grid or application + // during the waiting time. + + if (IsAgreementAcceptedL() || !IsAutoUpdateDisabledL()) + { + //user accepted the disclamier during the waiting time + //out of firsttime mode, check auto check setting in runl and + //do update check as normal. + // If autoUpdate is enabled ==> always to normal mode + + //In normal mode now. + iMode = ENormalMode; + SetModeL(iMode); + StartL(StartNow); + } + else + { + //this is first time mode + FLOG("[bgchecker]HandlerFirstTimeL 3 "); + LaunchSoftNotificationL( R_IAUPDATE_FEATURES_AVAILABLE, + R_TEXT_SOFTKEY_OK, R_TEXT_SOFTKEY_CANCEL ); + } + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::DoCancel() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::DoCancel() + { + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::RunError() +// ---------------------------------------------------------- +TInt CIAUpdateBGTimer::RunError(TInt /*aError*/) + { + return KErrNone; + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::CheckingFrequencyInMinutesL() +// ---------------------------------------------------------- +TInt CIAUpdateBGTimer::CheckingFrequencyInMinutesL() + { + FLOG("[bgchecker]CheckingFrequencyInMinutesL begin "); + +#ifdef _DEMO + return KCheckingUpdateInterval; +#else + TInt CheckingFrequency = 0; + CRepository* cenrep = CRepository::NewL( KCRUidIAUpdateSettings ); + CleanupStack::PushL( cenrep ); + TInt err = cenrep->Get( KIAUpdateCheckingFrequency, CheckingFrequency ); + + if ( err != KErrNone ) + { + FLOG("[bgchecker]CheckingFrequencyInMinutesL Getting checking frequency from Cenrep failed "); + } + + CleanupStack::PopAndDestroy( cenrep ); + + return CheckingFrequency*24*60; // convert into minutes +#endif + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::UpdateAvailableReminderIntervalInMinutesL() +// ---------------------------------------------------------- +TInt CIAUpdateBGTimer::UpdateAvailableReminderIntervalInMinutesL() + { + FLOG("[bgchecker]UpdateAvailableReminderIntervalInMinutesL begin "); + +#ifdef _DEMO + return KUpdateAvailableReminderInterval; +#else + TInt updateAvailableReminderIntervel = 0; + CRepository* cenrep = CRepository::NewL( KCRUidIAUpdateSettings ); + CleanupStack::PushL( cenrep ); + TInt err = cenrep->Get( KIAUpdateUpdateAvailableReminderInterval, updateAvailableReminderIntervel ); + + if ( err != KErrNone ) + { + FLOG("[bgchecker]UpdateAvailableReminderIntervalInMinutesL interval for update available reminder from Cenrep failed "); + } + + CleanupStack::PopAndDestroy( cenrep ); + + return updateAvailableReminderIntervel*24*60; // convert into minutes +#endif + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::FirstTimeDialogDelayInMinutesL() +// ---------------------------------------------------------- +TInt CIAUpdateBGTimer::FirstTimeDialogDelayInMinutesL() + { + FLOG("[bgchecker]FirstTimeDialogDelayInMinutesL begin "); + +#ifdef _DEMO + return KFirstTimeDialogDelay; +#else + TInt firstTimeDialogDelay = 0; + CRepository* cenrep = CRepository::NewL( KCRUidIAUpdateSettings ); + CleanupStack::PushL( cenrep ); + TInt err = cenrep->Get( KIAUpdateFirstTimeDialogDelay, firstTimeDialogDelay ); + + if ( err != KErrNone ) + { + FLOG("[bgchecker]FirstTimeDialogDelayInMinutesL Getting first time dialog delay from Cenrep failed "); + } + + CleanupStack::PopAndDestroy( cenrep ); + + return firstTimeDialogDelay*24*60; // convert into minutes +#endif + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::FirstTimeDialogReminderIntervalInMinutesL() +// ---------------------------------------------------------- +TInt CIAUpdateBGTimer::FirstTimeDialogReminderIntervalInMinutesL() + { + FLOG("[bgchecker]FirstTimeDialogDelayInMinutesL begin "); + +#ifdef _DEMO + return KFirstTimeDialogReminderInterval; +#else + TInt firstTimeDialogReminderInterval = 0; + CRepository* cenrep = CRepository::NewL( KCRUidIAUpdateSettings ); + CleanupStack::PushL( cenrep ); + TInt err = cenrep->Get( KIAUpdateFirstTimeDialogReminderInterval, firstTimeDialogReminderInterval ); + + if ( err != KErrNone ) + { + FLOG("[bgchecker]FirstTimeDialogReminderIntervalInMinutesL Getting first time dialog reminder interval from Cenrep failed "); + } + + CleanupStack::PopAndDestroy( cenrep ); + + return firstTimeDialogReminderInterval*24*60; // convert into minutes +#endif + } + + + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::IsFirstTimeDialogDisabledL() +// ---------------------------------------------------------- +TBool CIAUpdateBGTimer::IsFirstTimeDialogDisabledL() + { + FLOG("[bgchecker]IsFirstTimeDialogDisabledL begin "); + + TBool isDisabled = EFalse; + + CRepository* cenrep = CRepository::NewL( KCRUidIAUpdateSettings ); + CleanupStack::PushL( cenrep ); + + TInt err = cenrep->Get( KIAUpdateFirstTimeDialogDisabled, isDisabled ); + + FLOG_NUM("[bgchecker] err = %d", err ); + FLOG_NUM("[bgchecker] isDisabled = %d", isDisabled ); + + if ( err != KErrNone ) + { + FLOG("[bgchecker]IsFirstTimeDialogDisabledL get value from cenrep failed "); + } + + CleanupStack::PopAndDestroy( cenrep ); + + return isDisabled; + } + + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::StartL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::StartL( TTimeIntervalMinutes aWaitTime ) + { + Cancel(); + /* + RTimer::After maximum delay is 35 minutes, 47 seconds this is because it is 32bit integer. + Thats why aWaitTime is divided to 30min runs. + */ + + iRuns = 0; + + if(aWaitTime.Int() > HalfHourInMinuts ) + { + iRuns = aWaitTime.Int() / HalfHourInMinuts; + TTimeIntervalMinutes halfhour( HalfHourInMinuts ); + After( ConvertToMicroseconds( halfhour ) ); + } + else{ + After(ConvertToMicroseconds( aWaitTime ) ); + } + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::TimeIntervalFromNextRefreshL() +// ---------------------------------------------------------- +TTimeIntervalMinutes CIAUpdateBGTimer::TimeIntervalFromNextRefreshL() + { + FLOG("[bgchecker] TimeIntervalFromNextRefreshL 1"); + TTime lastrefreshtime = GetLastRefreshTimeL(); + + FTIME( lastrefreshtime ); + + TTime currenttime; + currenttime.UniversalTime(); + + FTIME ( currenttime ); + + //get current gap + TTimeIntervalMinutes timepast; + currenttime.MinutesFrom( lastrefreshtime, timepast ); + FLOG("[bgchecker] TimeIntervalFromNextRefreshL 2"); + if ( timepast.Int() < 0 ) + { + FLOG("[bgchecker] TimeIntervalFromNextRefreshL 3"); + //user set its clock backward, refresh anyway. + return timepast; + } + FLOG("[bgchecker] TimeIntervalFromNextRefreshL 4"); + TTimeIntervalMinutes interval( CheckingFrequencyInMinutesL() ); + FLOG_NUM(" interval %d ", interval.Int() ); + FLOG_NUM(" timepast %d ", timepast.Int() ); + FLOG("[bgchecker] TimeIntervalFromNextRefreshL 5"); + //check if the interval is bigger than the value defined by user + TTimeIntervalMinutes timetowait(interval.Int() - timepast.Int()); + FLOG("[bgchecker] TimeIntervalFromNextRefreshL 6"); + return timetowait; + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::TimeIntervalFromNextShowOfNewFeatureDialogL() +// ---------------------------------------------------------- +TTimeIntervalMinutes CIAUpdateBGTimer::TimeIntervalFromNextShowOfNewFeatureDialogL() + { + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 1"); + TTime lastshowtime = GetLastTimeShowNewFeatureDialogL(); + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 2"); + if( lastshowtime.Int64() == 0 ) + { + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 3"); + //first time + //wait for some days + + TTimeIntervalMinutes firstTimeDelay(FirstTimeDialogDelayInMinutesL()); + TTime currenttime; + currenttime.UniversalTime(); + + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 4"); + //save the next show new feature dialog time + //in case use switch off the device and restarted. + User::LeaveIfError(SetLastTimeShowNewFeatureDialogL(currenttime)); + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 5"); + return firstTimeDelay; + } + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 6"); + TTime currenttime; + currenttime.UniversalTime(); + + TTimeIntervalMinutes timepass; + currenttime.MinutesFrom( lastshowtime, timepass ); + + if ( timepass.Int() < 0 ) + { + FLOG("[bgchecker] TimeIntervalFromNextRefreshL 3"); + //clock is set back. + return timepass; + } + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 7"); + + TTimeIntervalMinutes interval; + if ( ModeL() == EFirstTimeMode ) + { + FLOG(" current mode is FirstTimeMode "); + interval = FirstTimeDialogDelayInMinutesL(); + } + else if ( ModeL() == EFirstTimeRemindMode ) + { + FLOG(" current mode is FirstTimeRemindMode"); + interval = FirstTimeDialogReminderIntervalInMinutesL(); + } + else + { + //nothing + FLOG(" current mode is wrong!!"); + User::LeaveIfError( KErrArgument ); + } + + FLOG_NUM(" interval %d ", interval.Int() ); + FLOG_NUM(" timepast %d ", timepass.Int() ); + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 5"); + //check if the interval is bigger than the value defined by user + TTimeIntervalMinutes timetowait(interval.Int() - timepass.Int()); + FLOG("[bgchecker] TimeIntervalFromNextShowOfNewFeatureDialogL 6"); + return timetowait; + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::DoSoftNotificationCallBackL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::DoSoftNotificationCallBackL( TBool aIsAccepted ) + { + FLOG("[bgchecker] SoftNotificationCallBack"); + if ( !IAUpdateEnabledL() ) + { + Shutdown(); + return; + } + iMode = ModeL(); + + switch ( iMode ) + { + case EFirstTimeMode: + case EFirstTimeRemindMode: + { + + FLOG("[bgchecker] SoftNotificationCallBack EFirstTimeMode"); + if ( !aIsAccepted ) + { + FLOG("[bgchecker] SoftNotificationCallBack EFirstTimeMode not accepted"); + iMode = EFirstTimeMode2; + SetModeL( iMode ); + StartL( StartNow ); + } + else + { + FLOG("[bgchecker] SoftNotificationCallBack EFirstTimeMod accepeted"); + StartIaupdateL(); + //iaupdate is launched + //check the disclaimer acceptance and automatic checking setting in 10mins + + StartL( KDelayForUserToAcceptDisclaimer ); + iMode = EFirstTimeMode3; + SetModeL( iMode ); + + + //Still in first time mode, + //check user's setting and disclamier after 10mins. + } + break; + } + + + + case EFirstTimeMode2: + { + FLOG("[bgchecker] SoftNotificationCallBack EFirstTimeMode2 "); + if ( aIsAccepted ) + { + FLOG("[bgchecker] SoftNotificationCallBack EFirstTimeMode2, accepted"); + //user wants to be reminder so remind in 4 weeks + //set to first time remind mode + iMode = EFirstTimeRemindMode; + SetModeL( iMode ); + TTimeIntervalMinutes fourweeks( FirstTimeDialogReminderIntervalInMinutesL() ); + TTime currenttime; + currenttime.UniversalTime(); + + //save the next show new feature dialog time + //in case use switch off the device and restarted. + User::LeaveIfError( SetLastTimeShowNewFeatureDialogL( currenttime ) ); + + StartL( fourweeks ); + return; + } + else + { + FLOG("[bgchecker] SoftNotificationCallBack EFirstTimeMode2, not accepted"); + //in sleep mode now + iMode = ESleepMode; + SetModeL( iMode ); + + //subscribe to cenrep key for automatic checking for wake up from sleep mode + ListenAutoUpdateSettingsL(); + } + break; + } + + case ENormalMode: + { + FLOG("[bgchecker] SoftNotificationCallBack ENormalMode"); + if ( !aIsAccepted ) + { + FLOG("[bgchecker] SoftNotificationCallBack ENormalMode not accpeted"); + //user wants to be reminded later + TTimeIntervalMinutes oneweek( UpdateAvailableReminderIntervalInMinutesL() ); + TTime currenttime; + currenttime.UniversalTime(); + TTime nextRemindTime = currenttime + oneweek; + + SetReminderL( ETrue ); + SetNextRemindTimeL( nextRemindTime ); + + iReminderTimer->StartReminderTimerL( oneweek ); + + //the reminder call back function will be called when reminder timer expires. + } + else + { + //accepted, launch iad + StartIaupdateL(); + } + break; + } + + case ESleepMode: + { + FLOG("[bgchecker] SoftNotificationCallBack ESleepMode"); + //donothing + break; + } + + default: + break; + } + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::SoftNotificationCallBack() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::SoftNotificationCallBack( TBool aIsAccepted ) + { + TRAP_IGNORE( DoSoftNotificationCallBackL( aIsAccepted ) ); + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::CurrentMode() +// ---------------------------------------------------------- +TIAUpdateBGMode CIAUpdateBGTimer::CurrentMode() + { + return iMode; + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::DoReminderTimerCallBack() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::DoReminderTimerCallBackL() + { + FLOG("[bgchecker] ReminderTimerCallBack begin"); + if ( !IAUpdateEnabledL() ) + { + Shutdown(); + return; + } + //Check the automatic update setting, if it has been disabled, + //then go to sleep mode. + if ( IsAutoUpdateDisabledL() ) + { + FLOG("[bgchecker] ReminderTimerCallBack autoupdate is disabled, switch to sleep mode"); + ListenAutoUpdateSettingsL(); + iMode = ESleepMode; + SetModeL( iMode ); + return; + } + + TTimeIntervalMinutes timetowait = TimeIntervalFromNextRefreshL(); + + if ( timetowait.Int() <= KRefreshTimerReminderTimerGap ) + { + FLOG("[bgchecker] ReminderTimerCallBack refresh is about to come in one day. We don't show reminder then"); + return; + } + + //if reminder is still on which means the BGTimer is not expired + //and checkupdate() is not called yet, then go ahead to call DoupdatesChecking + //this is to avoid DoUpdateChecking being called at the same time. + + if ( ReminderOnL() ) + { + FLOG("[bgchecker] ReminderTimerCallBack Reminder is still ON"); + DoUpdatesCheckingL( EFalse ); + } + FLOG("[bgchecker] ReminderTimerCallBack end"); + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::ReminderTimerCallBack() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::ReminderTimerCallBack() + { + TRAP_IGNORE( DoReminderTimerCallBackL() ); + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::LaunchSoftNotificationL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::LaunchSoftNotificationL( const TInt& aResourceId, const TInt& SK1, const TInt& SK2 ) + { + iInternalFile->ReadControllerDataL(); + TInt snid = iInternalFile->SoftNotificationID(); + if ( snid ) + { + //there is a soft notification buffered, remove it + iSoftNotification->RemoveSoftNotificationL( snid ); + } + + FLOG("[bgchecker] LaunchSoftNotificationL "); + HBufC* text = ReadResourceLC( aResourceId ); + HBufC* sk1 = ReadResourceLC( SK1 ); + HBufC* sk2 = ReadResourceLC( SK2 ); + + + iMode = ModeL(); + + if ( iMode == ENormalMode ) + { + TFileName path; + TInt err = GetPrivatePathL( path ); + + if ( err == KErrNone ) + { + HBufC8* image = LoadFileLC( path ); + iSoftNotification->SetImageL( *image ); + CleanupStack::PopAndDestroy( image ); + } + } + + + iSoftNotification->SetTextL( *text, *text ); + iSoftNotification->SetSoftkeyLabelsL( *sk1, *sk2 ); + + iSoftNotification->ShowSoftNotificationL(); + FLOG("[bgchecker] LaunchSoftNotificationL 1"); + CleanupStack::PopAndDestroy( 3 ); //text, sk1, sk2 + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::GetPrivatePathL() +// ---------------------------------------------------------- +TInt CIAUpdateBGTimer::GetPrivatePathL( TFileName& aPath ) + { + RFs fsSession; + User::LeaveIfError( fsSession.Connect() ); + CleanupClosePushL( fsSession ); + + // This will set the correct drive and private path + // for the file server session. + TInt err = KErrNone; + TRAP( err, SetPrivateDriveL( fsSession, KImageFile ) ); + + if ( err != KErrNone ) + { + CleanupStack::PopAndDestroy( &fsSession ); + return err; + } + + err = fsSession.SessionPath( aPath ); + aPath.Append( KImageFile ); + + CleanupStack::PopAndDestroy( &fsSession ); + return err; + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::LoadFileLC() +// ---------------------------------------------------------- + HBufC8* CIAUpdateBGTimer::LoadFileLC(const TDesC& aFile) + { + RFs fs; + User::LeaveIfError( fs.Connect() ); + CleanupClosePushL( fs ); + RFile file; + User::LeaveIfError(file.Open(fs, aFile, EFileRead)); + CleanupClosePushL(file); + TInt size; + User::LeaveIfError(file.Size(size)); + HBufC8* imagebuf = HBufC8::NewL(size); + TPtr8 imageptr(imagebuf->Des()); + file.Read(imageptr); + CleanupStack::PopAndDestroy( &file ); + CleanupStack::PopAndDestroy( &fs ); + CleanupDeletePushL(imagebuf); + return imagebuf; + } + + + // ---------------------------------------------------------- + // CIAUpdateBGTimer::SetPrivateDriveL() + // ---------------------------------------------------------- + void CIAUpdateBGTimer::SetPrivateDriveL( + RFs& aFs, + const TDesC& aFileName ) const + { + // First try to find the file from the private directory + // of the drive where the process exists. + RProcess process; + + // Set the session private path according to + // the process file name drive. + TInt driveNum( + SetSessionPrivatePathL( aFs, process.FileName() ) ); + + // Get the session path that was set above. + TFileName sessionPath; + User::LeaveIfError( aFs.SessionPath( sessionPath ) ); + + // Use the file finder to check if the file actually exists + // in the given drive path. If it does not, the file finder + // will automatically check from other drives. So, here we + // should always find the file if any exists. + TFindFile finder( aFs ); + User::LeaveIfError( finder.FindByDir( aFileName, sessionPath ) ); + + // The drive may have changed if the file was not found from + // the first suggested drive. So, be sure to have the correct + // private path. + driveNum = SetSessionPrivatePathL( aFs, finder.File() ); + + // Use the drive info to check if the drive is ROM drive. + // We prefer non ROM drives. But, accept ROM if nothing else is + // available. + TDriveInfo info; + User::LeaveIfError( aFs.Drive( info, driveNum ) ); + TBool isRomDrive( info.iDriveAtt & KDriveAttRom ); + if ( !isRomDrive ) + { + // The current file is not in ROM drive so use that. + return; + } + + // Because previous finding was ROM file, try to find a non ROM file. + TInt findErrorCode( finder.Find() ); + if ( findErrorCode == KErrNotFound ) + { + // Because no new file is found, use the current settings. + return; + } + User::LeaveIfError( findErrorCode ); + + // Update the session path for the correct file. + SetSessionPrivatePathL( aFs, finder.File() ); + } + + + // ---------------------------------------------------------- + // CIAUpdateBGTimer::SetSessionPrivatePathL() + // ---------------------------------------------------------- + TInt CIAUpdateBGTimer::SetSessionPrivatePathL( + RFs& aFs, + const TDesC& aPath ) const + { + // Use the parser to get the drive information from the path. + TParsePtrC parser( aPath ); + + if ( !parser.DrivePresent() ) + { + User::Leave( KErrArgument ); + } + + // Drive check was passed above. + // So, drive information is safe to use. + const TDesC& drive( parser.Drive() ); + const TChar driveChar( drive[ 0 ] ); + TInt driveNum( EDriveA ); + User::LeaveIfError( + RFs::CharToDrive( driveChar, driveNum ) ); + + // Set the file drive to be file session private path drive. + User::LeaveIfError( aFs.SetSessionToPrivate( driveNum ) ); + + return driveNum; + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::ReadResourceLC() +// ---------------------------------------------------------- +HBufC* CIAUpdateBGTimer::ReadResourceLC( TInt aResourceId ) + { + TResourceReader reader; + HBufC8* buff = iResourceFile.AllocReadLC( aResourceId ); + reader.SetBuffer( buff ); + HBufC* text = reader.ReadHBufCL(); + CleanupStack::PopAndDestroy( buff ); + CleanupStack::PushL( text ); + return text; + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::IsAutoUpdateDisabledL() +// ---------------------------------------------------------- +TBool CIAUpdateBGTimer::IsAutoUpdateDisabledL() + { + TInt autochecksetting; + CRepository* cenrep = CRepository::NewL( KCRUidIAUpdateSettings ); + CleanupStack::PushL( cenrep ); + User::LeaveIfError( cenrep->Get( KIAUpdateAutoUpdateCheck, autochecksetting ) ); + CleanupStack::PopAndDestroy( cenrep ); + return (autochecksetting == EIAUpdateSettingValueDisable) ? ETrue : EFalse; + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::ListenAutoUpdateSettingsL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::ListenAutoUpdateSettingsL() + { + FLOG("[bgchecker] ListenAutoUpdateSettingsL() begin"); + if (iIAUpdateCRSession == NULL ) + { + iIAUpdateCRSession = CRepository::NewL( KCRUidIAUpdateSettings ); + } + if (iNotifyHandler == NULL ) + { + iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iIAUpdateCRSession ); + } + iNotifyHandler->StartListeningL(); + } + + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::StopListeningAutoUpdateSettingsL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::StopListeningAutoUpdateSettingsL() + { + FLOG("[bgchecker] StopListeningAutoUpdateSettingsL() begin"); + if (iIAUpdateCRSession == NULL ) + { + iIAUpdateCRSession = CRepository::NewL( KCRUidIAUpdateSettings ); + } + if (iNotifyHandler == NULL ) + { + iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iIAUpdateCRSession ); + } + iNotifyHandler->StopListening(); + } + +// ---------------------------------------------------------- +// CIAUpdateBGTimer::StartIaupdateL() +// ---------------------------------------------------------- +void CIAUpdateBGTimer::StartIaupdateL() const + { + FLOG("[bgchecker] StartIaupdateL() begin"); + RWsSession ws; + User::LeaveIfError( ws.Connect() == KErrNone ); + TApaTaskList tasklist(ws); + TApaTask task = tasklist.FindApp( TUid::Uid( KIADUpdateLauncherUid ) ); + if ( task.Exists() ) + { + FLOG("[bgchecker] StartIaupdateL() IAD launcher process found"); + task.BringToForeground(); + FLOG("[bgchecker] StartIaupdateL() after task.BringToForeground()"); + ws.Close(); + } + else + { + ws.Close(); + RProcess process; + CleanupClosePushL( process ); + User::LeaveIfError( + process.Create( KIAUpdateLauncherExe, KNullDesC ) ); + + CApaCommandLine* commandLine = CApaCommandLine::NewLC(); + commandLine->SetDocumentNameL( KNullDesC ); + commandLine->SetExecutableNameL( _L("iaupdatelauncher.exe") ); + commandLine->SetTailEndL( KRefreshFromNetworkDenied ); + commandLine->SetProcessEnvironmentL( process ); + CleanupStack::PopAndDestroy( commandLine ); + + process.Resume(); + CleanupStack::PopAndDestroy( &process ); + } + FLOG("[bgchecker] StartIaupdateL() end"); + } + +// --------------------------------------------------------------------------- +// CIAUpdateBGTimer::IAUpdateEnabledL() +// --------------------------------------------------------------------------- +// +TBool CIAUpdateBGTimer::IAUpdateEnabledL() const + { + FLOG("[bgchecker] CIAUpdateBGTimer::IAUpdateEnabledL() begin"); + TBool enabled = EFalse; + RFeatureControl featureControl; + TInt error( KErrNone ); + + error = featureControl.Connect(); + FLOG_NUM("[bgchecker] CIAUpdateBGTimer::IAUpdateEnabledL() Connection to the Feature Manager Server: %d", error ); + + User::LeaveIfError( error ); + + TUid iaupdatefeature; + iaupdatefeature.iUid = KFeatureIdIAUpdate; + + TInt ret = featureControl.FeatureSupported( iaupdatefeature ); + if ( ret == KFeatureSupported ) + { + enabled = ETrue; + } + featureControl.Close(); + FLOG_NUM("[bgchecker] CIAUpdateBGTimer::IAUpdateEnabledL() enabled: %d", enabled ); + return enabled; + } + +// --------------------------------------------------------------------------- +// CIAUpdateBGTimer::Shutdown() +// --------------------------------------------------------------------------- +// +void CIAUpdateBGTimer::Shutdown() + { + FLOG("[bgchecker] Shutdown() begin"); + Cancel(); + delete iUpdate; + iUpdate = NULL; + + delete iReminderTimer; + iReminderTimer = NULL; + + if ( iNotifyHandler ) + { + iNotifyHandler->StopListening(); + delete iNotifyHandler; + iNotifyHandler = NULL; + } + + if ( iSoftNotification ) + { + TRAP_IGNORE( iSoftNotification->RemoveSoftNotificationL( iSoftNotification->Id() ) ); + delete iSoftNotification; + iSoftNotification = NULL; + } + + CActiveScheduler::Stop(); + + FLOG("[bgchecker] Shutdown() end"); + } + + + +// End of file + +