/*

* 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:  Provides an interface to WLAN Engine.

*

*/

#include <e32base.h>

#include <utf.h>

#include "CWlanSupport.h"

#include "CEventQueue.h"

#include "ConnMonIAP.h"

#include "ConnMonAvailabilityManager.h"

#include "connmoncommsdatcache.h"

#include "log.h"

#include "ConnMonUtils.h"

#include "connmonwlannetwork.h"

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

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

// CWlanSupport::NewL

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

//

CWlanSupport* CWlanSupport::NewL( CConnMonServer* aServer )

    {

    //LOGENTRFN("CWlanSupport::NewL()")

    CWlanSupport* self = new( ELeave ) CWlanSupport( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    //LOGEXITFN("CWlanSupport::NewL()")

    return self;

    }

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

// CWlanSupport::CWlanSupport

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

//

CWlanSupport::CWlanSupport(

        CConnMonServer* aServer )

        :

        iServer( aServer ),

        iEnableScan( ETrue ),

        iEnableEventsToClients( EFalse )

    {

    // iEnableScan has to be initialized to ETrue, so iAvailableWlanIapsCache will be initialized

    // properly when WLAN IAP availability is asked for the first time.

    }

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

// CWlanSupport::ConstructL

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

//

void CWlanSupport::ConstructL()

    {

    iWlanMgmt = CWlanMgmtClient::NewL();

    ActivateNotificationsL();

    }

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

// Destructor

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

//

CWlanSupport::~CWlanSupport()

    {

    CancelNotifications(); // Deletes iEventWatcher

    delete iWlanMgmt;

    iWlanMgmt = NULL;

    // Cleanup WLAN IAPs cache array

    iAvailableWlanIapsCache.Close();

    // Cleanup WLAN sessions pointer array

    iWlanSessionsPtrArray.ResetAndDestroy();

    }

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

// CWlanSupport::GetBearerAvailabilityL

// Called from CWlanEvent::OldNetworksLost

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

//

void CWlanSupport::GetBearerAvailabilityL( TBool& aAvailability )

    {

    LOGENTRFN("CWlanSupport::GetBearerAvailabilityL()")

    aAvailability = EFalse;

    // Check if connection exists

    TInt mode( 0 );

    TInt ret = GetConnectionMode( mode );

    if ( KErrNone == ret )

        {

        // An active WLAN connection exists.

        aAvailability = ETrue;

        }

    else // No active WLAN connections... Scan WLAN networks

        {

        CWlanScanInfo* scanInfo = CWlanScanInfo::NewL();

        CleanupStack::PushL( scanInfo );

        // Get scan results without parameters

        ret = iWlanMgmt->GetScanResults( *scanInfo );

        if ( KErrNone == ret )

            {

            // Check scan results

            if ( scanInfo->IsDone() )

                {

                // Empty scan info, no WLAN networks available

                aAvailability = EFalse;

                }

            else

                {

                // WLAN networks found

                aAvailability = ETrue;

                }

            }

        else

            {

            LOGIT1("GetBearerAvailabilityL: GetScanResults error <%d>", ret)

            User::Leave( ret );

            }

        CleanupStack::PopAndDestroy( scanInfo );

        }

    LOGEXITFN("CWlanSupport::GetBearerAvailabilityL()")

    }

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

// CWlanSupport::GetBearerAvailabilityL

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

//

TInt CWlanSupport::GetBearerAvailabilityL( const RMessage2& aMessage, TBool& aAvailability )

    {

    LOGENTRFN("CWlanSupport::GetBearerAvailabilityL()")

    TInt result( KErrNone );

    aAvailability = EFalse;

    // Check if event watcher has the availability information

    TBool eventWatcherKnowsAvailability( EFalse );

    if ( iEventWatcher )

        {

        eventWatcherKnowsAvailability = iEventWatcher->HasAvailabilityKnowledge();

        }

    // Use WLAN bearer availability info from event watcher if possible.

    if ( eventWatcherKnowsAvailability )

        {

        aAvailability = iEventWatcher->WlanAvailability();

        result = KErrNone;

        }

    else

        {

        // Check if a WLAN connection exists

        TInt mode( 0 );

        TInt ret = GetConnectionMode( mode );

        if ( KErrNone == ret )

            {

            // An active WLAN connection equals bearer availability.

            aAvailability = ETrue;

            result = KErrNone;

            }

        else // No active WLAN connections... Scan WLAN networks

            {

            // Add session to wlan session table (if not already there)

            TInt index = AddWlanSessionL( aMessage );

            iWlanSessionsPtrArray[index]->GetScanResultsL( aMessage );

            result = KRequestPending;

            }

        }

    LOGEXITFN1("CWlanSupport::GetBearerAvailabilityL()", result)

    return result;

    }

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

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

//

TInt CWlanSupport::GetSignalStrengthL(

        const RMessage2& aMessage,

        TInt& aSignalStrength )

    {

    LOGENTRFN("CWlanSupport::GetSignalStrengthL()")

    TInt result( KErrNone );

    TInt mode( 0 );

    aSignalStrength = 0;

    // Get connection mode to see if connection exists

    TInt ret = GetConnectionMode( mode );

    if ( KErrNone == ret )

        {

        // An active WLAN connection exists -> get signal quality

        result = GetConnectionSignalQuality( aSignalStrength );

        }

    else // No connection -> scan networks

        {

        // Add session to wlan session table (if not already there)

        TInt index = AddWlanSessionL( aMessage );

        iWlanSessionsPtrArray[index]->GetScanResultsL( aMessage );

        result = KRequestPending;

        }

    LOGEXITFN1("CWlanSupport::GetSignalStrengthL()", result)

    return result;

    }

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

// CWlanSupport::GetNetworkNamesL

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

//

TInt CWlanSupport::GetNetworkNamesL( const RMessage2& aMessage )

    {

    LOGENTRFN("CWlanSupport::GetNetworkNamesL()")

    // Add session to wlan session table (if not already there)

    TInt index = AddWlanSessionL( aMessage );

    iWlanSessionsPtrArray[index]->GetScanResultsL( aMessage );

    LOGEXITFN1("CWlanSupport::GetNetworkNamesL()", KRequestPending)

    return KRequestPending;

    }

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

// CWlanSupport::ParseNetworkNamesL

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

//

void CWlanSupport::ParseNetworkNamesL(

        CWlanScanInfo* aScanInfo,

        TConnMonNetworkNames& aNetInfo )

    {

    LOGENTRFN("CWlanSupport::ParseNetworkNamesL()")

    TInt ret( KErrNone );

    RArray< TConnMonNetwork > sortedNetworkNames;

    CleanupClosePushL( sortedNetworkNames );

    aNetInfo.iCount = 0;

    // For logging only

    LOG(TInt count(0);)

    LOGIT("Parsing networks:")

    // Iterate through scan results.

    for ( aScanInfo->First(); !aScanInfo->IsDone(); aScanInfo->Next() )

        {

        TConnMonNetwork nw;

        // Operating mode

        if ( aScanInfo->Capability() & KWlan802Dot11CapabilityEssMask )

            {

            nw.iType = EConnMonInfraStructure;

            }

        else

            {

            nw.iType = EConnMonAdHoc;

            }

        // Signal strength

        nw.iSignalStrength = aScanInfo->RXLevel();

        // SSID

        TUint8 ieLen( 0 );

        const TUint8* ieData( NULL );

        ret = aScanInfo->InformationElement( KWlan802Dot11SsidIE, ieLen, &ieData );

        if ( ( KErrNone == ret ) && ( ieLen <= CConnMonWlanNetwork::KMaxNameLength ) )

            {

            // ieData points to the beginning of the 802.11 SSID payload data i.e.

            // the header is bypassed. ieLen contains the length of payload data.

            nw.iName.Copy( ieData, ieLen );

            }

        sortedNetworkNames.InsertInOrderAllowRepeatsL( nw, CWlanSupport::CompareNetworkStrengths );

#ifdef _DEBUG

        // Print network information to log

        count++;

        if ( ( KErrNone == ret ) && ( ieLen <= CConnMonWlanNetwork::KMaxNameLength ) )

            {

            TBuf<CConnMonWlanNetwork::KMaxNameLength+1> debug_name;

            ConnMonUtils::TDes8ToTDes( nw.iName, debug_name );

            TWlanBssid bssid;

            aScanInfo->Bssid( bssid );

            LOGIT11("%02d: %02X:%02X:%02X:%02X:%02X:%02X sig.str %d, type %d, name(%02d): %s",

                    count, bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5],

                    nw.iSignalStrength, nw.iType, debug_name.Length(), debug_name.PtrZ())

            }

#endif // _DEBUG

        } // for

    // Go through the items one by one starting from the largest signal strength.

    // Always uses the first item in array, since it is removed in the end of loop.

    while ( sortedNetworkNames.Count() > 0 && aNetInfo.iCount < KConnMonMaxNetworkCount )

        {

        TConnMonNetwork &item( sortedNetworkNames[0] );

        TBool duplicate( EFalse );

        for ( TUint i = 0; i < aNetInfo.iCount; i++ )

            {

            if ( aNetInfo.iNetwork[i].iType == item.iType &&

                 aNetInfo.iNetwork[i].iName == item.iName )

                {

                duplicate = ETrue;

                }

            }

        if ( !duplicate )

            {

            // Adding the item

            aNetInfo.iNetwork[aNetInfo.iCount].iType = item.iType;

            aNetInfo.iNetwork[aNetInfo.iCount].iSignalStrength = item.iSignalStrength;

            aNetInfo.iNetwork[aNetInfo.iCount].iName.Copy( item.iName );

#ifdef _DEBUG

            // One letter longer than max WLAN network name, since we are adding a '\0' when printing

            TBuf<CConnMonWlanNetwork::KMaxNameLength+1> name;

            ConnMonUtils::TDes8ToTDes( aNetInfo.iNetwork[aNetInfo.iCount].iName, name );

            LOGIT3("Added network %.2d, sig.str %d, name: %s",

                    aNetInfo.iCount,

                    aNetInfo.iNetwork[aNetInfo.iCount].iSignalStrength,

                    name.PtrZ())

#endif // _DEBUG

            aNetInfo.iCount++;

            }

        sortedNetworkNames.Remove( 0 );

        }

    CleanupStack::PopAndDestroy( &sortedNetworkNames );

    LOGEXITFN("CWlanSupport::ParseNetworkNamesL()")

    }

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

// CWlanSupport::CompareNetworkStrengths

//

// Compares two WLAN network signal strengths.

// It should return:

// 1. zero, if the two objects are equal.

// 2. a negative value, if the first object is less than the second.

// 3. a positive value, if the first object is greater than the second.

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

//

TInt CWlanSupport::CompareNetworkStrengths(

        const TConnMonNetwork& aFirst,

        const TConnMonNetwork& aSecond )

    {

    //LOGENTRFN("CWlanSupport::CompareNetworkStrengths()")

    TInt result( 0 );

    if ( aFirst.iSignalStrength < aSecond.iSignalStrength )

        {

        result = -1;

        }

    else if ( aFirst.iSignalStrength > aSecond.iSignalStrength )

        {

        result = 1;

        }

    //LOGEXITFN1("CWlanSupport::CompareNetworkStrengths()", result)

    return result;

    }

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

// CWlanSupport::AppendAvailableIaps

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

//

TInt CWlanSupport::AppendAvailableIaps( RArray<TUint>& aIdArray )

    {

    //LOGENTRFN("CWlanSupport::AppendAvailableIaps()")

    TInt err( KErrNone );

    if ( iEnableScan )

        {

        iAvailableWlanIapsCache.Reset();

        err = iWlanMgmt->GetAvailableIaps( iAvailableWlanIapsCache );

        LOGIT2("WLAN IAPs available: %d, err <%d> (from WLAN engine)", iAvailableWlanIapsCache.Count(), err)

        iEnableScan = EFalse;

        }

    else

        {

        LOGIT1("WLAN IAPs available: %d (from cache, no scan)", iAvailableWlanIapsCache.Count())

        }

    const TInt wlanIapCount( iAvailableWlanIapsCache.Count() );

    if ( KErrNone == err && wlanIapCount > 0 )

        {

        for ( TInt i = 0; i < wlanIapCount; i++ )

            {

            err = aIdArray.Append( iAvailableWlanIapsCache[i] );

            if ( err )

                {

                break;

                }

            }

        }

    //LOGEXITFN1("CWlanSupport::AppendAvailableIaps()", err)

    return err;

    }

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

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

//

TInt CWlanSupport::AppendAvailableIapsBySsidL( RArray<TUint>& aIdArray )

    {

    LOGENTRFN("CWlanSupport::AppendAvailableIapsBySsidL()")

    TInt ret( KErrNone );

    // Get ssid of current connection

    TWlanSsid currentSsid;

    ret = iWlanMgmt->GetConnectionSsid( currentSsid );

    if ( KErrNone != ret )

        {

        LOGIT1("ERROR reading current connection ssid from wlan engine <%d>", ret)

        ret = KErrDisconnected;

        }

    else

        {

        LOGTIMINGSTART("CWlanSupport::AppendAvailableIapsBySsidL")

        // Create a session with the latest version CommsDat

        CMDBSession* db = CMDBSession::NewLC( CMDBSession::LatestVersion() );

        db->SetAttributeMask( ECDProtectedWrite );

        TBuf<CConnMonWlanNetwork::KMaxNameLength> ssid16;

        CnvUtfConverter::ConvertToUnicodeFromUtf8( ssid16, currentSsid );

        LOGIT2("AppendAvailableIapsBySsidL: ssid: %S, length: %d", &ssid16, ssid16.Length())

        // Create wlan service record set

        CMDBRecordSet<CCDWlanServiceRecord>* wlanSet =

                new( ELeave ) CMDBRecordSet<CCDWlanServiceRecord>(

                        CCDWlanServiceRecord::TableIdL( *db ) );

        CleanupStack::PushL( wlanSet );

        // Create wlan service record

        CCDWlanServiceRecord* wlanRecord =

            new( ELeave ) CCDWlanServiceRecord( CCDWlanServiceRecord::TableIdL( *db ) );

        CleanupStack::PushL( wlanRecord );

        // Set ssid field in wlan service record (see wlancontainer.h)

        wlanRecord->iWLanSSID.SetL( ssid16 );

        // Append wlan service record to wlan service record set (currently empty)

        wlanSet->iRecords.AppendL( wlanRecord );

        CleanupStack::Pop( wlanRecord ); // Ownership moved

        // Find matching wlan service records (all wlan service records with same SSID)

        if ( wlanSet->FindL( *db ) )

            {

            TInt wlanRecordCount( wlanSet->iRecords.Count() );

            LOGIT1("AppendAvailableIapsBySsidL: wlan record count: %d", wlanRecordCount)

            // Loop for each record found

            for ( TInt i = 0; i < wlanRecordCount; i++ )

                {

                // Load current record to make sure all fields are up to date

                // LoadL() will only look at ElementId and updates the rest of the fields

                wlanRecord->SetElementId( wlanSet->iRecords[i]->ElementId() );

                wlanRecord->LoadL( *db );

                // Create IAP record

                CCDIAPRecord* iapRecord =

                    static_cast<CCDIAPRecord*>( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

                CleanupStack::PushL( iapRecord );

                iapRecord->iServiceType.SetL( TPtrC( KCDTypeNameLANService ) );

                // Set the service field to the same value as in the wlan service record we are currently looking

                iapRecord->iService = wlanRecord->iWlanServiceId;

                // Find matching IAP record

                if ( iapRecord->FindL( *db ) )

                    {

                    // Read IAP ID and append to buffer

                    TUint iapId = iapRecord->RecordId();

                    LOGIT2("AppendAvailableIapsBySsidL: index: %d, id: %d", i, iapId)

                    aIdArray.Append( iapId ); // Ignore if Append fails, ID will be absent from availability list.

                    }

                else

                    {

                    LOGIT("AppendAvailableIapsBySsidL: no matching IAP record found")

                    }

                CleanupStack::PopAndDestroy( iapRecord );

                }

            }

        else

            {

            LOGIT("AppendAvailableIapsBySsidL: no matching IAP records found")

            ret = KErrNotFound;

            }

        CleanupStack::PopAndDestroy( wlanSet );

        CleanupStack::PopAndDestroy( db );

        LOGTIMINGEND("CWlanSupport::AppendAvailableIapsBySsidL")

        }

    LOGEXITFN1("CWlanSupport::AppendAvailableIapsBySsidL()", ret)

    return ret;

    }

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

// CWlanSupport::GetConnectionSsid

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

//

TInt CWlanSupport::GetConnectionSsid( TDes& aSsid )

    {

    LOGENTRFN("CWlanSupport::GetConnectionSsid()")

    TInt err( KErrNone );

    TWlanSsid ssid;

    err = iWlanMgmt->GetConnectionSsid( ssid );

    if ( KErrNone == err )

        {