/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  This class implements WLAN background scan logic.

*

*/

/*

*/

#include <e32base.h>

#include <e32const.h> 

#include "wlanscanproviderinterface.h"

#include "awsinterface.h"

#include "awsenginebase.h"

#include "wlanbgscan.h"

#include "wlandevicesettings.h" // default values in case invalid data is passed in NotifyChangedSettings

#include "am_debug.h"

/**

 * One day to be added to TTime.

 */

const TInt KAddOneDay = 1;

/**

 * Get hours from CenRep variable.

 */

const TInt KGetHours = 100;

/**

 * Zero seconds.

 */

const TInt KZeroSeconds = 0;

/**

 * Last minute of a day.

 */

const TInt KWlanBgScanTwentyThreeFiftyNineOclock = 2359;

/**

 * Maximun interval for background scan.

 */

const TInt KWlanBgScanMaxInterval = 1800;

#ifdef _DEBUG

/**

 * Formatting of date time debug string.

 */

/**

 * Maximun length for date time debug string.

 */

const TInt KWlanBgScanMaxDateTimeStrLen = 50;

#endif

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

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

// CWlanBgScan::CWlanBgScan

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

//

    iProvider ( aProvider ),

    iAwsComms( NULL ),

    iAutoPeriod( EAutoPeriodNone ),

    {

    DEBUG( "CWlanBgScan::CWlanBgScan()" );

    }

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

// CWlanBgScan::ConstructL

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

//

void CWlanBgScan::ConstructL()

    {

    DEBUG( "CWlanBgScan::ConstructL()" );

    // create AWS comms interface

    if( err != KErrNone )

        {

        DEBUG1( "CWlanBgScan::ConstructL() - AWS comms creation failed with code %i", err );

        }

    else

        {

        DEBUG( "CWlanBgScan::ConstructL() - AWS comms creation successful" );

        }

    DEBUG( "CWlanBgScan::ConstructL() - done" );    

    }

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

// CWlanBgScan::NewL

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

//

    {

    DEBUG( "CWlanBgScan::NewL()" );

    CWlanBgScan* self = new ( ELeave ) CWlanBgScan( aProvider, aTimerServices );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

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

// CWlanBgScan::~CWlanBgScan

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

//

CWlanBgScan::~CWlanBgScan()

    {

    }

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

// From class MWlanBgScanProvider.

// CWlanBgScan::ScanComplete

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

//

void CWlanBgScan::ScanComplete()

    {

    }

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

// From class MWlanBgScanProvider.

// CWlanBgScan::NotConnected

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

//

void CWlanBgScan::NotConnected()

    {

        {

        DEBUG( "CWlanBgScan::NotConnected() - issue a new request with immediate expiry" );

        iProvider.Scan( KWlanBgScanMaxDelayExpireImmediately );

        }

    }

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

// From class MWlanBgScanProvider.

// CWlanBgScan::IsBgScanEnabled

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

//

TBool CWlanBgScan::IsBgScanEnabled()

    {

    // If ( interval != never )                              -> Return True

    // Otherwise                                             -> return False

    DEBUG1( "CWlanBgScan::IsBgScanEnabled() - returning %u", 

    }

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

// From class MWlanBgScanProvider.

// CWlanBgScan::NotifyChangedSettings

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

//

void CWlanBgScan::NotifyChangedSettings( MWlanBgScanProvider::TWlanBgScanSettings& aSettings )

    {

    DEBUG6( "CWlanBgScan::NotifyChangedSettings( interval: %u, psm srv mode: %u, peak start: %04u, peak end: %04u, peak: %u, off-peak: %u )",

            aSettings.backgroundScanInterval,

            aSettings.psmServerMode,

            aSettings.bgScanPeakStartTime,

            aSettings.bgScanPeakEndTime,

            aSettings.bgScanIntervalPeak,

            aSettings.bgScanIntervalOffPeak);

    MWlanBgScanProvider::TWlanBgScanSettings settingsToUse;

        {

        }

    }

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

// CWlanBgScan::CheckSettings

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

//

void CWlanBgScan::CheckSettings(

        MWlanBgScanProvider::TWlanBgScanSettings& aSettingsToUse,                   // [OUT]

        const MWlanBgScanProvider::TWlanBgScanSettings& aProposedSettings ) const   // [IN]

    {

    aSettingsToUse = aProposedSettings;

    if( aSettingsToUse.bgScanPeakStartTime > KWlanBgScanTwentyThreeFiftyNineOclock ||

        aSettingsToUse.bgScanPeakEndTime > KWlanBgScanTwentyThreeFiftyNineOclock )

        {

        DEBUG2( "CWlanBgScan::CheckSettings() - peak start or end invalid, using default values (start %u, end %u)",

                KWlanDefaultBgScanPeakPeriodStart,

                KWlanDefaultBgScanPeakPeriodEnd );

        aSettingsToUse.bgScanPeakStartTime = KWlanDefaultBgScanPeakPeriodStart;

        aSettingsToUse.bgScanPeakEndTime = KWlanDefaultBgScanPeakPeriodEnd;

        }

    if( aSettingsToUse.bgScanIntervalPeak > KWlanBgScanMaxInterval )

        {

        DEBUG1( "CWlanBgScan::CheckSettings() - peak interval invalid, using default value %u",

                KWlanDefaultBgScanIntervalPeakPeriod );

        aSettingsToUse.bgScanIntervalPeak = KWlanDefaultBgScanIntervalPeakPeriod;

        }

    if( aSettingsToUse.bgScanIntervalOffPeak > KWlanBgScanMaxInterval )

        {

        DEBUG1( "CWlanBgScan::CheckSettings() - off-peak interval invalid, using default value %u",

                KWlanDefaultBgScanIntervalOffPeakPeriod );

        aSettingsToUse.bgScanIntervalOffPeak = KWlanDefaultBgScanIntervalOffPeakPeriod;

        }    

    }

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

// CWlanBgScan::IsIntervalChangeNeeded

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

//

TBool CWlanBgScan::IsIntervalChangeNeeded()

    {

    TBool ret( ETrue );

    // no need to change interval if both peak and off-peak intervals are the same

        {

        ret = EFalse;

        }

    DEBUG1( "CWlanBgScan::IsIntervalChangeNeeded() - returning %d", ret );

    return ret;    

    }

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

// CWlanBgScan::ScheduleAutoIntervalChange

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

//

void CWlanBgScan::ScheduleAutoIntervalChange()

    {

    DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange()" );

    iTimerServices.StopTimer( iIntervalChangeRequestId );

    if( IsIntervalChangeNeeded() )

        {

        TTime intervalChangeAt = AutoIntervalChangeAt();

        if( KErrNone != iTimerServices.StartTimer( iIntervalChangeRequestId, intervalChangeAt, *this ) )

            {

            DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange() - error: requesting timeout failed, peak <-> off-peak interval will not be changed" );

            }

        }

    else

        {

        DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange() - peak <-> off-peak interval change not needed" );

        }

    DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange() - returning" );

    }

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

// CWlanBgScan::AutoIntervalChangeAt

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

//

TTime CWlanBgScan::AutoIntervalChangeAt()

    {

    TTime currentTime;

    currentTime.HomeTime();

    TDateTime change_time( currentTime.DateTime() );

        {

        case ESmaller:

            {

            change_time.SetSecond( KZeroSeconds );

            currentTime = change_time;

            break;

            }

        case EInsideRange:

            {

            change_time.SetSecond( KZeroSeconds );

            currentTime = change_time;

                {

                DEBUG( "CWlanBgScan::AutoIntervalChangeAt() - peak end happens tomorrow" );

                currentTime += TTimeIntervalDays( KAddOneDay );

                }

            else

                {

                DEBUG( "CWlanBgScan::AutoIntervalChangeAt() - peak end happens today" );

                }

            break;

            }

        case EGreater:

            {

            change_time.SetSecond( KZeroSeconds );

            currentTime = change_time;

            currentTime += TTimeIntervalDays( KAddOneDay );

            break;

            }

        }

#ifdef _DEBUG

    change_time = currentTime.DateTime();

    TBuf<KWlanBgScanMaxDateTimeStrLen> dbgString;

    TRAP_IGNORE( currentTime.FormatL( dbgString, KWlanBgScanDateTimeFormat ) );

    DEBUG1( "CWlanBgScan::AutoIntervalChangeAt() - interval change to occur: %S", &dbgString );

#endif

    return currentTime;

    }

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

// CWlanBgScan::TimeRelationToRange

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

//

CWlanBgScan::TRelation CWlanBgScan::TimeRelationToRange( const TTime& aTime, TUint aRangeStart, TUint aRangeEnd ) const

    {

#ifdef _DEBUG

    TBuf<KWlanBgScanMaxDateTimeStrLen> dbgString;

    DEBUG1( "CWlanBgScan::TimeRelationToRange() - time:  %S", &dbgString );

#endif

        {

            {

            }

        else

            {

            }

        }

    else

        {

        }

    return relation;

    }

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

// CWlanBgScan::CurrentAutoInterval

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

//

TUint32 CWlanBgScan::CurrentAutoInterval()

    {

    TUint32 interval( 0 );

    TTime currentTime;

    currentTime.HomeTime();

        {

        }

    else

        {       

        }

    DEBUG1( "CWlanBgScan::CurrentAutoInterval() - current interval: %u", interval );

    return interval;

    }

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

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

//

    {

    }

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

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

//

void CWlanBgScan::OnTimeout()

    {

    DEBUG( "CWlanBgScan::OnTimeout()" );

    }

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

// CWlanBgScan::DoSetInterval

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

//

void CWlanBgScan::DoSetInterval( TUint32 aNewInterval )

    {

    DEBUG1( "CWlanBgScan::DoSetInterval( aNewInterval: %u )", aNewInterval );

        {