/*
* 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 "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 WLAN Coverage Check class
*
*/


#include <wlanmgmtclient.h>

#include "cmwlancoveragecheck.h"
#include "cmpluginwlan.h"

#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "cmwlancoveragecheckTraces.h"
#endif


/**
* Management frame information element IDs.
* needed to determine coverage
*/
enum T802Dot11InformationElementID
    {
    E802Dot11SsidIE                 = 0,
    E802Dot11SupportedRatesIE       = 1,
    E802Dot11FhParameterSetIE       = 2,
    E802Dot11DsParameterSetIE       = 3,
    E802Dot11CfParameterSetIE       = 4,
    E802Dot11TimIE                  = 5,
    E802Dot11IbssParameterSetIE     = 6,
    E802Dot11CountryIE              = 7,
    E802Dot11HoppingPatternParamIE  = 8,
    E802Dot11HoppingPatternTableIE  = 9,
    E802Dot11RequestIE              = 10,

    E802Dot11ChallengeTextIE        = 16,
    // Reserved for challenge text extension 17 - 31
    E802Dot11ErpInformationIE       = 42,
    E802Dot11ExtendedRatesIE        = 50,
    E802Dot11AironetIE              = 133,
    E802Dot11ApIpAddressIE          = 149,
    E802Dot11RsnIE                  = 221
    };


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

// ----------------------------------------------------------------------------
// CCmWlanCoverageCheck::CCmWlanCoverageCheck()
// ----------------------------------------------------------------------------
//
CCmWlanCoverageCheck::CCmWlanCoverageCheck() : CActive( EPriorityStandard )
    {
    OstTraceFunctionEntry1( CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_ENTRY, this );
    CActiveScheduler::Add( this );
    OstTraceFunctionExit1( CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_EXIT, this );
    }

// ----------------------------------------------------------------------------
// CCmWlanCoverageCheck::~CCmWlanCoverageCheck()
// ----------------------------------------------------------------------------
//
CCmWlanCoverageCheck::~CCmWlanCoverageCheck()
    {
    OstTraceFunctionEntry1( DUP1_CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_ENTRY, this );
    Cancel();
    OstTraceFunctionExit1( DUP1_CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_EXIT, this );
    }

// ----------------------------------------------------------------------------
// CCmWlanCoverageCheck::DoCancel
// ----------------------------------------------------------------------------
//
void CCmWlanCoverageCheck::DoCancel()
    {
    OstTraceFunctionEntry1( CCMWLANCOVERAGECHECK_DOCANCEL_ENTRY, this );
    iWait.AsyncStop();
    OstTraceFunctionExit1( CCMWLANCOVERAGECHECK_DOCANCEL_EXIT, this );
    }

// ----------------------------------------------------------------------------
// CCmWlanCoverageCheck::RunL
// ----------------------------------------------------------------------------
//
void CCmWlanCoverageCheck::RunL()
    {
    OstTraceFunctionEntry1( CCMWLANCOVERAGECHECK_RUNL_ENTRY, this );

    switch ( iProgState )
        {
        case EScanning:
            {
            if ( iStatus.Int() == KErrNone )
                {
                // The list is ready.
                iProgState = EDone;
                iWait.AsyncStop();
                }
            else
                {
                // Something went wrong -> no coverage.
                iWait.AsyncStop();
                }
            }
            break;
        case EDone:
            {
            iWait.AsyncStop();
            }
            break;
        default:
            {
            User::Leave( KErrCorrupt );
            }
            break;
        }

    OstTraceFunctionExit1( CCMWLANCOVERAGECHECK_RUNL_EXIT, this );
    }

// ----------------------------------------------------------------------------
// CCmWlanCoverageCheck::GetCoverageL
// ----------------------------------------------------------------------------
//
TBool CCmWlanCoverageCheck::GetCoverageL()
    {
    OstTraceFunctionEntry0( CCMWLANCOVERAGECHECK_GETCOVERAGEL_ENTRY );

    iProgState = EServiceStatus;
    iCoverage = EFalse;

    CWlanMgmtClient* wlanMgmt = CWlanMgmtClient::NewL();
    CleanupStack::PushL( wlanMgmt );

    CWlanScanInfo* scanInfo = CWlanScanInfo::NewL();
    CleanupStack::PushL( scanInfo );

    iProgState = EScanning;

    wlanMgmt->GetScanResults( iStatus, *scanInfo );

    SetActive();
    iWait.Start();

    // now we have the results and might start to work on them...
    if ( iProgState == EDone )
        { //finished without error, work on the result...

        for ( scanInfo->First(); !scanInfo->IsDone(); scanInfo->Next() )
            {
            TBool isHidden( EFalse );

            TUint8 ieLen( 0 );
            const TUint8* ieData;

            TInt ret = scanInfo->InformationElement( E802Dot11SsidIE, ieLen,
                                                      &ieData );
            if ( ret == KErrNone )
                {
                isHidden = IsHiddenSsid( ieLen, ieData );
                if ( !isHidden )
                    {
                    // WLAN awailable...stop searching.
                    iCoverage = ETrue;
                    break;
                    }
                }
            else
                {
                User::Leave( ret );
                }
            }

        CleanupStack::PopAndDestroy( 2, wlanMgmt );
        }
    else
        {
        // Clean the cleanupstack in case status is KErrNone
        CleanupStack::PopAndDestroy( scanInfo );
        CleanupStack::PopAndDestroy( wlanMgmt );

        User::LeaveIfError( iStatus.Int() );
        }

    OstTraceFunctionExit0( CCMWLANCOVERAGECHECK_GETCOVERAGEL_EXIT );
    return iCoverage;
    }

// ---------------------------------------------------------
// CCmWlanCoverageCheck::IsHiddenSsid
// ---------------------------------------------------------
//
TBool CCmWlanCoverageCheck::IsHiddenSsid(
        TUint aSsidLength,
        const TUint8* aSsid ) const
    {
    OstTraceFunctionEntryExt( CCMWLANCOVERAGECHECK_ISHIDDENSSID_ENTRY, this );

    const TUint8 CSPACE = 0x20;
    TBool result( EFalse );
    TBool result2( ETrue );

    if ( !aSsidLength )
        {
        result = ETrue;
        }

    TInt count( 0 );
    TUint8 temp( 0x00 );

    for ( TUint i( 0 ); i < aSsidLength; ++i )
        {
        temp = aSsid[i];
        count += temp; // in hidden networks characters are: 0x00
        result2 &= temp == CSPACE ;
        }

    if ( !count || result2 )
        {
        result = ETrue;
        }

    OstTraceFunctionExitExt( CCMWLANCOVERAGECHECK_ISHIDDENSSID_EXIT, this, result );
    return result;
    }