diff -r c40eb8fe8501 -r 6524e815f76f wlan_bearer/wlanengine/wlan_symbian/wlanengine_symbian_3.1/src/wlanbgscanstates.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlanengine/wlan_symbian/wlanengine_symbian_3.1/src/wlanbgscanstates.cpp Sat Feb 20 00:38:18 2010 +0200 @@ -0,0 +1,883 @@ +/* +* Copyright (c) 2009-2010 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: 2 % +*/ + +#include +#include + +#include "wlanscanproviderinterface.h" +#include "awsinterface.h" +#include "awsenginebase.h" +#include "wlancbwaiter.h" +#include "wlanbgscanawscommsinterface.h" +#include "wlanbgscan.h" +#include "wlanbgscanstates.h" +#include "wlandevicesettings.h" // default values in case invalid data is passed in NotifyChangedSettings +#include "wlantimer.h" +#include "am_debug.h" + +/** Constant indicating that scanning is disabled */ +const TUint32 KWlanNoScanning( 0xFFFFFFFF ); + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::CWlanBgScanStates +// --------------------------------------------------------------------------- +// +CWlanBgScanStates::CWlanBgScanStates( CWlanBgScan& aBgScan, MWlanScanResultProvider& aProvider, MWlanTimerServices& aTimerServices ) : + iBgScan( aBgScan ), + iUsedBgScanInterval( KWlanNoScanning ), + iBgScanInterval( KWlanNoScanning ), + iAggressiveBgScanInterval( KWlanNoScanning ), + iAggressiveBgScanTimer( NULL ), + iNextState( EBgScanStateMax ), + iAwsStartupStatus( KErrNotFound ), + iAwsCmd( MWlanBgScanAwsComms::EAwsCommandMax ), + iAwsCmdStatus( KErrNone ), + iAutoInterval( KWlanBgScanIntervalNever ), + iProvider( aProvider ), + iTimerServices( aTimerServices ), + iBgScanState( EBgScanStateMax ), + iIntervalChangeRequestId( 0 ), + iCompletedAwsCommand( MWlanBgScanAwsComms::EAwsCommandMax ), + iAwsCommandCompletionCode( KErrNone ) + { + DEBUG( "CWlanBgScanStates::CWlanBgScanStates()" ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::ConstructL +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::ConstructL() + { + DEBUG( "CWlanBgScanStates::ConstructL()" ); + + if( iBgScan.AwsPresence() == CWlanBgScan::EAwsStarting ) + { + DEBUG( "CWlanBgScanStates::ConstructL() - AWS starting up, goto Init state" ); + iBgScanState = EBgScanInit; + } + else + { + DEBUG( "CWlanBgScanStates::ConstructL() - AWS not present, goto Off state" ); + iBgScanState = EBgScanOff; + } + + // Create a timer for guarding when to drop out of aggressive BG scan mode + iAggressiveBgScanTimer = CWlanTimer::NewL( TCallBack( StopAggressiveBgScan, this ), + TCallBack( StopAggressiveBgScan, this ), + TCallBack( StopAggressiveBgScan, this ) ); + + DEBUG( "CWlanBgScanStates::ConstructL() - done" ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::~CWlanBgScanStates +// --------------------------------------------------------------------------- +// +CWlanBgScanStates::~CWlanBgScanStates() + { + DEBUG( "CWlanBgScanStates::~CWlanBgScanStates()" ); + delete iAggressiveBgScanTimer; + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StartAggressiveBgScan +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StartAggressiveBgScan( TUint32& aInterval, TUint32& aDuration ) + { + DEBUG3( "CWlanBgScanStates::StartAggressiveBgScan() - new interval: %u, old interval: %u, duration: %u", + aInterval, iAggressiveBgScanInterval, aDuration ); + // Serve the request only if the requested interval is smaller or equal than + // what is already being served + if( aInterval <= iAggressiveBgScanInterval ) + { + iAggressiveBgScanInterval = aInterval; + + // Start the timer guarding when to drop out of aggressive mode + iAggressiveBgScanTimer->Cancel(); + iAggressiveBgScanTimer->After( aDuration ); + + // Refresh interval used in BG scanning + RefreshUsedInterval(); + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StopAggressiveBgScan +// --------------------------------------------------------------------------- +// +TInt CWlanBgScanStates::StopAggressiveBgScan( TAny* aPtr ) + { + DEBUG( "CWlanBgScanStates::StopAggressiveBgScan()" ); + + CWlanBgScanStates* self = static_cast( aPtr ); + + // Disable aggressive mode + self->iAggressiveBgScanInterval = KWlanNoScanning; + + // Refresh interval used in BG scanning + self->RefreshUsedInterval(); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::GetBgInterval +// --------------------------------------------------------------------------- +// +TUint32 CWlanBgScanStates::GetBgInterval() + { + TUint32 scanInterval( iUsedBgScanInterval ); + + if( scanInterval == KWlanNoScanning ) + { + scanInterval = KWlanBgScanIntervalNever; + } + + return scanInterval; + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::IntervalChanged +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::IntervalChanged() + { + DEBUG( "CWlanBgScanStates::IntervalChanged()" ); + + if( iBgScan.AwsPresence() == CWlanBgScan::EAwsStarting ) + { + DEBUG( "CWlanBgScanStates::IntervalChanged() - AWS is still starting up, returning" ); + return; + } + + NextState( CWlanBgScanStates::EBgScanEventIntervalChanged ); + + DEBUG2( "CWlanBgScanStates::IntervalChanged() - current interval %u, current state %u", + GetBgInterval(), + iBgScanState ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::NextState +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::NextState( const CWlanBgScanStates::TWlanBgScanSmEvent& aEvent ) + { + DEBUG1( "CWlanBgScanStates::NextState() - aEvent %u", aEvent ); + + switch ( iBgScanState ) + { + case EBgScanInit: + { + InStateInit( iBgScanState, aEvent ); + break; + } + case EBgScanOff: + { + InStateOff( iBgScanState, aEvent ); + break; + } + case EBgScanOn: + { + InStateOn( iBgScanState, aEvent ); + break; + } + case EBgScanAuto: + { + InStateAuto( iBgScanState, aEvent ); + break; + } + case EBgScanAutoAws: + { + InStateAutoAws( iBgScanState, aEvent ); + break; + } + case EBgScanSendingAwsCmd: + { + InStateSendingAwsCmd( iBgScanState, aEvent ); + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::NextState() - error: invalid state %d", iBgScanState ); + ASSERT( 0 ); + break; + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::InStateInit +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::InStateInit( TWlanBgScanState& aState, const CWlanBgScanStates::TWlanBgScanSmEvent& aEvent ) + { + switch( aEvent ) + { + case CWlanBgScanStates::EBgScanEventAwsStartupComplete: + { + DEBUG( "CWlanBgScanStates::InStateInit() - event: EBgScanEventAwsStartupComplete" ); + switch( AwsStartupStatus() ) + { + case KErrNone: + { + DEBUG( "CWlanBgScanStates::InStateInit() - AWS startup successful" ); + switch ( iBgScanSettings.backgroundScanInterval ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScanStates::InStateInit() - state change Init to Off" ); + StateChangeInitToOff( aState ); + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScanStates::InStateInit() - state change Init to AutoAws" ); + StateChangeInitToAutoAws( aState ); + break; + } + default: + { + DEBUG( "CWlanBgScanStates::InStateInit() - state change Init to On" ); + StateChangeInitToOn( aState ); + } + } + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateInit() - AWS startup failed! Status %d", AwsStartupStatus() ); + switch ( iBgScanSettings.backgroundScanInterval ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScanStates::InStateInit() - state change Init to Off" ); + StateChangeInitToOff( aState ); + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScanStates::InStateInit() - state change Init to Auto" ); + StateChangeInitToAuto( aState ); + break; + } + default: + { + DEBUG( "CWlanBgScanStates::InStateInit() - state change Init to On" ); + StateChangeInitToOn( aState ); + break; + } + } + break; + } + } + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateInit() - event %d ignored", aEvent ); + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeInitToOn +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeInitToOn( TWlanBgScanState& aState ) + { + DEBUG( "CWlanBgScanStates::StateChangeInitToOn()" ); + aState = EBgScanOn; + SetInterval( iBgScanSettings.backgroundScanInterval ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeInitToOff +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeInitToOff( TWlanBgScanState& aState ) + { + DEBUG( "CWlanBgScanStates::StateChangeInitToOff()" ); + aState = EBgScanOff; + SetInterval( KWlanBgScanIntervalNever ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeInitToAuto +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeInitToAuto( TWlanBgScanState& aState ) + { + aState = EBgScanAuto; + DEBUG( "CWlanBgScanStates::StateChangeInitToAuto() - determine next interval change time and request callback" ); + iBgScan.ScheduleAutoIntervalChange(); + SetInterval( iBgScan.CurrentAutoInterval() ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::InStateOff +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::InStateOff( TWlanBgScanState& aState, const CWlanBgScanStates::TWlanBgScanSmEvent& aEvent ) + { + switch( aEvent ) + { + case CWlanBgScanStates::EBgScanEventIntervalChanged: + { + DEBUG( "CWlanBgScanStates::InStateOff() - event: EBgScanEventIntervalChanged" ); + switch( iBgScanSettings.backgroundScanInterval ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScanStates::InStateOff() - no change in the interval" ); + aState = EBgScanOff; + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScanStates::InStateOff() - state change Off to Automatic" ); + StateChangeOffToAutomatic( aState ); + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateOff() - state change Off to On (interval: %u)", iBgScanSettings.backgroundScanInterval ); + StateChangeOffToOn( aState, iBgScanSettings.backgroundScanInterval ); + } + } + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateOff() - event %d ignored", aEvent ); + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeOffToOn +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeOffToOn( TWlanBgScanState& aState, TUint32 aNewBgScanInterval ) + { + aState = EBgScanOn; + SetInterval( aNewBgScanInterval ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeOffToAutomatic +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeOffToAutomatic( TWlanBgScanState& aState ) + { + if ( iBgScan.AwsPresence() == CWlanBgScan::EAwsPresent ) + { + DEBUG( "CWlanBgScanStates::StateChangeOffToAutomatic() - state change Off to SendingAwsCmd" ); + aState = EBgScanSendingAwsCmd; + DEBUG( "CWlanBgScanStates::InStaStateChangeOffToAutomaticteOff() - if command sending succeeds, next state is AutoAws" ); + iNextState = EBgScanAutoAws; + MWlanBgScanAwsComms::TAwsMessage msg = { MWlanBgScanAwsComms::EStart, 0 }; + iBgScan.AwsCommand( msg ); + DEBUG( "CWlanBgScanStates::StateChangeOffToAutomatic() - SendOrQueueAwsCommand() returned" ); + } + else + { + DEBUG( "CWlanBgScanStates::StateChangeOffToAutomatic() - state change Off to Auto" ); + DEBUG( "CWlanBgScanStates::StateChangeOffToAutomatic() - determine next interval change time and request callback" ); + aState = EBgScanAuto; + iBgScan.ScheduleAutoIntervalChange(); + SetInterval( iBgScan.CurrentAutoInterval() ); + } + } +// --------------------------------------------------------------------------- +// CWlanBgScanStates::InStateOn +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::InStateOn( TWlanBgScanState& aState, const CWlanBgScanStates::TWlanBgScanSmEvent& aEvent ) + { + switch( aEvent ) + { + case CWlanBgScanStates::EBgScanEventIntervalChanged: + { + DEBUG( "CWlanBgScanStates::InStateOn() - event: EBgScanEventIntervalChanged" ); + switch( iBgScanSettings.backgroundScanInterval ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScanStates::InStateOn() - state change On to Off" ); + StateChangeOnToOff( aState ); + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScanStates::InStateOn() - state change On to Auto" ); + StateChangeOnToAutomatic( aState ); + break; + } + default: + { + DEBUG( "CWlanBgScanStates::InStateOn() - state change On to On" ); + StateChangeOnToOn( aState, iBgScanSettings.backgroundScanInterval ); + } + } + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateOn() - event %d ignored", aEvent ); + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeOnToOn +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeOnToOn( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) + { + aState = EBgScanOn; + SetInterval( aNewBgScanSetting ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeOnToAutomatic +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeOnToAutomatic( TWlanBgScanState& aState ) + { + if ( iBgScan.AwsPresence() == CWlanBgScan::EAwsPresent ) + { + DEBUG( "CWlanBgScanStates::StateChangeOnToAutomatic() - state change Init to SendingAwsCmd" ); + aState = EBgScanSendingAwsCmd; + DEBUG( "CWlanBgScanStates::StateChangeOnToAutomatic() - if command sending succeeds, next state is AutoAws" ); + iNextState = EBgScanAutoAws; + MWlanBgScanAwsComms::TAwsMessage msg = { MWlanBgScanAwsComms::EStart, 0 }; + iBgScan.AwsCommand( msg ); + DEBUG( "CWlanBgScanStates::StateChangeOnToAutomatic() - SendOrQueueAwsCommand() returned" ); + } + else + { + aState = EBgScanAuto; + iBgScan.ScheduleAutoIntervalChange(); + SetInterval( iBgScan.CurrentAutoInterval() ); + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeOnToOff +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeOnToOff( TWlanBgScanState& aState ) + { + aState = EBgScanOff; + SetInterval( KWlanBgScanIntervalNever ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::InStateAuto +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::InStateAuto( TWlanBgScanState& aState, const CWlanBgScanStates::TWlanBgScanSmEvent& aEvent ) + { + switch( aEvent ) + { + case CWlanBgScanStates::EBgScanEventIntervalChanged: + { + DEBUG( "CWlanBgScanStates::InStateAuto() - event: EBgScanEventIntervalChanged" ); + switch( iBgScanSettings.backgroundScanInterval ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScanStates::InStateAuto() - state change Auto to Off" ); + StateChangeAutoToOff( aState ); + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScanStates::InStateAuto() - state still Auto" ); + StateChangeAutoToAuto( aState ); + break; + } + default: + { + DEBUG( "CWlanBgScanStates::InStateAuto() - state change Auto to On" ); + StateChangeAutoToOn( aState, iBgScanSettings.backgroundScanInterval ); + } + } + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateAuto() - event %d ignored", aEvent ); + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeAutoToOff +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeAutoToOff( TWlanBgScanState& aState ) + { + aState = EBgScanOff; + iTimerServices.StopTimer( iIntervalChangeRequestId ); + iIntervalChangeRequestId = 0; + SetInterval( KWlanBgScanIntervalNever ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeAutoToAuto +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeAutoToAuto( TWlanBgScanState& aState ) + { + aState = EBgScanAuto; + iBgScan.ScheduleAutoIntervalChange(); + SetInterval( iBgScan.CurrentAutoInterval() ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeAutoToOn +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeAutoToOn( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) + { + aState = EBgScanOn; + iTimerServices.StopTimer( iIntervalChangeRequestId ); + iIntervalChangeRequestId = 0; + SetInterval( aNewBgScanSetting ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::InStateAutoAws +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::InStateAutoAws( TWlanBgScanState& aState, const CWlanBgScanStates::TWlanBgScanSmEvent& aEvent ) + { + switch( aEvent ) + { + case CWlanBgScanStates::EBgScanEventIntervalChanged: + { + DEBUG( "CWlanBgScanStates::InStateAutoAws() - event: EBgScanEventIntervalChanged" ); + switch( iBgScanSettings.backgroundScanInterval ) + { + case KWlanBgScanIntervalNever: + { + DEBUG( "CWlanBgScanStates::InStateAutoAws() - state change AutoAws to Off" ); + StateChangeAutoAwsToOff( aState ); + break; + } + case KWlanBgScanIntervalAutomatic: + { + DEBUG( "CWlanBgScanStates::InStateAutoAws() - no change in the interval" ); + aState = EBgScanAutoAws; + break; + } + default: + { + DEBUG( "CWlanBgScanStates::InStateAutoAws() - state change AutoAws to On" ); + StateChangeAutoAwsToOn( aState ); + } + } + break; + } + case CWlanBgScanStates::EBgScanEventAwsIntervalChanged: + { + DEBUG( "CWlanBgScanStates::InStateAutoAws() - event: EBgScanEventAwsIntervalChanged" ); + SetInterval( AutoInterval() ); + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateAutoAws() - event %d ignored", aEvent ); + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeAutoAwsToOff +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeAutoAwsToOff( TWlanBgScanState& aState ) + { + aState = EBgScanSendingAwsCmd; + iNextState = EBgScanOff; + DEBUG( "CWlanBgScanStates::StateChangeAutoAwsToOff() - calling SendOrQueueAwsCommand()" ); + MWlanBgScanAwsComms::TAwsMessage msg = { MWlanBgScanAwsComms::EStop, 0 }; + iBgScan.AwsCommand( msg ); + DEBUG( "CWlanBgScanStates::StateChangeAutoAwsToOff() - SendOrQueueAwsCommand() returned" ); + iProvider.CancelScan(); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeAutoAwsToOn +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeAutoAwsToOn( TWlanBgScanState& aState ) + { + aState = EBgScanSendingAwsCmd; + iNextState = EBgScanOn; + DEBUG( "CWlanBgScanStates::StateChangeAutoAwsToOn() - calling SendAwsCommand()" ); + MWlanBgScanAwsComms::TAwsMessage msg = { MWlanBgScanAwsComms::EStop, 0 }; + iBgScan.AwsCommand( msg ); + DEBUG( "CWlanBgScanStates::StateChangeAutoAwsToOn() - SendAwsCommand() returned" ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::InStateSendingAwsCmd +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::InStateSendingAwsCmd( TWlanBgScanState& aState, const CWlanBgScanStates::TWlanBgScanSmEvent& aEvent ) + { + DEBUG1( "CWlanBgScanStates::InStateSendingAwsCmd() - event: %d", aEvent ); + + switch( aEvent ) + { + case CWlanBgScanStates::EBgScanEventAwsCmdComplete: + { + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - event: EBgScanEventAwsCmdComplete" ); + switch( AwsCmdStatus() ) + { + case KErrNone: + { + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - AWS command sending successful" ); + switch ( iNextState ) + { + case EBgScanOff: + { + ASSERT( AwsCmd() == MWlanBgScanAwsComms::EStop ); + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - state change SendingAwsCmd to Off" ); + StateChangeSendingAwsCmdToOff( aState ); + break; + } + case EBgScanOn: + { + ASSERT( AwsCmd() == MWlanBgScanAwsComms::EStop ); + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - state change SendingAwsCmd to On" ); + StateChangeSendingAwsCmdToOn( aState ); + break; + } + case EBgScanAutoAws: + { + ASSERT( AwsCmd() == MWlanBgScanAwsComms::EStart ); + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - state change SendingAwsCmd to AutoAws" ); + StateChangeSendingAwsCmdToAutoAws( aState ); + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateSendingAwsCmd() - illegal state change from SendingAwsCmd to %u", iNextState ); + ASSERT( 0 ); + } + } + break; + } + default: + { + DEBUG2( "CWlanBgScanStates::InStateSendingAwsCmd() - AWS command %d sending failed! Status %d", AwsCmd(), AwsCmdStatus() ); + switch ( iNextState ) + { + case EBgScanOff: + { + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - state change SendingAwsCmd to Off" ); + StateChangeSendingAwsCmdToOff( aState ); + break; + } + case EBgScanOn: + { + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - state change SendingAwsCmd to On" ); + StateChangeSendingAwsCmdToOn( aState ); + break; + } + case EBgScanAutoAws: + { + DEBUG( "CWlanBgScanStates::InStateSendingAwsCmd() - state change SendingAwsCmd to Auto" ); + StateChangeSendingAwsCmdToAuto( aState ); + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateSendingAwsCmd() - illegal state change from SendingAwsCmd to %u", iNextState ); + ASSERT( 0 ); + } + } + break; + } + } + break; + } + default: + { + DEBUG1( "CWlanBgScanStates::InStateSendingAwsCmd() - event %d ignored", aEvent ); + } + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeInitToAutoAws +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeInitToAutoAws( TWlanBgScanState& aState ) + { + if ( iBgScan.AwsPresence() == CWlanBgScan::EAwsPresent ) + { + DEBUG( "CWlanBgScanStates::StateChangeInitToAutoAws() - state change Init to SendingAwsCmd" ); + aState = EBgScanSendingAwsCmd; + DEBUG( "CWlanBgScanStates::StateChangeInitToAutoAws() - if command sending succeeds, next state is AutoAws" ); + iNextState = EBgScanAutoAws; + MWlanBgScanAwsComms::TAwsMessage msg = { MWlanBgScanAwsComms::EStart, 0 }; + iBgScan.AwsCommand( msg ); + DEBUG( "CWlanBgScanStates::StateChangeInitToAutoAws() - SendOrQueueAwsCommand() returned" ); + } + else + { + DEBUG( "CWlanBgScanStates::StateChangeInitToAutoAws() - error: AWS not present!" ); + ASSERT( 0 ); + DEBUG( "CWlanBgScanStates::StateChangeInitToAutoAws() - state change Init to Auto" ); + aState = EBgScanAuto; + DEBUG( "CWlanBgScanStates::StateChangeInitToAutoAws() - * determine next interval change time and request callback" ); + iBgScan.ScheduleAutoIntervalChange(); + SetInterval( iBgScan.CurrentAutoInterval() ); + } + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeSendingAwsCmdToOff +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeSendingAwsCmdToOff( TWlanBgScanState& aState ) + { + DEBUG( "CWlanBgScanStates::StateChangeSendingAwsCmdToOff()" ); + aState = EBgScanOff; + SetInterval( KWlanBgScanIntervalNever ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeSendingAwsCmdToOn +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeSendingAwsCmdToOn( TWlanBgScanState& aState ) + { + DEBUG( "CWlanBgScanStates::StateChangeSendingAwsCmdToOn()" ); + aState = EBgScanOn; + SetInterval( iBgScanSettings.backgroundScanInterval ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeSendingAwsCmdToAuto +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeSendingAwsCmdToAuto( TWlanBgScanState& aState ) + { + DEBUG( "CWlanBgScanStates::StateChangeSendingAwsCmdToAuto()" ); + aState = EBgScanAuto; + DEBUG( "CWlanBgScanStates::StateChangeSendingAwsCmdToAuto() - * determine next interval change time and request callback" ); + iBgScan.ScheduleAutoIntervalChange(); + SetInterval( iBgScan.CurrentAutoInterval() ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::StateChangeSendingAwsCmdToAutoAws +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::StateChangeSendingAwsCmdToAutoAws( TWlanBgScanState& aState ) + { + DEBUG( "CWlanBgScanStates::StateChangeSendingAwsCmdToAutoAws()" ); + aState = EBgScanAutoAws; + SetInterval( AutoInterval() ); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::SetInterval +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::SetInterval( TUint32 aInterval ) + { + DEBUG2( "CWlanBgScanStates::SetInterval() - current: %u, new: %u", iBgScanInterval, aInterval ); + + if( aInterval == KWlanBgScanIntervalNever ) + { + iBgScanInterval = KWlanNoScanning; + } + else + { + iBgScanInterval = aInterval; + } + + RefreshUsedInterval(); + } + +// --------------------------------------------------------------------------- +// CWlanBgScanStates::RefreshUsedInterval +// --------------------------------------------------------------------------- +// +void CWlanBgScanStates::RefreshUsedInterval() + { + TUint oldInterval = iUsedBgScanInterval; + + DEBUG2( "CWlanBgScanStates::RefreshUsedInterval() - agg: %u, normal: %u", + iAggressiveBgScanInterval, iBgScanInterval ); + + // Smaller of the two intervals will be taken into use + if( iAggressiveBgScanInterval < iBgScanInterval ) + { + iUsedBgScanInterval = iAggressiveBgScanInterval; + } + else + { + iUsedBgScanInterval = iBgScanInterval; + } + + // If the interval changed, update it to P&S + if( iUsedBgScanInterval != oldInterval ) + { + DEBUG2( "CWlanBgScanStates::RefreshUsedInterval() - used interval changed (new: %u, old: %u), publish it via P&S", + iUsedBgScanInterval, oldInterval ); + TUint32 interval = GetBgInterval(); + iProvider.PublishBgScanInterval( interval ); + } + + // Check if scanning has to be cancelled or carried out immediately + if( KWlanNoScanning == iUsedBgScanInterval ) + { + DEBUG( "CWlanBgScanStates::RefreshUsedInterval() - scanning disabled, cancel pending scan" ); + // In case scanning was disabled, cancel the pending scan request + iProvider.CancelScan(); + } + else if( iUsedBgScanInterval < oldInterval ) + { + DEBUG( "CWlanBgScanStates::RefreshUsedInterval() - new interval smaller than the old one, scan immediately" ); + // In case the new interval is smaller than the old one, scan + // immediately + iProvider.CancelScan(); + iProvider.Scan( KWlanBgScanMaxDelayExpireImmediately ); + } + // else + // In case the new interval is bigger than the old one, it + // is taken into use after the pending scan request completes. + } + + +