/*

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

*

*/

//  EXTERNAL INCLUDES

#include <wlanmgmtclient.h>

#include <centralrepository.h>

#include <utf.h>

#include <wlancontainer.h>

#include <commsdattypeinfov1_1.h>

#include <wlanscaninfo.h>

#include <cmdestinationext.h>

#include <commdb.h>

#ifdef __WINS__

#include <e32math.h>

#endif

//  CLASS HEADER

#include "wsfwlanscanner.h"

//  INTERNAL INCLUDES

#include "wsfwlaninfoarray.h"

#include "wsfwlanscaninfodefines.h"

#include "wsfwlanconnectiondetailsprovider.h"

#include "wsfwlansettingsaccessor.h"

#include "wsflogger.h"

//  LOCAL DEFINITIONS

using namespace CMManager;

/**

* Microseconds in a second 

*/

static const TInt KMicrosecPerSecond = 1000 * 1000;

//  CONSTRUCTION AND DESTRUCTION

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

// CWsfWlanScanner::NewL

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

//    

CWsfWlanScanner* CWsfWlanScanner::NewL( CommsDat::CMDBSession& aDbSession )

    {

    CWsfWlanScanner* self = CWsfWlanScanner::NewLC( aDbSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// CWsfWlanScanner::NewLC

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

//    

CWsfWlanScanner* CWsfWlanScanner::NewLC( CommsDat::CMDBSession& aDbSession )

    {

    CWsfWlanScanner* self = new( ELeave ) CWsfWlanScanner( aDbSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWsfWlanScanner::~CWsfWlanScanner

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

//    

CWsfWlanScanner::~CWsfWlanScanner()

    {

    LOG_ENTERFN( "CWsfWlanScanner::~CWsfWlanScanner" );

    StopScanning();

    Cancel();

    iTimer.Close();

    iCmManagerExt.Close();

    delete iActiveConnectionName;

    delete iScanResults;

    delete iWlanMgmtClient;

    delete iWlanSettingsAccessor;

    delete iScanInfo;

    delete iScanArray;

    iDirectScanSsids.Close();

    iDirectScanIapIDs.Close();

    iDbSession = NULL; // not owning

    iConnectionDetailsProvider = NULL;

    }

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

// CWsfWlanScanner::CWsfWlanScanner

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

//    

CWsfWlanScanner::CWsfWlanScanner( CommsDat::CMDBSession& aDbSession ): 

    CActive( EPriorityStandard ),

    iDbSession( &aDbSession ),

    iScanState( EIdle )

    {

    }

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

// CWsfWlanScanner::ConstructL

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

//    

void CWsfWlanScanner::ConstructL()

    {

    LOG_ENTERFN( "CWsfWlanScanner::ConstructL" );

#ifndef __WINS__ // client is not available on wins

    iWlanMgmtClient = CWlanMgmtClient::NewL();

    iScanInfo = CWlanScanInfo::NewL();

#endif

    iCmManagerExt.OpenL();

    iScanArray = CWsfWlanInfoArray::NewL();

    User::LeaveIfError( iTimer.CreateLocal() );

    iScanResults = KNullDesC8().AllocL();

    iWlanSettingsAccessor = CWsfWlanSettingsAccessor::NewL( *iDbSession );

    iScanningInterval = iWlanSettingsAccessor->ScanInterval() * 

                                                          KMicrosecPerSecond;

    iShowAvailability = iWlanSettingsAccessor->ShowAvailability();

    LOG_WRITEF( "initial bgScanInterval = %d sec", 

                iWlanSettingsAccessor->ScanInterval() );

    LOG_WRITEF( "initial showAvailability = %d", iShowAvailability );

    CActiveScheduler::Add( this );

    }

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

// CWsfWlanScanner::DoCancel

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

//    

void CWsfWlanScanner::DoCancel()

    {

    LOG_ENTERFN( "CWsfWlanScanner::DoCancel" );

    iTimer.Cancel();

#ifndef __WINS__

    iWlanMgmtClient->CancelGetScanResults();

#endif    

    iScanState = EIdle;    

    }

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

// CWsfWlanScanner::RunL

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

//    

void CWsfWlanScanner::RunL()

    {

    LOG_ENTERFN( "CWsfWlanScanner::RunL" );

    /*

     * Scan logic

     * 1. Do broadcast scan - state = EIdle

     * 2. Get available IAPs - state = EBroadcastScan

     * 3. Process broadcast scan results state = EBroadcastScan

     * 4. Do direct scans for remaining known networks

     *    from step 2. Get available IAPs - state = EDirectScan

     * 5. Add connected network - state = EFinished

     * 6. Set names and priorities for known networks - state = EFinished

     */

    if ( iScanState == EIdle )

        {

        LOG_WRITE( "broadcast scan phase" );

        // prepare things for direct scans

        PrepareDirectScan();

        // notify clients

        if ( iObserver )

            {

            iObserver->WlanScanStarted();

            }

        // do broadcast scan

#ifndef __WINS__

        iWlanMgmtClient->GetScanResults( iStatus, *iScanInfo );

        SetActive();

#else

        // for testing

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

#endif     

        iScanState = EBroadcastScan;

        }

    else if ( iScanState == EBroadcastScan )

        {

        // process broadcast scan results

        DoScanForNetworksL();

        // now it's time to initiate direct scan 

        // for remaining known networks

        if ( iDirectScanSsids.Count() )

            {

#ifdef _DEBUG

            HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( 

                                                        iDirectScanSsids[0] );

            LOG_WRITEF( "requesting direct scan for [%S]", ssid );

            CleanupStack::PopAndDestroy( ssid );

#endif

#ifndef __WINS__

            // run direct scan

            iWlanMgmtClient->GetScanResults( iDirectScanSsids[0], 

                                             iStatus, *iScanInfo );

            SetActive();

#else

            // for testing

            SetActive();

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

#endif                                             

            iScanState = EDirectScan;

            }

        else

            {

            LOG_WRITE( "direct scan skipped" );

            iScanState = EFinished;

            }

        }

    else if ( iScanState == EDirectScan )

        {

        LOG_WRITE( "direct scan results" );

#ifndef __WINS__

        ProcessDirectScanResultL();

#endif

        // delete the processed item (first)

        iDirectScanSsids.Remove( 0 );

        iDirectScanIapIDs.Remove( 0 );

        if ( iDirectScanSsids.Count() )

            {

            // repeated direct scans for known networks

#ifdef _DEBUG

            HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( 

                                                        iDirectScanSsids[0] );

            LOG_WRITEF( "requesting direct scan for [%S]", ssid );

            CleanupStack::PopAndDestroy( ssid );

#endif

#ifndef __WINS__

            // run direct scan

            iWlanMgmtClient->GetScanResults( iDirectScanSsids[0], 

                                             iStatus, *iScanInfo );        

            SetActive();

#else

            // for testing

            SetActive();

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

#endif                                             

            }

        else

            {

            // there is nothing more to do

            iScanState = EFinished;

            }

        }

    if ( iScanState == EFinished )

        {

        LOG_WRITE( "scanning finished" );

#ifndef __WINS__

        AddConnectedWLANInfoL();

        TWsfWlanInfo* info(NULL);

        TInt scanArrayCount( iScanArray->Count() );

        for ( TInt i(0) ; i < scanArrayCount ; i++ )

            {  

            info = (*iScanArray)[ i ];

            if( info->iIapId )

                {

                TRAPD( error, UpdatePriorityL( *info ) );

                if ( error )

                    {

                    // Ignore error and just continue

                    LOG_WRITE( "Prio update failed" );

                    }

                }

            if( info->iIapId && info->iConnectionState != EConnected )

                {

                ReplaceSsidsWithIapName( *info );

                }

            }

#endif //_WINS_

        // sort the array

        iScanArray->SortArrayL();

        HBufC8* results = iScanArray->SerializeContentLC();

        CleanupStack::Pop( results );

        delete iScanResults;

        iScanResults = results;

        // we may let go the scan array contents...

        iScanArray->Reset();

#ifdef _DEBUG

        DumpScanResultsL( iScanArray );

#endif

        // notify clients that data is ready

        if ( iObserver )

            {

            iObserver->WlanScanCompleteL();

            }

        if ( !iShowAvailability )

            {

            // reset the timer if we are responsible for scheduling scans

            iTimer.Cancel();

            iTimer.After( iStatus, 

                          TTimeIntervalMicroSeconds32( iScanningInterval ) );

            Cancel();

            SetActive();

            }

        iScanState = EIdle;

        }

    }

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

// CWsfWlanScanner::AddConnectedWLANInfo

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

//    

void CWsfWlanScanner::AddConnectedWLANInfoL()

    {

    // Get the possible connection

    if ( iConnectionDetailsProvider )

        {

        TWsfWlanInfo* connectedInfo = new (ELeave) TWsfWlanInfo();

        CleanupStack::PushL( connectedInfo );

        if ( iConnectionDetailsProvider->ConnectedWlanConnectionDetailsL(

                connectedInfo) )

            {

            TBuf8<KWlanMaxAccessPointNameLength> connectedSsidOrIap;

            connectedSsidOrIap.Copy( connectedInfo->iSsid );

            // ConnectedWlanConnectionDetailsL() may have returned an IAP name instead of SSID.

            // make sure that we really have SSID in connectedInfo->iSSID at this phase.

            TWlanSsid connectedSsid;

            iWlanMgmtClient->GetConnectionSsid( connectedSsid );

            connectedInfo->iSsid.Copy( connectedSsid );

            connectedInfo->iCoverage = 0;

            connectedInfo->iVisibility = 1;

            TBool connectedInfoAppended = EFalse;

            RPointerArray<TWsfWlanInfo> matchArray;

            CleanupClosePushL( matchArray );

            if ( connectedInfo->iIapId )

                {

                LOG_WRITEF( "Connected iap [%d]", connectedInfo->iIapId );

                iScanArray->MatchWithIapIDL( connectedInfo->iIapId,

                        iScanArray->Count(), matchArray );

                if ( !matchArray.Count() )

                    {

                    LOG_WRITE( "Not found with Iap id" );

                    iScanArray->MatchL( connectedInfo->iSsid,

                                        connectedInfo->iSecurityMode,

                                        connectedInfo->iNetMode, 

                                        iScanArray->Count(),

                                        matchArray );

                    }

                }

            else

                {

                LOG_WRITE( "Easy WLAN connection" );

                iScanArray->MatchL( connectedInfo->iSsid,

                        connectedInfo->iSecurityMode,

                        connectedInfo->iNetMode, iScanArray->Count(),

                        matchArray );

                }

            if ( matchArray.Count() )

                {

                LOG_WRITE( "Info found" );

                TWsfWlanInfo* temp = matchArray[0];

                temp->iConnectionState = EConnected;

                temp->iSsid.Copy( connectedSsidOrIap );

                temp->iNetworkName.Zero();

                }

            else

                {

                LOG_WRITE( "Info not found - append" );

                connectedInfo->iSsid.Copy( connectedSsidOrIap );

                iScanArray->AppendL( connectedInfo );

                connectedInfoAppended = ETrue;

                }

            CleanupStack::PopAndDestroy( &matchArray );

            if ( connectedInfoAppended )

                {

                CleanupStack::Pop( connectedInfo );

                }

            else

                {

                CleanupStack::PopAndDestroy( connectedInfo );

                }

            }

        else

            {

            CleanupStack::PopAndDestroy( connectedInfo );

            }

        }

    else

        {

        LOG_WRITE( "No connection details provider" );

        }

    }

#ifdef _DEBUG

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

// CWsfWlanScanner::DumpScanResultsL

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

//    

void CWsfWlanScanner::DumpScanResultsL( CWsfWlanInfoArray* aArray )

    {

    _LIT( Kopen, "open" );

    _LIT( Kwep, "wep" );

    _LIT( Kwpa, "wpa" );

    _LIT( Kwpa2, "wpa2" );        

    _LIT( K802, "802.1x" );

    const TDesC* secModes[4] = { &Kopen, &Kwep, &K802, &Kwpa };

    _LIT( Kpsk, "psk" );

    _LIT( Keap, "eap" );

    _LIT( Khidden, "<hidden>" );

    for ( TInt i( 0 ); i < aArray->Count(); ++i )

        {

        TWsfWlanInfo* wi( (*aArray)[i] );

        const TDesC* sm( 0 );

        switch ( wi->iSecurityMode )

            {

            case EWlanSecModeOpen:

                sm = &Kopen;

                break;

            case EWlanSecModeWep:

                sm = &Kwep;

                break;

            case EWlanSecModeWpa:

                sm = &Kwpa;

                break;

            case EWlanSecModeWpa2:

                sm = &Kwpa2;

                break;

            case EWlanSecMode802_1x:

                sm = &K802;

            }

        const TDesC* psk = wi->UsesPreSharedKey()? &Kpsk:             

                               ( ( wi->iSecurityMode == EWlanSecMode802_1x || 

                                   wi->iSecurityMode == EWlanSecModeWpa ||

                                   wi->iSecurityMode == EWlanSecModeWpa2 )? 

                                      &Keap: &KNullDesC );

        HBufC16 *ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( wi->iSsid );

        LOG_WRITEF( "[%S] %S %S %S", ssid, sm, psk, 

                    wi->iVisibility? &KNullDesC: &Khidden );

        CleanupStack::PopAndDestroy( ssid );

        }

    }

#endif // _DEBUG

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

// CWsfWlanScanner::RunError

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

//    

TInt CWsfWlanScanner::RunError( TInt aError )

    {

    LOG_ENTERFN( "CWsfWlanScanner::RunError" );

    LOG_WRITEF( "error = %d", aError );

    iScanArray->Reset();

    if ( iObserver && aError != KErrNotReady )

        {

        // KErrNotReady is excluded as it indicates that the WLAN engine

        // has not yet set up itself, which we cannot help

        iObserver->NotifyError( aError );    

        }

    iScanState = EIdle;

    if ( !iShowAvailability )

        {

        // the scanning has failed, re-issue the scan timer

        iTimer.Cancel();