/*

* Copyright (c) 2005-2009 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: MPM ConnMon request handling

*

*/

/**

@file mpmconnmonreqs.cpp

Mobility Policy Manager ConnMon request handling.

*/

// INCLUDE FILES

#include "mpmconnmonreqs.h"

#include "mpmlogger.h"

#include "mpmserversession.h"

#include "mpmiapselection.h"

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMPMConnMonReqs::NewL

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

//

CMPMConnMonReqs* CMPMConnMonReqs::NewL(CMPMConnMonEvents& aParent,

                                       RConnectionMonitor& aConnMon,

                                       TUint aConnId, 

                                       CMPMServerSession* aSession )

    {

    CMPMConnMonReqs* self = new (ELeave) CMPMConnMonReqs(

                                aParent, aConnMon, aConnId, aSession );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMPMConnMonReqs::CMPMConnMonReqs

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

//

CMPMConnMonReqs::CMPMConnMonReqs(CMPMConnMonEvents& aParent,

                                 RConnectionMonitor& aConnMon,

                                 TUint aConnId, 

                                 CMPMServerSession* aSession )

      iParent(aParent), 

      iConnMon(aConnMon), 

      iConnId(aConnId), 

      iSession(aSession), 

      iWlanScanCallback( EWlanScanCallbackNone ), 

      iConnectionCount( 0 )

    {

    }

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

// CMPMConnMonReqs::~CMPMConnMonReqs

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

//

CMPMConnMonReqs::~CMPMConnMonReqs()

    {

    MPMLOGSTRING( "CMPMConnMonReqs::~CMPMConnMonReqs" )

    Cancel();

    }

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

// CMPMConnMonReqs::ConstructL

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

//

void CMPMConnMonReqs::ConstructL()

    {

    MPMLOGSTRING( "CMPMConnMonReqs::ConstructL" )

    CActiveScheduler::Add(this);

    }

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

// CMPMConnMonReqs::AvailableIapsSync

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

//

void CMPMConnMonReqs::AvailableIapsSync()

    {

    MPMLOGSTRING( "CMPMConnMonReqs::AvailableIapsSync" )

    iNextState = EGetIapAvailState;

    iLastCancelCode = EConnMonGetPckgAttribute;

    iConnMon.GetPckgAttribute( EBearerIdAll, 0, KIapAvailability,

                               iIapBuf, iStatus);

    SetActive();

    // Since CodeScanner does not recognise method IsStarted(), 

    // it claims that here is a problem:

    // 

    // Problem: Active object called without checking 

    // whether it is active or cancelling it first.

    // 

    if ( !iActiveSchedulerWait.IsStarted() )

        {

        iActiveSchedulerWait.Start();

        }

    }

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

// CMPMConnMonReqs::RefreshAvailableIAPs

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

//

void CMPMConnMonReqs::RefreshAvailableIAPs( TWlanScanCallback aCallback, 

                                            TInt aForceRefreshIntervalSeconds )

    {

    MPMLOGSTRING2( "CMPMConnMonReqs::RefreshAvailableIAPs callback %d", aCallback )

    // set the type of callback to determine afterwards which function to call

    iWlanScanCallback = aCallback;

    iNextState      = EScanWLANNetworksState;   // Default value

    iLastCancelCode = EConnMonGetPckgAttribute;

    TTime time;

    time.UniversalTime();

    TTimeIntervalSeconds interval( 0 );

    TInt ret( KErrNone );

    // Calculate the elapsed time.

    ret = time.SecondsFrom( iParent.GetIAPRefreshTime(), interval );

    if ( ret != KErrNone )

        {

        MPMLOGSTRING2( "CMPMConnMonReqs::RefreshAvailableIAPs interval error %d ", ret )

        // problem with interval, force iapavailability.

        interval = 0;

        aForceRefreshIntervalSeconds = 0;

        }

    // Default behavior is to query KIapAvailability from ConnMon always

    // or if the availability information has aged at least aForceRefreshIntervalSeconds

    //

    if ( aForceRefreshIntervalSeconds == 0 || 

       ( interval.Int() >= aForceRefreshIntervalSeconds ) )

        {

        // Discard availability notifications from Connection Monitor 

        // until MPM initiated WLAN scan request has completed.

        // 

        iParent.EnableDiscarding();

        MPMLOGSTRING2( "CMPMConnMonReqs::RefreshAvailableIAPs interval %d, executing scan", 

            interval.Int() )

        iConnMon.GetPckgAttribute( EBearerIdAll, 0, KIapAvailability,

                                   iIapBuf, iStatus );

        SetActive();

        }

    // With consecutive calls we allow MPM to use cached value.

    //

    else

        {

        MPMLOGSTRING2( "CMPMConnMonReqs::RefreshAvailableIAPs interval %d, using cached value",

            interval.Int() )

        // iIapBuf is empty, thus we need a new state.

        iNextState = EScanWLANNetworksStateCached;

        TRequestStatus* statusPtr;

        statusPtr = &iStatus;

        // We can just complete the request.

        SetActive();

        User::RequestComplete( statusPtr, KErrNone );

        }

    }

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

// CMPMConnMonReqs::CompareConnIds

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

//

TBool CMPMConnMonReqs::CompareConnIds( const CMPMConnMonReqs& aReq1,

                                       const CMPMConnMonReqs& aReq2 )

    {

    if ( aReq1.iConnId == aReq2.iConnId )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CMPMConnMonReqs::MyCancel()

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

//

void CMPMConnMonReqs::MyCancel()

    {

    // Handle cancellation here.

    MPMLOGSTRING( "CMPMConnMonReqs::MyCancel()" )

    ASSERT( iNextState != EGetIapAvailState && iNextState != EObsolete );

    // Allow the availability update when the connmon request completes.

    iNextState = EObsolete;

    }

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

// CMPMConnMonReqs::ErrorCallbackL()

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

//

void CMPMConnMonReqs::ErrorCallbackL( TInt aStatus )

    {

    switch ( iNextState )

        {

        case EGetIapAvailState:

        case EGetConnectionCountState: 

            {

            MPMLOGSTRING( "CMPMConnMonReqs::ErrorCallbackL: EGetIapAvailState failed" )

            if ( iActiveSchedulerWait.IsStarted() )

                {

                iActiveSchedulerWait.AsyncStop();

                }

            break;

            }

        case EScanWLANNetworksState:

        case EScanWLANNetworksStateCached:

            {

            MPMLOGSTRING( "CMPMConnMonReqs::ErrorCallbackL: EScanWLANNetworksState failed" )

            ASSERT( iSession );

            // Disable discarding availability notifications from Connection Monitor.

            // 

            iParent.DisableDiscarding(); 

            // check which callback function to use and continue

            // handling the request if possible.

            // 

            if( iWlanScanCallback == EWlanScanCallbackChooseIap )

                {

                iSession->IapSelectionL()->ChooseIapWLANScanCompletedL( aStatus );

                }

            else if( iWlanScanCallback == EWlanScanCallbackProcessErr )

                {

                iSession->ProcessErrorWlanScanCompletedL();

                }

            else if( iWlanScanCallback == EWlanScanCallbackCarrierRejected )

                {

                // No fresh IAP info available but try to select new IAP

                // based on whatever existing info there is

                // 

                iSession->CompleteCarrierRejected();

                }

            else if( iWlanScanCallback == EWlanScanCallbackSortSnap )

                {

                // SortSnap was called with old availability information.

                iSession->CompleteServerSortSNAP();

                }

            else

                {

                MPMLOGSTRING(

                    "CMPMConnMonReqs::ErrorCallbackL: iWlanScanCallback EWlanScanCallbackNone" )

                }

            // reset callback type

            //

            iWlanScanCallback = EWlanScanCallbackNone;

            break;

            }

        case EObsolete:

            MPMLOGSTRING( "CMPMConnMonReqs::ErrorCallbackL: EObsolete" )

            break;

        }

    }

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

// CMPMConnMonReqs::RunL

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

//

void CMPMConnMonReqs::RunL()

    {

    MPMLOGSTRING( "CMPMConnMonReqs::RunL" )

    if ( iStatus != KErrNone )

        {

        // Nok

        MPMLOGSTRING2( "CMPMConnMonReqs::RunL: \

ConnMon request completed with error code = %i", iStatus.Int() )

        // Does nothing if state is obsolete.

        ErrorCallbackL( iStatus.Int() );

        // RemoveReqPtr is safe if "this" doesn't exist

        iParent.RemoveReqPtr( this );

        delete this;

        }

    else

        {

        // Ok

        switch (iNextState)

            {

            case EGetIapAvailState:

                {

                MPMLOGSTRING( "CMPMConnMonReqs::RunL: EGetIapAvailState" )

                iParent.SetAvailableIAPs( iIapBuf() );

                if ( iActiveSchedulerWait.IsStarted() )

                    {

                    iActiveSchedulerWait.AsyncStop();

                    }

                iNextState      = EGetConnectionCountState;

                iLastCancelCode = EConnMonGetConnectionCount;

                iConnMon.GetConnectionCount( iConnectionCount, iStatus );

                SetActive();

                break;

                }

            case EGetConnectionCountState: 

                {

                MPMLOGSTRING( "CMPMConnMonReqs::RunL: EGetConnectionCountState" )

                MPMLOGSTRING2( "CMPMConnMonReqs::RunL: Connection Count: %i", 

                    iConnectionCount )

                iParent.SetConnectionCounter( iConnectionCount );

                iParent.RemoveReqPtr( this );

                delete this;

                break;

                }

            case EScanWLANNetworksState:

            case EScanWLANNetworksStateCached:

                {

                MPMLOGSTRING( "CMPMConnMonReqs::RunL: EScanWLANNetworksState and EScanWLANNetworksStateCached" )

                ASSERT( iSession );

                if ( iNextState == EScanWLANNetworksState )

                    {

                    MPMLOGSTRING( "CMPMConnMonReqs::RunL: EScanWLANNetworksState fresh data available from ConnMon" )

                    iParent.SetAvailableIAPs( iIapBuf() );

                    // Disable discarding availability notifications from Connection Monitor.

                    // 

                    iParent.DisableDiscarding(); 

                    // Generate event only if we got new iaps from ConnMon.

                    // 

                    if ( iWlanScanCallback == EWlanScanCallbackGenerateEvent )

                        {

                        MPMLOGSTRING( "CMPMConnMonReqs::RunL: iWlanScanCallback EWlanScanCallbackGenerateEvent" )

                        // Generate event only if not 

                        //

                        iParent.IapAvailabilityChange( EConnMon );

                        }

                    }

                // check which callback function to use

                // 

                if( iWlanScanCallback == EWlanScanCallbackChooseIap )

                    {

                    iSession->IapSelectionL()->ChooseIapWLANScanCompletedL( iStatus.Int() );

                    }

                else if( iWlanScanCallback == EWlanScanCallbackProcessErr )

                    {

                    iSession->ProcessErrorWlanScanCompletedL();

                    }

                else if( iWlanScanCallback == EWlanScanCallbackCarrierRejected )

                    {

                    iSession->CompleteCarrierRejected();

                    }

                else if( iWlanScanCallback == EWlanScanCallbackSortSnap )

                    {

                    iSession->CompleteServerSortSNAP();

                    }

                else

                    {

                    MPMLOGSTRING(

                    "CMPMConnMonReqs::RunL: iWlanScanCallback default processing" )

                    }

                // reset callback type

                //

                iWlanScanCallback = EWlanScanCallbackNone;

                iParent.RemoveReqPtr( this );

                delete this;

                break;

                }

            case EObsolete:

                iParent.SetAvailableIAPs( iIapBuf() );

                delete this;

                break;

            default:

                {

                MPMLOGSTRING( "CMPMConnMonReqs::RunL: default" )

                PanicServer( KErrNotSupported );

                break;

                }

            }

        }

    }

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

// CMPMConnMonReqs::RunError

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

//

TInt CMPMConnMonReqs::RunError( TInt aError )

    {

    MPMLOGSTRING2( "CMPMConnMonReqs::RunError: RunL made a leave with error = %i", aError )

    // Disable discarding availability notifications from Connection Monitor.

    // 

    iParent.DisableDiscarding(); 

    // check which callback function was used when leave occurred

    // 

    if( iWlanScanCallback == EWlanScanCallbackChooseIap )

        {

        ASSERT( iSession );

        iSession->ChooseIapComplete( aError, NULL );

        }

    else if( iWlanScanCallback == EWlanScanCallbackProcessErr )

        {

        TBMNeededAction neededAction( EPropagateError );

        ASSERT( iSession );

        iSession->ProcessErrorComplete( KErrNone, &aError, &neededAction );

        }

    else

        {

        MPMLOGSTRING(

        "CMPMConnMonReqs::RunError: iWlanScanCallback EWlanScanCallbackNone" )

        }

    // We are done

    iParent.RemoveReqPtr( this );

    delete this;

    // Return KErrNone to prevent panic 

    return KErrNone;

    }

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

// CMPMConnMonReqs::DoCancel

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

//

void CMPMConnMonReqs::DoCancel()

    {

    MPMLOGSTRING( "CMPMConnMonReqs::DoCancel" )

    // Disable discarding availability notifications from Connection Monitor.

    // 

    iParent.DisableDiscarding(); 

    iConnMon.CancelAsyncRequest( iLastCancelCode );

    if ( iActiveSchedulerWait.IsStarted() )

        {

        iActiveSchedulerWait.AsyncStop();

        }

    }

//  End of File