/*

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

*

*/

/*

*/

#include <e32base.h>

#include <e32const.h> 

#include "wlanscanproviderinterface.h"

#include "awsinterface.h"

#include "awsenginebase.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<CWlanBgScanStates*>( 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;