/*

* Copyright (c) 2008 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:  Content Manager server's scheduler component

*

*/

// INCLUDE FILES

#include <apgtask.h>

#include "cmsettings.h"

#include "cmcommonutils.h"

#include "cmscheduler.h"

#include "mediaservantuid.h"

#include "cmcommsdbnotifier.h"

#include "cmcenrepnotifier.h"

#include "msdebug.h"

// WLAN scanning interval [s]

const TInt

    KTimerInterval = 30 * 60 * 1000 * 1000; // 30 minutes in microseconds

const TInt KTimerCount = 2; // KTimerCount*KTimerInterval = 1 hour

const TUid KMediaServantUid = { KMediaServantUID3 }; // application uid

const TInt KOfflineProfile = 5; // offline profile identifier

// ========================== MEMBER FUNCTIONS ===============================

// Two-phased constructor.

EXPORT_C CCmScheduler* CCmScheduler::NewL(

    MCmServiceObserver& aServer, MCmSettings& aSettings)

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::NewL"));

    CCmScheduler* self = new ( ELeave )

        CCmScheduler( aServer, aSettings );

    self->ConstructL();

    return self;

    }

// Destructor

CCmScheduler::~CCmScheduler()

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::~CCmScheduler"));

    Cancel();

    delete iNotifier;

    delete iRepositoryNotifier;

    iConnMon.CancelNotifications();

    iConnMon.Close();

    iTimer.Close();

    }

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

// CCmScheduler::CCmScheduler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCmScheduler::CCmScheduler(

    MCmServiceObserver& aServer, MCmSettings& aSettings)

    : CActive( EPriorityStandard ),

    iServer( aServer ), iSettings( aSettings ),

    iScheduledServiceRunning( EFalse ), iEnabled( ETrue ),

    iState( ECmScStateOffline ), iTimerCount( 0 ),

    iServiceToExecute( ECmServicePreProcessingStore ),

    iExecuteHarvest( ETrue ), iSchedulerInitiated( EFalse )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::CCmScheduler()"));

    }

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

// CCmScheduler::ConstructL()

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

//

void CCmScheduler::ConstructL()

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::ConstructL"));

    // Ensure that iap is set. Otherwise scheduler cannot be used

#ifdef __DEBUG

    TInt iap( 0 );

    User::LeaveIfError( iSettings.GetIapL( iap ) );

    TRACE( Print( _L("[Cm Scheduler]\t IAP to use is  %d"), iap));

#endif

    User::LeaveIfError( iTimer.CreateLocal() );

    CActiveScheduler::Add( this );

    iEnabled = EFalse;

    iRepositoryNotifier = CCmCenrepNotifier::NewL( *this );

    User::LeaveIfError( iRepositoryNotifier->GetCurrentProfile(

                        iCurrentProfile ) );

    // create commsdb notifier

    TRAPD( error, iNotifier = CCmCommsDbNotifier::NewL( *this ) );

    if ( !error )

        {

        iWlanScanState = iNotifier->WlanScanStateL();

        }

    else

        {

        TRACE( Print( _L("[Cm Scheduler]\t CCmScheduler::ConstructL \

        error = %d"), error));

        }

    // check that mc is not in offline mode

    if ( iCurrentProfile != KOfflineProfile )

        {

        iState = ECmScStateOnline;

        if ( error == KErrNone )

            {

            // We assume that scan is off.

            // State is checked and if it is on wlan events can be used.

            if ( iNotifier->HasScanStateChangedL() )

                {

                LOG(_L("[Cm Scheduler]\t CCmScheduler::ConstructL() \

                    Scanning state changed on"));

                // scanning is on

                SetEnabledL( ETrue );

                }

            else

                {

                LOG(_L("[Cm Scheduler]\t CCmScheduler::ConstructL() \

                    Scanning state is off - starting timer"));

                // scanning is off - use timer

                TryToStartRetryTimer();

                }

            }

        else

            {

            LOG(_L("[Cm Scheduler]\t CCmScheduler::ConstructL() \

                Notifier creation failed"));

            // if notifier cannot be created we start the timer

            TryToStartRetryTimer();

            }

        }

    else

        {

        LOG(_L("[Cm Scheduler]\t CCmScheduler::ConstructL() \

            profile = offline"));

        }

    }

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

// CCmScheduler::EventL()

// Called when an event arrives to connection monitor

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

//

void CCmScheduler::EventL( const CConnMonEventBase& aConnMonEvent )

    {

    TRACE(Print(_L("[Cm Scheduler]\t CCmScheduler::EventL() \

        eventtype = %d, connection id = %d"),

        aConnMonEvent.EventType(), aConnMonEvent.ConnectionId()));

    TTime currentTime;

    currentTime.HomeTime();

    TTimeIntervalHours interval;

    currentTime.HoursFrom( iLastSyncTime, interval );

    TRACE(Print(_L("[Cm Scheduler]\t CCmScheduler::EventL() \

	    hours from last sync = %d"), interval.Int()));

    if ( interval.Int() >= 1 && !ApplicationRunning() )

        {

        HandleConnectionEventL( aConnMonEvent );

        }

    }

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

// CCmScheduler::HandleConnectionEventL()

// Handles connection event

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

//

void CCmScheduler::HandleConnectionEventL(

                            const CConnMonEventBase& aConnMonEvent )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::HandleConnectionEventL() \

	    HandleConnectionEventL"));

    if ( aConnMonEvent.EventType() == EConnMonIapAvailabilityChange )

        {

        LOG(_L("[Cm Scheduler]\t CCmScheduler::HandleConnectionEventL() \

            EConnMonIapAvailabilityChange"));

        TCmSchedulerState newState = ECmScStateOffline;

        if ( CheckIapAvailabilityL( aConnMonEvent ) )

            {

            newState = ECmScStateOnline;

            }

        if ( newState != iState )

            {

            iState = newState;

            if ( newState && !iScheduledServiceRunning )

                {

                LOG(_L("[Cm Scheduler]\t State changed to online,\

                    starting operation.."));

                iSchedulerInitiated = ETrue;// do also harvest

                TRACE( Print( _L("[Cm Scheduler]\t HandleConnectionEventL \

                    iSchedulerInitiated = %d"), iSchedulerInitiated));

                iExecuteHarvest = ETrue;

                TRACE( Print( _L("[Cm Scheduler]\t HandleConnectionEventL \

                    iExecuteHarvest = %d"), iExecuteHarvest));

                TryToExecuteService( iServiceToExecute );

                }

            else

                {

                LOG(_L("[Cm Scheduler]\t State changed to offline,\

                    canceling timer.."));

                CancelTimer();

                }

            }

        }

    }

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

// CCmScheduler::RunL()

// Called when the timer elapses

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

//

void CCmScheduler::RunL()

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::RunL()"));

    TRACE( Print( _L("[Cm Scheduler]\t status %d"), iStatus.Int() ));

    TRACE( Print( _L("[Cm Scheduler]\t state %d"), iState ));

    if ( KErrNone == iStatus.Int() &&

         iState == ECmScStateOnline &&

         !iScheduledServiceRunning )

        {

        if ( ++iTimerCount >= KTimerCount && !ApplicationRunning() )

            {

            LOG(_L("[Cm Scheduler]\t Online timer passed, \

                starting operation.."));

            iSchedulerInitiated = ETrue;// do also harvest

            TRACE( Print( _L("[Cm Scheduler]\t RunL \

                iSchedulerInitiated = %d"), iSchedulerInitiated));

            iExecuteHarvest = ETrue;

            TRACE( Print( _L("[Cm Scheduler]\t RunL \

                iExecuteHarvest = %d"), iExecuteHarvest));

            TryToExecuteService( iServiceToExecute );

            }

        else

            {

            iTimer.After( iStatus,

                TTimeIntervalMicroSeconds32( KTimerInterval ) );

            SetActive();

            }

        }

    }

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

// CCmScheduler::TryToExecuteService()

// Starts process if application is not running

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

//

void CCmScheduler::TryToExecuteService( TCmService aService )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::TryToExecuteService()"));

    TInt err = KErrNone;

    TRAP( err, iServer.ExecuteServiceL( aService ));

    iScheduledServiceRunning = !err;

    if ( !err && aService == ECmServicePreProcessingStore )

        {

        iStorePreprocessed = EFalse;

        }

    TRACE( Print( _L("[Cm Scheduler]\t ExecuteServiceL err: %d"), err));

    if ( err )

        {

        TryToStartRetryTimer();

        }

    }

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

// CCmScheduler::TryToStartRetryTimer()

// Starts timer if not already active

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

//

void CCmScheduler::TryToStartRetryTimer()

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::TryToStartRetryTimer()"));

    if ( !IsActive() )

        {

        LOG(_L("[Cm Scheduler]\t starting one hour resync timer.."));

        CancelTimer();

        iTimer.After(

                iStatus, TTimeIntervalMicroSeconds32( KTimerInterval ));

        SetActive();

        }

    }

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

// CCmScheduler::CancelTimer()

// Cancels timer

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

//

void CCmScheduler::CancelTimer()

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::CancelTimer"));

    iTimer.Cancel();

    iTimerCount = 0;

    }

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

// CCmScheduler::SetEnabledL()

// Enabled/disabled connection monitor events

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

//

EXPORT_C void CCmScheduler::SetEnabledL( TBool aEnable )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::SetEnabled()"));

    if ( iEnabled != aEnable )

        {

        iEnabled = aEnable;

        if ( iEnabled )

            {

            LOG(_L("[Cm Scheduler]\t enabling scheduler.."));

            LOG(_L("[Cm Scheduler]\t starting to listen wlan events.."));

            User::LeaveIfError( iConnMon.ConnectL() );

            iConnMon.NotifyEventL( *this );

            }

         else // iConnMon is connected when entering here...

            {

            LOG(_L("[Cm Scheduler]\t disabling scheduler.."));

            iConnMon.CancelNotifications();

            iConnMon.Close();

            }

        }

    }

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

// CCmScheduler::SetServiceToExecute

// Sets service to be executed

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

//

EXPORT_C void CCmScheduler::SetServiceToExecute( TCmService aService )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::SetServiceToExecute()"));

    iServiceToExecute = aService;

    }

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

// CCmScheduler::ServiceExecuted

// Called when service is ready

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

//

EXPORT_C void CCmScheduler::ServiceExecuted( TCmService aService, TInt aErr )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::ServiceExecuted()"));

    TRACE( Print( _L("[Cm Scheduler]\t service %d err %d"),

        aService, aErr));

    if ( !iScheduledServiceRunning )

        {

        LOG(_L("[Cm Scheduler]\t No scheduled service running, returning"));

        return;

        }

    iScheduledServiceRunning = EFalse;

    TBool startRetryTimer( EFalse );

    if ( aErr )

        {

        startRetryTimer = ETrue;

        }

    else

        {

        switch ( aService )

            {

            case ECmServicePreProcessingStore:

                {

                if ( iStorePreprocessed == EFalse )

                    {

                    iStorePreprocessed = ETrue;

                    TryToExecuteService( ECmServiceStore );

                    }

                else

                    {

                    iLastSyncTime.HomeTime();

                    startRetryTimer = ETrue;

                    iSchedulerInitiated = EFalse;

                    }

                break;

                }

            case ECmServiceStore:

                {

                // execute fill

                TryToExecuteService( ECmServiceFill );

                break;

                }

            case ECmServiceFill:

                {

                if ( iExecuteHarvest )

                    {

                    TRACE( Print( _L("[Cm Scheduler]\t serviceexecuted \

                        harvest %d schedulerinitiated %d"),

                        iExecuteHarvest, iSchedulerInitiated));

                    // execute harvest

                    TryToExecuteService( ECmServiceHarvest );

                    }

                else

                    {

                    LOG(_L("[Cm Scheduler]\t CCmScheduler::ServiceExecuted \

                        ExecuteHarvest = EFalse"));

                    startRetryTimer = ETrue;

                    iLastSyncTime.HomeTime();

                    iSchedulerInitiated = EFalse;

                    TRACE( Print( _L("[Cm Scheduler]\t ServiceExecuted \

                         iSchedulerInitiated = %d"), iSchedulerInitiated));

                    }

                break;

                }

            case ECmServiceHarvest:

            // fall through

            case ECmServicePreProcessingFill:

                {

                iSchedulerInitiated = EFalse;

                TRACE( Print( _L("[Cm Scheduler]\t ServiceExecuted \

                    iSchedulerInitiated = %d"), iSchedulerInitiated));

                startRetryTimer = ETrue;

                iLastSyncTime.HomeTime();

                break;

                }

            default:

                {

                LOG(_L("[Cm Scheduler]\t default"));

                break;

                }

            }

        }

    if ( startRetryTimer )

        {

        TryToStartRetryTimer();

        }

    }

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

// CCmScheduler::DoCancel

// Called by framework when timer is cancelled

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

//

void CCmScheduler::DoCancel()

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::DoCancel()"));

    CancelTimer();

    }

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

// CCmScheduler::WlanScanStateChanged

// starts/disables timer and connection monitor events depending on state

// of wlan scanning interval

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

//

void CCmScheduler::WlanScanStateChanged( TInt aState )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::WlanScanStateChanged()"));

    iWlanScanState = aState;

    if ( iCurrentProfile != KOfflineProfile )

        {

        if ( aState == KWlanScanNetworkNever )

            {

            TRAP_IGNORE( SetEnabledL( EFalse ) );

            // state is set online so we can try start process

            iState = ECmScStateOnline;

            TryToStartRetryTimer();

            }

        else

            {

            // cancel timer

            CancelTimer();

            TRAP_IGNORE( SetEnabledL( ETrue ) );

            }

        }

    }

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

// CCmScheduler::ProfileChangedL

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

//

void CCmScheduler::ProfileChangedL( TInt aProfile )

    {

    LOG(_L("[Cm Scheduler]\t CCmScheduler::ProfileChangedL()"));

    if ( aProfile == KOfflineProfile )

        {

        LOG(_L("[Cm Scheduler]\t CCmScheduler::ProfileChangedL() \

            offline"));

        iCurrentProfile = aProfile;

        // disable wlan scanning

        CmCommonUtils::SetWlanScanL( KWlanScanNetworkNever );

        // stop receiving events