diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlanengine/wlan_symbian/wlanengine_symbian_3.1/src/wlanbgscan.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlanengine/wlan_symbian/wlanengine_symbian_3.1/src/wlanbgscan.cpp Tue Feb 02 02:03:13 2010 +0200 @@ -0,0 +1,854 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* 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. +* +*/ + +/* +* %version: 12 % +*/ + +#include +#include + +#include "wlanscanproviderinterface.h" +#include "awsinterface.h" +#include "awsenginebase.h" +#include "wlancbwaiter.h" +#include "wlanbgscanawscomms.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. + */ +_LIT( KWlanBgScanDateTimeFormat, "%F %*E %*N %D %H:%T:%S" ); + +/** + * Maximun length for date time debug string. + */ +const TInt KWlanBgScanMaxDateTimeStrLen = 50; +#endif + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// CWlanBgScan::CWlanBgScan +// --------------------------------------------------------------------------- +// +CWlanBgScan::CWlanBgScan( MWlanScanResultProvider& aProvider, CWlanTimerServices& aTimerServices ) : + iProvider ( aProvider ), + iCurrentBgScanInterval( 0 ), + iAwsComms( NULL ), + iBgScanState( EBgScanOff ), + iAutoPeriod( EAutoPeriodNone ), + iTimerServices( aTimerServices ), + iIntervalChangeRequestId( 0 ), + iBgScanPeakStartTime( 0 ), + iBgScanPeakEndTime( 0 ), + iBgScanIntervalPeak( 0 ), + iBgScanIntervalOffPeak( 0 ) + { + DEBUG( "CWlanBgScan::CWlanBgScan()" ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::ConstructL +// --------------------------------------------------------------------------- +// +void CWlanBgScan::ConstructL() + { + DEBUG( "CWlanBgScan::ConstructL()" ); + + // create AWS comms interface + TRAPD( err, iAwsComms = CWlanBgScanAwsComms::NewL( *this ) ); + if( err != KErrNone ) + { + if( iAwsComms ) + { + delete iAwsComms; + iAwsComms = NULL; + } + 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 +// --------------------------------------------------------------------------- +// +CWlanBgScan* CWlanBgScan::NewL( MWlanScanResultProvider& aProvider, CWlanTimerServices& aTimerServices ) + { + DEBUG( "CWlanBgScan::NewL()" ); + CWlanBgScan* self = new ( ELeave ) CWlanBgScan( aProvider, aTimerServices ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::~CWlanBgScan +// --------------------------------------------------------------------------- +// +CWlanBgScan::~CWlanBgScan() + { + DEBUG( "CWlanBgScan::CWlanBgScan()" ); + } + +// --------------------------------------------------------------------------- +// From class MWlanBgScanProvider. +// CWlanBgScan::ScanComplete +// --------------------------------------------------------------------------- +// +void CWlanBgScan::ScanComplete() + { + DEBUG1( "CWlanBgScan::ScanComplete() - current interval %us", GetInterval() ); + + if ( GetInterval() != KWlanBgScanIntervalNever ) + { + DEBUG1( "CWlanBgScan::ScanComplete() - issue a new request with %us as expiry", GetInterval() ); + iProvider.Scan( GetInterval() ); + } + } + +// --------------------------------------------------------------------------- +// From class MWlanBgScanProvider. +// CWlanBgScan::IntervalChanged +// --------------------------------------------------------------------------- +// +void CWlanBgScan::IntervalChanged( TUint32 aNewInterval ) + { + DEBUG1( "CWlanBgScan::IntervalChanged() - aNewInterval %u", aNewInterval ); + + NextState( aNewInterval ); + + DEBUG2( "CWlanBgScan::IntervalChanged() - current interval %u, current state %u", + GetInterval(), + iBgScanState ); + } + +// --------------------------------------------------------------------------- +// From class MWlanBgScanProvider. +// CWlanBgScan::NotConnected +// --------------------------------------------------------------------------- +// +void CWlanBgScan::NotConnected() + { + DEBUG1( "CWlanBgScan::NotConnected() - current interval %us", GetInterval() ); + + if ( GetInterval() != KWlanBgScanIntervalNever ) + { + 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", + ( GetInterval() != KWlanBgScanIntervalNever ) ? 1 : 0 ); + + return ( GetInterval() != KWlanBgScanIntervalNever ); + } + +// --------------------------------------------------------------------------- +// 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; + CheckSettings( settingsToUse, aSettings ); + + iBgScanPeakStartTime = settingsToUse.bgScanPeakStartTime; + iBgScanPeakEndTime = settingsToUse.bgScanPeakEndTime; + iBgScanIntervalPeak = settingsToUse.bgScanIntervalPeak; + iBgScanIntervalOffPeak = settingsToUse.bgScanIntervalOffPeak; + + IntervalChanged( settingsToUse.backgroundScanInterval ); + + if( IsAwsPresent() ) + { + CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::ESetPowerSaveMode, aSettings.psmServerMode }; + iAwsComms->SendOrQueueAwsCommand( msg ); + } + } + +// --------------------------------------------------------------------------- +// 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::GetInterval +// --------------------------------------------------------------------------- +// +TUint32 CWlanBgScan::GetInterval() + { + return iCurrentBgScanInterval; + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::SetInterval +// --------------------------------------------------------------------------- +// +void CWlanBgScan::SetInterval( TUint32 aInterval ) + { + iCurrentBgScanInterval = aInterval; + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::IsIntervalChangeNeeded +// --------------------------------------------------------------------------- +// +TBool CWlanBgScan::IsIntervalChangeNeeded() + { + TBool ret( ETrue ); + + // no need to change interval if both peak and off-peak intervals are the same + if( iBgScanPeakStartTime == iBgScanPeakEndTime ) + { + 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() ); + + switch( TimeRelationToRange( currentTime, iBgScanPeakStartTime, iBgScanPeakEndTime ) ) + { + case ESmaller: + { + change_time.SetHour( iBgScanPeakStartTime / KGetHours ); + change_time.SetMinute( iBgScanPeakStartTime % KGetHours ); + change_time.SetSecond( KZeroSeconds ); + currentTime = change_time; + break; + } + case EInsideRange: + { + change_time.SetHour( iBgScanPeakEndTime / KGetHours ); + change_time.SetMinute( iBgScanPeakEndTime % KGetHours ); + change_time.SetSecond( KZeroSeconds ); + currentTime = change_time; + if( iBgScanPeakStartTime > iBgScanPeakEndTime ) + { + DEBUG( "CWlanBgScan::AutoIntervalChangeAt() - peak end happens tomorrow" ); + currentTime += TTimeIntervalDays( KAddOneDay ); + } + else + { + DEBUG( "CWlanBgScan::AutoIntervalChangeAt() - peak end happens today" ); + } + break; + } + case EGreater: + { + change_time.SetHour( iBgScanPeakStartTime / KGetHours ); + change_time.SetMinute( iBgScanPeakStartTime % KGetHours ); + change_time.SetSecond( KZeroSeconds ); + currentTime = change_time; + currentTime += TTimeIntervalDays( KAddOneDay ); + break; + } + } + +#ifdef _DEBUG + change_time = currentTime.DateTime(); + TBuf 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 dbgString; + TRAP_IGNORE( aTime.FormatL( dbgString, KWlanBgScanDateTimeFormat ) ); + DEBUG1( "CWlanBgScan::TimeRelationToRange() - time: %S", &dbgString ); +#endif + + TTime time( aTime ); + + TDateTime start_time( aTime.DateTime() ); + start_time.SetHour( aRangeStart / KGetHours ); + start_time.SetMinute( aRangeStart % KGetHours ); + start_time.SetSecond( KZeroSeconds ); + + if( aRangeStart > aRangeEnd ) + { + DEBUG( "CWlanBgScan::TimeRelationToRange() - end time of range must to be tomorrow" ); + if( time.DayNoInMonth() == ( time.DaysInMonth() - 1 ) ) + { + DEBUG( "CWlanBgScan::TimeRelationToRange() - last day of the month, move to next month" ); + time += TTimeIntervalMonths( 1 ); + DEBUG( "CWlanBgScan::TimeRelationToRange() - move to first day of the month" ); + TDateTime new_time( time.DateTime() ); + new_time.SetDay( 0 ); + + time = TTime( new_time ); + } + else + { + DEBUG( "CWlanBgScan::TimeRelationToRange() - add one day to end time" ); + time += TTimeIntervalDays( KAddOneDay ); + } + } + + TDateTime end_time( time.DateTime() ); + end_time.SetHour( aRangeEnd / KGetHours ); + end_time.SetMinute( aRangeEnd % KGetHours ); + end_time.SetSecond( KZeroSeconds ); + +#ifdef _DEBUG + TBuf rngStart, rngEnd; + TRAP_IGNORE( TTime( start_time ).FormatL( rngStart, KWlanBgScanDateTimeFormat ) ); + TRAP_IGNORE( TTime( end_time ).FormatL( rngEnd, KWlanBgScanDateTimeFormat ) ); + DEBUG2( "CWlanBgScan::TimeRelationToRange() - range: %S - %S", &rngStart, &rngEnd ); +#endif + + CWlanBgScan::TRelation relation( ESmaller ); + if( aTime < TTime( start_time ) ) + { + DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: ESmaller" ); + relation = ESmaller; + } + else if( aTime >= TTime( start_time ) && aTime < TTime( end_time ) ) + { + DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EInsideRange" ); + relation = EInsideRange; + } + else + { + DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" ); + relation = EGreater; + } + + return relation; + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::CurrentAutoInterval +// --------------------------------------------------------------------------- +// +TUint32 CWlanBgScan::CurrentAutoInterval() + { + TUint32 interval( 0 ); + TTime currentTime; + currentTime.HomeTime(); + + if( TimeRelationToRange( currentTime, iBgScanPeakStartTime, iBgScanPeakEndTime ) == CWlanBgScan::EInsideRange ) + { + interval = iBgScanIntervalPeak; + } + else + { + interval = iBgScanIntervalOffPeak; + } + + DEBUG1( "CWlanBgScan::CurrentAutoInterval() - current interval: %u", interval ); + + return interval; + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::NextState +// --------------------------------------------------------------------------- +// +void CWlanBgScan::NextState( TUint32 aNewBgScanSetting ) + { + DEBUG1( "CWlanBgScan::NextState() - aNewBgScanSetting %u", aNewBgScanSetting ); + + switch ( iBgScanState ) + { + case EBgScanOff: + { + InStateOff( iBgScanState, aNewBgScanSetting ); + break; + } + case EBgScanOn: + { + InStateOn( iBgScanState, aNewBgScanSetting ); + break; + } + case EBgScanAuto: + { + InStateAuto( iBgScanState, aNewBgScanSetting ); + break; + } + case EBgScanAutoAws: + { + InStateAutoAws( iBgScanState, aNewBgScanSetting ); + break; + } + default: + { + ASSERT( 0 ); + break; + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::InStateOff +// --------------------------------------------------------------------------- +// +void CWlanBgScan::InStateOff( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) + { + switch( aNewBgScanSetting ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScan::InStateOff() - no change in the interval" ); + aState = EBgScanOff; + break; + } + case KWlanBgScanIntervalAutomatic: + { + if ( IsAwsPresent() ) + { + DEBUG( "CWlanBgScan::InStateOff() - state change Off to AutoAws" ); + + aState = EBgScanAutoAws; + DEBUG( "CWlanBgScan::InStateOff() - calling SendOrQueueAwsCommand()" ); + CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStart, 0 }; + iAwsComms->SendOrQueueAwsCommand( msg ); + DEBUG( "CWlanBgScan::InStateOff() - SendOrQueueAwsCommand() returned" ); + } + else + { + DEBUG( "CWlanBgScan::InStateOff() - state change Off to Auto" ); + DEBUG( "CWlanBgScan::InStateOff() - * determine next interval change time and request callback" ); + ScheduleAutoIntervalChange(); + SetInterval( CurrentAutoInterval() ); + if( GetInterval() != KWlanBgScanIntervalNever ) + { + DEBUG( "CWlanBgScan::InStateOff() - * cause immediate background scan" ); + NotConnected(); + } + else + { + DEBUG( "CWlanBgScan::InStateOff() - Auto interval zero, background scanning is off" ); + } + aState = EBgScanAuto; + } + break; + } + default: + { + DEBUG1( "CWlanBgScan::InStateOff() - state change Off to On (interval: %u)", aNewBgScanSetting ); + SetInterval( aNewBgScanSetting ); + // cause immediate background scan + NotConnected(); + aState = EBgScanOn; + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::InStateOn +// --------------------------------------------------------------------------- +// +void CWlanBgScan::InStateOn( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) + { + switch( aNewBgScanSetting ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScan::InStateOn() - state change On to Off" ); + SetInterval( KWlanBgScanIntervalNever ); + iProvider.CancelScan(); + aState = EBgScanOff; + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScan::InStateOn() - state change On to Auto" ); + SetInterval( KWlanBgScanIntervalNever ); + iProvider.CancelScan(); + if ( IsAwsPresent() ) + { + aState = EBgScanAutoAws; + DEBUG( "CWlanBgScan::InStateOn() - calling SendOrQueueAwsCommand()" ); + CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStart, 0 }; + iAwsComms->SendOrQueueAwsCommand( msg ); + DEBUG( "CWlanBgScan::InStateOn() - SendOrQueueAwsCommand() returned" ); + } + else + { + DEBUG( "CWlanBgScan::InStateOn() - * determine next interval change time and request callback" ); + ScheduleAutoIntervalChange(); + SetInterval( CurrentAutoInterval() ); + if( GetInterval() != KWlanBgScanIntervalNever ) + { + DEBUG( "CWlanBgScan::InStateOn() - * cause immediate background scan" ); + NotConnected(); + } + else + { + DEBUG( "CWlanBgScan::InStateOn() - Auto interval zero, background scanning is off" ); + } + aState = EBgScanAuto; + } + break; + } + default: + { + DEBUG( "CWlanBgScan::InStateOn() - state change On to On" ); + if ( GetInterval() == aNewBgScanSetting ) + { + DEBUG( "CWlanBgScan::InStateOn() - no change in the interval" ); + } + else if ( GetInterval() > aNewBgScanSetting ) + { + DEBUG( "CWlanBgScan::InStateOn() - current interval greater than the new interval" ); + DEBUG( "CWlanBgScan::InStateOn() - * cancel scan and cause immediate background scan" ); + iProvider.CancelScan(); + SetInterval( aNewBgScanSetting ); + NotConnected(); + } + else + { + DEBUG( "CWlanBgScan::InStateOn() - current interval smaller than the new interval" ); + DEBUG( "CWlanBgScan::InStateOn() - * cancel scan and issue new with interval as expiry" ); + iProvider.CancelScan(); + SetInterval( aNewBgScanSetting ); + ScanComplete(); + } + aState = EBgScanOn; + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::InStateAuto +// --------------------------------------------------------------------------- +// +void CWlanBgScan::InStateAuto( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) + { + switch( aNewBgScanSetting ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScan::InStateAuto() - state change Auto to Off" ); + SetInterval( KWlanBgScanIntervalNever ); + iTimerServices.StopTimer( iIntervalChangeRequestId ); + iIntervalChangeRequestId = 0; + iProvider.CancelScan(); + aState = EBgScanOff; + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScan::InStateAuto() - state still Auto" ); + + ScheduleAutoIntervalChange(); + + TUint32 currentInterval = GetInterval(); + + TUint32 autoInterval = CurrentAutoInterval(); + + if ( autoInterval == KWlanBgScanIntervalNever ) + { + DEBUG( "CWlanBgScan::InStateAuto() - Auto interval zero, background scanning is off" ); + DEBUG( "CWlanBgScan::InStateAuto() - * cancel scan" ); + iProvider.CancelScan(); + SetInterval( autoInterval ); + } + else if ( currentInterval == autoInterval ) + { + DEBUG( "CWlanBgScan::InStateAuto() - no change in the Auto interval" ); + } + else if ( currentInterval > autoInterval ) + { + DEBUG( "CWlanBgScan::InStateAuto() - current Auto interval greater than the new Auto interval" ); + DEBUG( "CWlanBgScan::InStateAuto() - * cancel scan and issue new with immediate expiry" ); + iProvider.CancelScan(); + SetInterval( autoInterval ); + NotConnected(); + } + else + { + DEBUG( "CWlanBgScan::InStateAuto() - current Auto interval smaller than the new Auto interval" ); + DEBUG( "CWlanBgScan::InStateAuto() - * cancel scan and issue new with interval expiry" ); + iProvider.CancelScan(); + SetInterval( autoInterval ); + ScanComplete(); + } + + aState = EBgScanAuto; + break; + } + default: + { + DEBUG( "CWlanBgScan::InStateAuto() - state change Auto to On" ); + SetInterval( aNewBgScanSetting ); + iTimerServices.StopTimer( iIntervalChangeRequestId ); + iIntervalChangeRequestId = 0; + // need to issue new scan request as it is possible that currently there is + // no scan requested + iProvider.CancelScan(); + NotConnected(); + aState = EBgScanOn; + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::InStateAutoAws +// --------------------------------------------------------------------------- +// +void CWlanBgScan::InStateAutoAws( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) + { + switch( aNewBgScanSetting ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScan::InStateAutoAws() - state change Auto to Off" ); + SetInterval( KWlanBgScanIntervalNever ); + aState = EBgScanOff; + DEBUG( "CWlanBgScan::InStateAutoAws() - calling SendOrQueueAwsCommand()" ); + CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStop, 0 }; + iAwsComms->SendOrQueueAwsCommand( msg ); + DEBUG( "CWlanBgScan::InStateAutoAws() - SendOrQueueAwsCommand() returned" ); + iProvider.CancelScan(); + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScan::InStateAutoAws() - no change in the interval" ); + aState = EBgScanAutoAws; + break; + } + default: + { + DEBUG( "CWlanBgScan::InStateAutoAws() - state change Auto to On" ); + SetInterval( aNewBgScanSetting ); + aState = EBgScanOn; + // need to issue new scan request as it is possible that currently there is + // no scan requested + DEBUG( "CWlanBgScan::InStateAutoAws() - calling SendAwsCommand()" ); + CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStop, 0 }; + iAwsComms->SendOrQueueAwsCommand( msg ); + DEBUG( "CWlanBgScan::InStateAutoAws() - SendAwsCommand() returned" ); + iProvider.CancelScan(); + NotConnected(); + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::Timeout +// --------------------------------------------------------------------------- +// +void CWlanBgScan::OnTimeout() + { + DEBUG( "CWlanBgScan::OnTimeout()" ); + + // by design, OnTimeout should only happen + // in Auto state + ASSERT( iBgScanState == EBgScanAuto ); + + NextState( KWlanBgScanIntervalAutomatic ); + + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::DoSetInterval +// --------------------------------------------------------------------------- +// +void CWlanBgScan::DoSetInterval( TUint32 aNewInterval ) + { + DEBUG1( "CWlanBgScan::DoSetInterval( aNewInterval: %u )", aNewInterval ); + + if( iBgScanState != EBgScanAutoAws ) + { + DEBUG( "CWlanBgScan::DoSetInterval() - state not AutoAws, ignoring request" ); + return; + } + + TUint32 currentInterval( GetInterval() ); + + if ( ( currentInterval == 0 ) && ( aNewInterval != 0 ) ) + { + DEBUG( "CWlanBgScan::DoSetInterval() - current interval is zero and new interval is non-zero" ); + DEBUG( "CWlanBgScan::DoSetInterval() - cancel scan and issue new with immediate expiry" ); + iProvider.CancelScan(); + SetInterval( aNewInterval ); + NotConnected(); + } + else if ( currentInterval == aNewInterval ) + { + DEBUG( "CWlanBgScan::DoSetInterval() - no change in the interval" ); + } + else if ( currentInterval > aNewInterval ) + { + // if current interval greater than new interval -> cancel scan and + // issue new with immediate expiry + DEBUG( "CWlanBgScan::DoSetInterval() - current interval greater than the new interval" ); + DEBUG( "CWlanBgScan::DoSetInterval() - cancel scan and issue new with immediate expiry" ); + iProvider.CancelScan(); + SetInterval( aNewInterval ); + NotConnected(); + } + else + { + DEBUG( "CWlanBgScan::DoSetInterval() - current interval smaller than the new interval" ); + DEBUG( "CWlanBgScan::DoSetInterval() - take new interval into use after currently pending scan is completed" ); + SetInterval( aNewInterval ); + } + + } + +// --------------------------------------------------------------------------- +// CWlanBgScan::IsAwsPresent +// -------------------------------------------------------------------------- +// +TBool CWlanBgScan::IsAwsPresent() + { + TBool ret( ETrue ); + + if( iAwsComms == NULL || !iAwsComms->IsAwsPresent() ) + { + ret = EFalse; + } + + DEBUG1( "CWlanBgScan::IsAwsPresent() - returning %i", ret ); + + return ret; + }