/*

* Copyright (c) 2007-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:   Implementation of the base class of signal level handler

*

*/

#include "vccsignallevelhandler.h"

#include "vccsignallevelobserver.h"

#include "rubydebug.h"

// Min. signal strength in absolut dBm, i.e. the value

// in real world is -110 dBm (so quite weak).

static const TInt32 KStrengthMin = 110;

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

// C++ destructor.

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

//

CVccSignalLevelHandler::~CVccSignalLevelHandler()

    {

    // Cancel any outstanding requests.

    Cancel();

    iStrength = 0;

    }

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

// Symbian second-phase constructor.

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

//

void CVccSignalLevelHandler::ConstructL()

    {

    CTimer::ConstructL();

    }

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

// C++ constructor.

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

//

CVccSignalLevelHandler::CVccSignalLevelHandler(

    MVccSignalLevelObserver& aObserver,

    const TSignalLevelParams& aParams )

    : CTimer( EPriorityStandard ),

    iObserver( aObserver ),

    iParams( aParams )

    {

    CActiveScheduler::Add( this );

    }

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

// Star signal level observing.

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

//

void CVccSignalLevelHandler::StartL()

    {

    RUBY_DEBUG_BLOCK( "CVccSignalLevelHandler::StartL" );

    if ( !iNotificationsOn )

        {

        EnableNotificationsL();

        iNotificationsOn = ETrue;

        }

    RUBY_DEBUG0( " -call Cancel()" );

    Cancel();

    RUBY_DEBUG0( " -call GetStrength()" );

    GetStrength();

    RUBY_DEBUG1( " -iStrength = %d, set op = EOperationGet \

                 state = EStrengthUnknown", iStrength );

    iOperation = EOperationGet;

    iState = EStrengthUnknown;

    RUBY_DEBUG0( " -call SetActive()" );

    SetActive();

    }

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

// Stop signal level observing.

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

//

void CVccSignalLevelHandler::Stop()

    {

    RUBY_DEBUG_BLOCK( "CVccSignalLevelHandler::Stop ");

    DisableNotifications();

    iNotificationsOn = EFalse;

    iStrength = 0;

    Cancel();

    }

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

// Set new parameters.

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

//

void CVccSignalLevelHandler::SetParams( const TSignalLevelParams& aParams )

    {

    RUBY_DEBUG_BLOCK( "CVccSignalLevelHandler::SetParams" );

    iParams = aParams;

    }

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

// Handles getting the signal strength and notifying the observer about

// strength changes.

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

//

void CVccSignalLevelHandler::RunL()

    {

    RUBY_DEBUG_BLOCK( "CVccSignalLevelHandler::RunL" );

    // Zero (0) is not acceptable.

    if ( !iStrength )

        {

        RUBY_DEBUG0( " -0 strength not acceptable, setting to KStrengthMin");

        iStrength = KStrengthMin;

        }

    RUBY_DEBUG3( " -iStrength = %d iState = %d iOp = %d", iStrength, iState, iOperation );

    switch ( iOperation )

        {

        case EOperationGet:

            {

            // We are in the Get-mode to get the signal strength.

            // If the strength is < than the high level (== the strength

            // is good), start timer to check if we are still in good level

            // after the timer completes.

            // The same is done if we have a low level (== bad).

            RUBY_DEBUG0( " -EOperationGet");

            if ( iStrength <= iParams.iHighLevel && iStrength > 0 )

                {

                RUBY_DEBUG0( "  set state = EStrengthHigh, op = EOperationWait" );

                After( iParams.iHighTimeout );

                iState = EStrengthHigh;

                iOperation = EOperationWait;

                }

            else if ( iStrength >= iParams.iLowLevel )

                {

                RUBY_DEBUG0( "  set state = EStrengtLow, op = EOperationWait" );

                After( iParams.iLowTimeout );

                iState = EStrengthLow;

                iOperation = EOperationWait;

                }

            else

                {

                RUBY_DEBUG0( "  strength between low and high, set op = EOperationNone" );

                iOperation = EOperationNone;

                // PCLint

                }

            break;

            }

        case EOperationWait:

            {

            // Timer has completed. Check the signal level again.

            RUBY_DEBUG0( " -EOperationWait" );

            RUBY_DEBUG0( "  set op = EOperationComplete" );

            GetStrength();

            SetActive();

            iOperation = EOperationComplete;

            break;

            }

        case EOperationComplete:

            {

            // Checking signal strength is now done.

            // Notify our observer (if needed).

            RUBY_DEBUG1( " -EOperationComplete, iStrength = %d", iStrength );

            // Do we have a good signal level?

            if ( iStrength <= iParams.iHighLevel && iStrength > 0 && iState == EStrengthHigh )

                {

                RUBY_DEBUG0( " -if ( iStrength <= iParams.iHighLevel" );

                NotifyChanges( iStrength, MVccSignalLevelObserver::ESignalClassNormal );

                }

            // Or do we have a bad signal level?

            else if ( iStrength >= iParams.iHighLevel && iState == EStrengthLow )

                {

                RUBY_DEBUG0( " -else if ( iStrength >= iParams.iHighLevel" );

                NotifyChanges( iStrength, MVccSignalLevelObserver::ESignalClassWeak );

                }

            else

                {

                // PCLint

                }

            iOperation = EOperationNone;

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// Handles signal strength changes notified by the subsystem

// (either the WLAN or the GSM).

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

//

void CVccSignalLevelHandler::StrengthChanged()

    {

    RUBY_DEBUG_BLOCK( "CVccSignalLevelHandler::StrengthChanged" );

    // The zero (0) is not good.

    if ( !iStrength )

        {

        iStrength = KStrengthMin;

        }

    RUBY_DEBUG3( " -iStrength = %d, iState = %d, iOp = %d",

                             iStrength, iState, iOperation);

    // Check in which direction the signal strength changed

    // and start the timeout timer to see if the signal level

    // stays at that (new) level.

    RUBY_DEBUG1( " -iHighLevel = %d", iParams.iHighLevel );

    RUBY_DEBUG1( " -iLowLevel = %d", iParams.iLowLevel );

    if ( iStrength <= iParams.iHighLevel && iStrength > 0 )  // && 

        //( iState == EStrengthLow || iState == EStrengthUnknown ) )

        {

        // Cancel outstanding timer in all the cases

        Cancel();

        // We have a good level after a bad one.

        RUBY_DEBUG0( " -call After( hightimeout ), set state = High, op = Wait");

        After( iParams.iHighTimeout );

        iState = EStrengthHigh;

        iOperation = EOperationWait;

        }

    else if ( iStrength >= iParams.iLowLevel )  //&& 

            //( iState == EStrengthHigh || iState == EStrengthUnknown ) )

        {

        // Cancel outstanding timer in all the cases

        Cancel();

        // We have a bad level after a good one.

        RUBY_DEBUG0( " -call After( lowtimeout ), set state = Low, op = Wait");

        After ( iParams.iLowTimeout );

        iState = EStrengthLow;

        iOperation = EOperationWait;

        }

    else

        {

        RUBY_DEBUG0( "-EOperationNone ");

        iOperation = EOperationNone;

        }

    }

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

// Cancel outstanding requests.

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

//

void CVccSignalLevelHandler::DoCancel()

    {

    RUBY_DEBUG_BLOCK( "CVccSignalLevelHandler::DoCancel" );

    switch ( iOperation )

        {

        case EOperationWait:

            {

            RUBY_DEBUG0( "EOperationWait" );

            CTimer::DoCancel();

            break;

            }

        case EOperationGet:

            // fall-through intended here

        case EOperationComplete:

            {

            RUBY_DEBUG0( "EOperationGet / EOperationComplete" );

            CancelGetStrength();

            break;

            }

        default:

            {

            break;

            }

        }

    }