/*

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

        }