diff -r 000000000000 -r 094583676ce7 wvuing/IMPSAlwaysOnlinePlugin/src/CIMPSAlwaysOnlineScheduler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wvuing/IMPSAlwaysOnlinePlugin/src/CIMPSAlwaysOnlineScheduler.cpp Thu Dec 17 08:41:52 2009 +0200 @@ -0,0 +1,857 @@ +/* +* Copyright (c) 2004 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: Helper class for always online scheduling +* +*/ + + +// INCLUDE FILES +#include "CIMPSAlwaysOnlineScheduler.h" +#include "CPEngAOPluginTimer.h" +#include "MIMPSScheduleObserver.h" +#include "IMPSCommonUiDebugPrint.h" +#include "IMPSAOPluginPanics.h" +#include "CIMPSSharedDataFactory.h" +#include "MIMPSSharedData.h" +#include "IMPSUIDDefs.h" +#include "wvsettingsshareddataNG.h" + +// CONSTANTS +const TInt KTimeValueLength( 2 ); +const TInt KTimeStringMaxLength( 10 ); // the length of the time string +const TInt KDefaultStartHour( 8 ); +const TInt KDefaultEndHour( 20 ); +const TInt KDefaultMinute( 0 ); +_LIT( KDefaultScheduleStartTime, "08:00" ); // default times +_LIT( KDefaultScheduleEndTime, "20:00" ); + +// ----------------------------------------------------------------------------- +// CIMPSAlwaysOnlinePluginImp::CIMPSAlwaysOnlineScheduler +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CIMPSAlwaysOnlineScheduler::CIMPSAlwaysOnlineScheduler( TIMPSAOKeys& aKeys ) : + iScheduledLoginOk( EFalse ), + iKeys( aKeys ), + iSchedulingIsStarted( EFalse ), + iStartupCheckOngoing( EFalse ) + { + + } + +// ----------------------------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::ConstructL( ) + { + iSharedDataClient = + CIMPSSharedDataFactory::CreatePermanentKeyHandlerL( this, + KIMPSServSettUid ); + + iSettingChangesNotifier = + CIMPSSharedDataFactory::CreateTemporaryKeyHandlerL( this, + KIMPSServSettNotifyUid ); + + iTimer = CPEngAOPluginTimer::NewL(); + } + + + +// ----------------------------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CIMPSAlwaysOnlineScheduler* CIMPSAlwaysOnlineScheduler::NewL( TIMPSAOKeys& aKeys ) + { + CIMPSAlwaysOnlineScheduler* self = new( ELeave ) CIMPSAlwaysOnlineScheduler( aKeys ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + return self; + } + + +// Destructor +CIMPSAlwaysOnlineScheduler::~CIMPSAlwaysOnlineScheduler() + { + delete iSharedDataClient; + delete iSettingChangesNotifier; + delete iTimer; + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::StartScheduling +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::StartSchedulingL() + { + IMPSCUI_DP_FUNC_ENTER( "StartScheduling" ); + + if ( !iSchedulingIsStarted ) + { + iSchedulingIsStarted = ETrue; + iTimer->SetObserver( this ); + + CheckScheduledLoginSettings(); + + // start listening schedule change events + TInt err ( iSettingChangesNotifier->SubscribeSet( KIMPSServSettNotifyUid, + iKeys.ScheduleChangedKey() ) ); + if ( err ) + { + StopScheduling(); + User::Leave( err ); + } + } + IMPSCUI_DP_FUNC_DONE( "StartScheduling" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::StopScheduling +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::StopScheduling() + { + IMPSCUI_DP_FUNC_ENTER( "StopScheduling" ); + if ( iSchedulingIsStarted ) + { + + if ( iTimer->IsActive() ) + { + iTimer->Cancel(); + } + iTimer->SetObserver( NULL ); + + iSettingChangesNotifier->UnSubscribe( KIMPSServSettNotifyUid, + iKeys.ScheduleChangedKey() ); + + iScheduledLoginOk = EFalse; + iWaitReason = EIMPSAOSchedulerNotWaiting; + iSchedulingIsStarted = EFalse; + } + IMPSCUI_DP_FUNC_DONE( "StopScheduling" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::IsScheduledLoginOk() +// +// (other items were commented in a header). +// --------------------------------------------------------- +// +TBool CIMPSAlwaysOnlineScheduler::IsScheduledLoginOk() + { + return iScheduledLoginOk; + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::HandlePermanentKeyNotifyL() +// +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::HandlePermanentKeyNotifyL( const TUid /* aUid */, + const TIMPSSharedKeys /* aKey */ ) + { + IMPSCUI_DP_FUNC_ENTER( "HandlePermanentKeyNotifyL" ); + IMPSCUI_DP_FUNC_DONE( "HandlePermanentKeyNotifyL" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::HandleTemporaryKeyNotifyL() +// +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::HandleTemporaryKeyNotifyL( const TUid aUid, + const TIMPSSharedKeys aKey ) + { + IMPSCUI_DP_FUNC_ENTER( "HandleTemporaryKeyNotifyL" ); + + if ( ( aUid == KIMPSServSettNotifyUid ) && + ( aKey == iKeys.ScheduleChangedKey() ) ) + { + CheckScheduledLoginSettings(); + } + + IMPSCUI_DP_FUNC_DONE( "HandleTemporaryKeyNotifyL" ); + } + + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::HandleTimeWaitedL +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::HandleTimeWaited() + { + IMPSCUI_DP_FUNC_ENTER( "HandleTimeWaited" ); + // check settings again and need for restart wait timer + CheckScheduledLoginSettings(); + IMPSCUI_DP_FUNC_DONE( "HandleTimeWaited" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::HandleTimeWaitedError +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::HandleTimeWaitedError( TInt aError ) + { + IMPSCUI_DP_FUNC_ENTER( "HandleTimeWaitedError" ); + if ( aError != KErrCancel ) + { + CheckScheduledLoginSettings(); + } + IMPSCUI_DP_FUNC_DONE( "HandleTimeWaitedError" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::SetObserverL +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::SetObserver( MIMPSScheduleObserver *aSchObserver ) + { + IMPSCUI_DP_FUNC_ENTER( "SetObserver" ); + iScheduleObserver = aSchObserver; + IMPSCUI_DP_FUNC_DONE( "SetObserver" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::CheckScheduledLoginSettingsL +// Checks the scheduling settings +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::CheckScheduledLoginSettings() + { + IMPSCUI_DP_FUNC_ENTER( "CheckScheduledLoginSettings" ); + // get the connection days + TInt connectionDays( ResolveConnectionDays() ); + if ( connectionDays == EWVSettingsNone ) + { + SetScheduledLogin( EFalse, EIMPSAOSchedulerNotWaiting ); + IMPSCUI_DP_FUNC_DONE( "CheckScheduledLoginSettings" ); + return; + } + + // get current hometime + // used also as the general waiting time, so we won't need yet another TTime + // instance and so that the switch-case looks a bit prettier + TTime currentTime; + currentTime.HomeTime(); + + TDateTime curTime( currentTime.DateTime() ); + + IMPSCUI_DP( D_IMPSCUI_LIT( "current day [%d], month [%d]" ), curTime.Day() + 1, + curTime.Month() + 1 ); + IMPSCUI_DP( D_IMPSCUI_LIT( "current hour [%d], minu [%d]" ), curTime.Hour(), + curTime.Minute() ); + TInt today( currentTime.DayNoInWeek() ); + TTime connectionStartTime; + TTime connectionEndTime; + TInt schState( FindNextConnectionHours( currentTime, + connectionStartTime, + connectionEndTime ) ); + + IMPSCUI_DP( D_IMPSCUI_LIT( "schedule state = %d" ), schState ); + + TTimeIntervalDays untilChange( 0 ); + switch ( schState ) + { + // start time and end time are same + case EIMPSAOPluginAlldayConnection: + { + if ( ResolveIfConnectionToday( today, connectionDays ) ) + { + // setting next checking time next day start time + SetScheduledLogin( ETrue, EIMPSAOSchedulerWaitingForAllDayConnRefresh ); + untilChange = 1; + currentTime = ( connectionStartTime + untilChange ); + } + else + { + // setting next checking time to next connection day + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = FindNextConnectionChangeDay( today, connectionDays, ETrue ); + currentTime = ( connectionStartTime + untilChange ); + } + break; + } + + // current time is < start time + case EIMPSAOPluginNormalBeforeConnection: + { + if ( ResolveIfConnectionToday( today, connectionDays ) ) + { + // setting next checking to current day connection start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + currentTime = connectionStartTime; + } + else + { + // setting next checking time to next connection day start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = ( FindNextConnectionChangeDay( ( today + 1 ), connectionDays, ETrue ) ); + currentTime = ( connectionStartTime + untilChange ); + } + break; + } + + // current time is between start and end time + case EIMPSAOPluginNormalDuringConnection: + { + if ( ResolveIfConnectionToday( today, connectionDays ) ) + { + // setting next checking to current day connection end time + SetScheduledLogin( ETrue, EIMPSAOSchedulerWaitingForDisconnect ); + currentTime = connectionEndTime; + } + else + { + // setting next checking to next connection day start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = FindNextConnectionChangeDay( today, connectionDays, ETrue ); + currentTime = ( connectionStartTime + untilChange ); + } + break; + } + + // current time is more than end time + case EIMPSAOPluginNormalAfterConnection: + { + if ( ResolveIfConnectionToday( today + 1, connectionDays ) ) + { + // setting next checking to next day connection start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = 1; + currentTime = ( connectionStartTime + untilChange ); + } + else + { + // setting next checking to next connection day start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = ( FindNextConnectionChangeDay( today + 1, connectionDays, ETrue ) + 1 ); + currentTime = ( connectionStartTime + untilChange ); + } + break; + } + + // current time is between start and end time, + // start time < 00:00, current time and endtime > 00:00 + case EIMPSAOPluginOvernightOldConnection: + { + if ( ResolveIfConnectionToday( ( today - 1 ), connectionDays ) ) + { + // setting next checking to current day connection end time + SetScheduledLogin( ETrue, EIMPSAOSchedulerWaitingForDisconnect ); + currentTime = connectionEndTime; + } + else + { + // setting next checking to next connection day start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = ( FindNextConnectionChangeDay( today + 1, connectionDays, ETrue ) + 1 ); + currentTime = ( connectionStartTime + untilChange ); + } + break; + } + + // current time is > end time + case EIMPSAOPluginOvernightNoConnection: + { + // setting next checking to next connection day start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = FindNextConnectionChangeDay( today, connectionDays, ETrue ); + currentTime = ( connectionStartTime + untilChange ); + break; + } + + // current time is between start and end time, + // start time and current time < 00:00, endtime > 00:00 + case EIMPSAOPluginOvernightNewConnection: + { + if ( ResolveIfConnectionToday( today, connectionDays ) ) + { + // setting next checking to next day connection end time + SetScheduledLogin( ETrue, EIMPSAOSchedulerWaitingForDisconnect ); + untilChange = 1; + currentTime = ( connectionEndTime + untilChange ); + } + else + { + // setting next checking to next connection day start time + SetScheduledLogin( EFalse, EIMPSAOSchedulerWaitingForReconnect ); + untilChange = ( FindNextConnectionChangeDay( today, connectionDays, ETrue ) ); + currentTime = ( connectionStartTime + untilChange ); + } + break; + } + + default: + { + SetScheduledLogin( EFalse, EIMPSAOSchedulerNotWaiting ); + IMPSCUI_DP_FUNC_DONE( "CheckScheduledLoginSettings" ); + return; + } + + } + + StartTimer( currentTime ); + IMPSCUI_DP_FUNC_DONE( "CheckScheduledLoginSettings" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::ResolveIfConnectionToday +// +// --------------------------------------------------------- +// +TBool CIMPSAlwaysOnlineScheduler::ResolveIfConnectionToday( TInt aToday, + TInt aConnectionDays ) + { + TBool retVal( EFalse ); + // this is needed because the method is used for checking yesterdays also + // + // to monday + if ( aToday < EMonday ) + { + aToday = ESunday; + } + + switch ( aToday ) + { + case EMonday: + { + if ( aConnectionDays & EWVSettingsMonday ) + { + retVal = ETrue; + } + break; + } + case ETuesday: + { + if ( aConnectionDays & EWVSettingsTuesday ) + { + retVal = ETrue; + } + break; + } + case EWednesday: + { + if ( aConnectionDays & EWVSettingsWednesday ) + { + retVal = ETrue; + } + break; + } + case EThursday: + { + if ( aConnectionDays & EWVSettingsThursday ) + { + retVal = ETrue; + } + break; + } + case EFriday: + { + if ( aConnectionDays & EWVSettingsFriday ) + { + retVal = ETrue; + } + break; + } + case ESaturday: + { + if ( aConnectionDays & EWVSettingsSaturday ) + { + retVal = ETrue; + } + break; + } + case ESunday: + { + if ( aConnectionDays & EWVSettingsSunday ) + { + retVal = ETrue; + } + break; + } + default: + { + // retVal keeped as false + break; + } + } + + return retVal; + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::ResolveConnectionDays +// +// --------------------------------------------------------- +// +TInt CIMPSAlwaysOnlineScheduler::ResolveConnectionDays() + { + TInt connectionDays( KErrNotFound ); + + //check if getting the connection day went ok + if ( iSharedDataClient->GetIntKey( iKeys.ConnDaysKey(), connectionDays ) != KErrNone ) + { + // if there was an error reading form the shared data file, set to UI spec default + connectionDays = EWVSettingsAll; + } + if ( ( connectionDays < EWVSettingsNone ) || + ( connectionDays > EWVSettingsAll ) ) + { + // if the found value was an invalid one, set it to default value + connectionDays = EWVSettingsAll; + } + + return connectionDays; + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::FindNextConnectionChangeDay +// +// --------------------------------------------------------- +// +TInt CIMPSAlwaysOnlineScheduler::FindNextConnectionChangeDay( TInt aToday, + TInt aConnectionDays, + TBool aFindConnectionDay ) + { + // first search for the connection day from the end of the week + // but skip the first day (=today) + TBool dayFound( EFalse ); + TInt dayIndex; + for ( dayIndex = aToday; dayIndex <= ESunday; dayIndex++ ) + { + if ( aFindConnectionDay ) + { + if ( ResolveIfConnectionToday( dayIndex, aConnectionDays ) ) + { + dayFound = ETrue; + break; + } + } + else + { + if ( !ResolveIfConnectionToday( dayIndex, aConnectionDays ) ) + { + dayFound = ETrue; + break; + } + } + } + + // connection day wasn't found on the end part of the week, + // check next the beginning of the week until today + if ( !dayFound ) + { + for ( dayIndex = EMonday; dayIndex <= aToday; dayIndex++ ) + { + if ( aFindConnectionDay ) + { + if ( ResolveIfConnectionToday( dayIndex, aConnectionDays ) ) + { + dayFound = ETrue; + break; + } + } + else + { + if ( !ResolveIfConnectionToday( dayIndex, aConnectionDays ) ) + { + dayFound = ETrue; + break; + } + } + } + } + + // next connection change wasn't found at all, return an error + if ( !dayFound ) + { + return KErrNotFound; + } + else + { + // calculate the amount of days until the next connection event + if ( dayIndex >= aToday ) + { + dayIndex = ( dayIndex - aToday ); + } + else + { + // 7 is the number of days in a week + dayIndex = ( 7 - ( aToday - dayIndex ) ); + } + } + + return dayIndex; + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::FindNextConnectionHours +// +// --------------------------------------------------------- +// +TInt CIMPSAlwaysOnlineScheduler::FindNextConnectionHours( TTime aTimeNow, + TTime& aStartTime, + TTime& aEndTime ) + { + TIMPSAOPluginScheduleState scheduleState( EIMPSAOPluginInvalidSchedule ); + TTime comparableTime; + // convert the current time to the format we use here + TBuf tmpBufStart; + TBuf tmpBufEnd; + + // parse the current time + comparableTime = aTimeNow; + + // resolve the next connection time + // check first if the time can be found + if ( ( iSharedDataClient->GetStringKey( iKeys.ConnStartKey(), tmpBufStart ) != KErrNone ) || + ( iSharedDataClient-> GetStringKey( iKeys.ConnEndKey(), tmpBufEnd ) != KErrNone ) ) + { + // we did not get the times, set the defaults + tmpBufStart = KDefaultScheduleStartTime(); + tmpBufEnd = KDefaultScheduleEndTime(); + } + + // there was a normal connection schedule + aStartTime.HomeTime(); + aEndTime.HomeTime(); + + TDateTime dateTime = aStartTime.DateTime(); + // get the start time + // read the hour part of the time + TInt connStartHour = Hour( tmpBufStart, KDefaultStartHour ); + dateTime.SetHour( connStartHour ); + // read the minute part of the time + TInt connStartMinute = Minute( tmpBufStart, KDefaultMinute ); + dateTime.SetMinute( connStartMinute ); + // set the start time + aStartTime = dateTime; + + // get the end time + // read the hour part + TInt connEndHour = Hour( tmpBufEnd, KDefaultEndHour ); + dateTime.SetHour( connEndHour ); + // read the minute part + TInt connEndMinute = Minute( tmpBufEnd, KDefaultMinute ); + dateTime.SetMinute( connEndMinute ); + // set the end time + aEndTime = dateTime; + + // now check the connection start and end times and the state of the + // connection + TTimeIntervalMinutes minuteInterval; + // case 1: all day schedule + if ( aStartTime == aEndTime ) + { + scheduleState = EIMPSAOPluginAlldayConnection; + MinutesInterval( aStartTime, comparableTime, minuteInterval ); + aStartTime = ( aTimeNow + minuteInterval ); + MinutesInterval( aEndTime, comparableTime, minuteInterval ); + aEndTime = ( aTimeNow + minuteInterval ); + } + // case 2: normal schedule + else if ( aStartTime < aEndTime ) + { + // case 2a: about to make a login + if ( comparableTime < aStartTime ) + { + scheduleState = EIMPSAOPluginNormalBeforeConnection; + MinutesInterval( aStartTime, comparableTime, minuteInterval ); + aStartTime = ( aTimeNow + minuteInterval ); + } + + else + { + // case 2b: between start and end times + if ( comparableTime < aEndTime ) + { + scheduleState = EIMPSAOPluginNormalDuringConnection; + MinutesInterval( aStartTime, comparableTime, minuteInterval ); + aStartTime = ( aTimeNow + minuteInterval ); + MinutesInterval( aEndTime, comparableTime, minuteInterval ); + aEndTime = ( aTimeNow + minuteInterval ); + } + // case 2c: connection over for today + else // ( aEndTime <= comparableTime ) + { + scheduleState = EIMPSAOPluginNormalAfterConnection; + MinutesInterval( aStartTime, comparableTime, minuteInterval ); + aStartTime = ( aTimeNow + minuteInterval ); + } + } + + } + // case 3: overnight schedule + else + { + // case 3a: connection not ended yet + if ( comparableTime < aEndTime ) + { + scheduleState = EIMPSAOPluginOvernightOldConnection; + MinutesInterval( aStartTime, comparableTime, minuteInterval ); + aStartTime = ( aTimeNow + minuteInterval ); + MinutesInterval( aEndTime, comparableTime, minuteInterval ); + aEndTime = ( aTimeNow + minuteInterval ); + } + + else + { + // case 3b: time between connections + if ( comparableTime < aStartTime ) + { + scheduleState = EIMPSAOPluginOvernightNoConnection; + MinutesInterval( aStartTime, comparableTime, minuteInterval ); + aStartTime = ( aTimeNow + minuteInterval ); + } + // case 3c: connection started again + else // ( aStartTime <= comparableTime ) + { + scheduleState = EIMPSAOPluginOvernightNewConnection; + MinutesInterval( aStartTime, comparableTime, minuteInterval ); + aStartTime = ( aTimeNow + minuteInterval ); + MinutesInterval( aEndTime, comparableTime, minuteInterval ); + aEndTime = ( aTimeNow + minuteInterval ); + } + } + } + + return scheduleState; + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::Hour() +// +// (other items were commented in a header). +// --------------------------------------------------------- +// +TInt CIMPSAlwaysOnlineScheduler::Hour( const TDesC& aTime, TInt aDefault ) + { + TPtrC hourPtr( aTime.Left( KTimeValueLength ) ); + + TLex lex( hourPtr ); + TInt hourInt ( aDefault ); + // we can ignore the error, if it fails we set the default + lex.Val( hourInt ); + return hourInt; + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::Minute() +// +// (other items were commented in a header). +// --------------------------------------------------------- +TInt CIMPSAlwaysOnlineScheduler::Minute( const TDesC& aTime, TInt aDefault ) + { + TPtrC minPtr( aTime.Right( KTimeValueLength ) ); + TLex lex( minPtr ); + TInt minuteInt ( aDefault ); + // we can ignore the error, if it fails we set the default + lex.Val( minuteInt ); + return minuteInt; + } + + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::SetScheduledLogin +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::SetScheduledLogin( TBool aIsScheduledLoginOk, + TIMPSAOSchedulerWaitReason aReason ) + { + IMPSCUI_DP_FUNC_ENTER( "SetScheduledLogin" ); + IMPSCUI_DP( D_IMPSCUI_LIT( "aIsScheduledLoginOK = %d" ), aIsScheduledLoginOk ); + IMPSCUI_DP( D_IMPSCUI_LIT( "aReason = %d" ), aReason ); + TBool prevScheduledLoginOK( iScheduledLoginOk ); + iScheduledLoginOk = aIsScheduledLoginOk; + iWaitReason = aReason; + + if ( iScheduleObserver && !iStartupCheckOngoing && + ( ( prevScheduledLoginOK != iScheduledLoginOk ) || + ( aReason == EIMPSAOSchedulerWaitingForAllDayConnRefresh ) ) ) + { + iScheduleObserver->HandleScheduleEvent( iScheduledLoginOk ); + } + IMPSCUI_DP_FUNC_DONE( "SetScheduledLogin" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::StartTimer +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::StartTimer( TTime aTime ) + { + IMPSCUI_DP_FUNC_ENTER( "StartTimer" ); + if ( iTimer->IsActive() ) + { + iTimer->Cancel(); + } + + TDateTime launchTime( aTime.DateTime() ); + IMPSCUI_DP( D_IMPSCUI_LIT( "Waiting for [%d] at:" ), iWaitReason ); + IMPSCUI_DP( D_IMPSCUI_LIT( "year [%d] " ), launchTime.Year() ); + IMPSCUI_DP( D_IMPSCUI_LIT( "day [%d], month [%d]" ), launchTime.Day() + 1, + launchTime.Month() + 1 ); + IMPSCUI_DP( D_IMPSCUI_LIT( "hour [%d], minu [%d]" ), launchTime.Hour(), + launchTime.Minute() ); + + iTimer->At( aTime ); + IMPSCUI_DP_FUNC_DONE( "StartTimer" ); + } + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::ParseTime +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::ParseTime( TTime& aTime, + const TDesC& aTimeString ) + { + if ( aTime.Parse( aTimeString ) < KErrNone ) + { + User::Panic( KIMPSAOPluginPanicCategory, ETimeParsingFailed ); + } + } + + +// --------------------------------------------------------- +// CIMPSAlwaysOnlineScheduler::ParseTime +// +// --------------------------------------------------------- +// +void CIMPSAlwaysOnlineScheduler::MinutesInterval( TTime aTime, + TTime aComparableTime, + TTimeIntervalMinutes& aInterval ) + { + if ( aTime.MinutesFrom( aComparableTime, aInterval ) != KErrNone ) + { + User::Panic( KIMPSAOPluginPanicCategory, + ETimeIntervalCalculationFailed ); + } + }