Bug 3539. Update localisation mappings.
/*
* 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<KTimeStringMaxLength> tmpBufStart;
TBuf<KTimeStringMaxLength> 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 );
}
}