cmmanager/cmmgr/cmmplugins/cmpluginwlan/src/cmwlancoveragecheck.cpp
changeset 20 9c97ad6591ae
equal deleted inserted replaced
18:fcbbe021d614 20:9c97ad6591ae
       
     1 /*
       
     2 * Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *        Implementation of WLAN Coverage Check class
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 #include <wlanmgmtclient.h>
       
    21 
       
    22 #include "cmwlancoveragecheck.h"
       
    23 #include "cmpluginwlan.h"
       
    24 
       
    25 #include "OstTraceDefinitions.h"
       
    26 #ifdef OST_TRACE_COMPILER_IN_USE
       
    27 #include "cmwlancoveragecheckTraces.h"
       
    28 #endif
       
    29 
       
    30 
       
    31 /**
       
    32 * Management frame information element IDs.
       
    33 * needed to determine coverage
       
    34 */
       
    35 enum T802Dot11InformationElementID
       
    36     {
       
    37     E802Dot11SsidIE                 = 0,
       
    38     E802Dot11SupportedRatesIE       = 1,
       
    39     E802Dot11FhParameterSetIE       = 2,
       
    40     E802Dot11DsParameterSetIE       = 3,
       
    41     E802Dot11CfParameterSetIE       = 4,
       
    42     E802Dot11TimIE                  = 5,
       
    43     E802Dot11IbssParameterSetIE     = 6,
       
    44     E802Dot11CountryIE              = 7,
       
    45     E802Dot11HoppingPatternParamIE  = 8,
       
    46     E802Dot11HoppingPatternTableIE  = 9,
       
    47     E802Dot11RequestIE              = 10,
       
    48 
       
    49     E802Dot11ChallengeTextIE        = 16,
       
    50     // Reserved for challenge text extension 17 - 31
       
    51     E802Dot11ErpInformationIE       = 42,
       
    52     E802Dot11ExtendedRatesIE        = 50,
       
    53     E802Dot11AironetIE              = 133,
       
    54     E802Dot11ApIpAddressIE          = 149,
       
    55     E802Dot11RsnIE                  = 221
       
    56     };
       
    57 
       
    58 
       
    59 // ======================= MEMBER FUNCTIONS =================================
       
    60 
       
    61 // ----------------------------------------------------------------------------
       
    62 // CCmWlanCoverageCheck::CCmWlanCoverageCheck()
       
    63 // ----------------------------------------------------------------------------
       
    64 //
       
    65 CCmWlanCoverageCheck::CCmWlanCoverageCheck() : CActive( EPriorityStandard )
       
    66     {
       
    67     OstTraceFunctionEntry1( CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_ENTRY, this );
       
    68     CActiveScheduler::Add( this );
       
    69     OstTraceFunctionExit1( CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_EXIT, this );
       
    70     }
       
    71 
       
    72 // ----------------------------------------------------------------------------
       
    73 // CCmWlanCoverageCheck::~CCmWlanCoverageCheck()
       
    74 // ----------------------------------------------------------------------------
       
    75 //
       
    76 CCmWlanCoverageCheck::~CCmWlanCoverageCheck()
       
    77     {
       
    78     OstTraceFunctionEntry1( DUP1_CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_ENTRY, this );
       
    79     Cancel();
       
    80     OstTraceFunctionExit1( DUP1_CCMWLANCOVERAGECHECK_CCMWLANCOVERAGECHECK_EXIT, this );
       
    81     }
       
    82 
       
    83 // ----------------------------------------------------------------------------
       
    84 // CCmWlanCoverageCheck::DoCancel
       
    85 // ----------------------------------------------------------------------------
       
    86 //
       
    87 void CCmWlanCoverageCheck::DoCancel()
       
    88     {
       
    89     OstTraceFunctionEntry1( CCMWLANCOVERAGECHECK_DOCANCEL_ENTRY, this );
       
    90     iWait.AsyncStop();
       
    91     OstTraceFunctionExit1( CCMWLANCOVERAGECHECK_DOCANCEL_EXIT, this );
       
    92     }
       
    93 
       
    94 // ----------------------------------------------------------------------------
       
    95 // CCmWlanCoverageCheck::RunL
       
    96 // ----------------------------------------------------------------------------
       
    97 //
       
    98 void CCmWlanCoverageCheck::RunL()
       
    99     {
       
   100     OstTraceFunctionEntry1( CCMWLANCOVERAGECHECK_RUNL_ENTRY, this );
       
   101 
       
   102     switch ( iProgState )
       
   103         {
       
   104         case EScanning:
       
   105             {
       
   106             if ( iStatus.Int() == KErrNone )
       
   107                 {
       
   108                 // The list is ready.
       
   109                 iProgState = EDone;
       
   110                 iWait.AsyncStop();
       
   111                 }
       
   112             else
       
   113                 {
       
   114                 // Something went wrong -> no coverage.
       
   115                 iWait.AsyncStop();
       
   116                 }
       
   117             }
       
   118             break;
       
   119         case EDone:
       
   120             {
       
   121             iWait.AsyncStop();
       
   122             }
       
   123             break;
       
   124         default:
       
   125             {
       
   126             User::Leave( KErrCorrupt );
       
   127             }
       
   128             break;
       
   129         }
       
   130 
       
   131     OstTraceFunctionExit1( CCMWLANCOVERAGECHECK_RUNL_EXIT, this );
       
   132     }
       
   133 
       
   134 // ----------------------------------------------------------------------------
       
   135 // CCmWlanCoverageCheck::GetCoverageL
       
   136 // ----------------------------------------------------------------------------
       
   137 //
       
   138 TBool CCmWlanCoverageCheck::GetCoverageL()
       
   139     {
       
   140     OstTraceFunctionEntry0( CCMWLANCOVERAGECHECK_GETCOVERAGEL_ENTRY );
       
   141 
       
   142     iProgState = EServiceStatus;
       
   143     iCoverage = EFalse;
       
   144 
       
   145     CWlanMgmtClient* wlanMgmt = CWlanMgmtClient::NewL();
       
   146     CleanupStack::PushL( wlanMgmt );
       
   147 
       
   148     CWlanScanInfo* scanInfo = CWlanScanInfo::NewL();
       
   149     CleanupStack::PushL( scanInfo );
       
   150 
       
   151     iProgState = EScanning;
       
   152 
       
   153     wlanMgmt->GetScanResults( iStatus, *scanInfo );
       
   154 
       
   155     SetActive();
       
   156     iWait.Start();
       
   157 
       
   158     // now we have the results and might start to work on them...
       
   159     if ( iProgState == EDone )
       
   160         { //finished without error, work on the result...
       
   161 
       
   162         for ( scanInfo->First(); !scanInfo->IsDone(); scanInfo->Next() )
       
   163             {
       
   164             TBool isHidden( EFalse );
       
   165 
       
   166             TUint8 ieLen( 0 );
       
   167             const TUint8* ieData;
       
   168 
       
   169             TInt ret = scanInfo->InformationElement( E802Dot11SsidIE, ieLen,
       
   170                                                       &ieData );
       
   171             if ( ret == KErrNone )
       
   172                 {
       
   173                 isHidden = IsHiddenSsid( ieLen, ieData );
       
   174                 if ( !isHidden )
       
   175                     {
       
   176                     // WLAN awailable...stop searching.
       
   177                     iCoverage = ETrue;
       
   178                     break;
       
   179                     }
       
   180                 }
       
   181             else
       
   182                 {
       
   183                 User::Leave( ret );
       
   184                 }
       
   185             }
       
   186 
       
   187         CleanupStack::PopAndDestroy( 2, wlanMgmt );
       
   188         }
       
   189     else
       
   190         {
       
   191         // Clean the cleanupstack in case status is KErrNone
       
   192         CleanupStack::PopAndDestroy( scanInfo );
       
   193         CleanupStack::PopAndDestroy( wlanMgmt );
       
   194 
       
   195         User::LeaveIfError( iStatus.Int() );
       
   196         }
       
   197 
       
   198     OstTraceFunctionExit0( CCMWLANCOVERAGECHECK_GETCOVERAGEL_EXIT );
       
   199     return iCoverage;
       
   200     }
       
   201 
       
   202 // ---------------------------------------------------------
       
   203 // CCmWlanCoverageCheck::IsHiddenSsid
       
   204 // ---------------------------------------------------------
       
   205 //
       
   206 TBool CCmWlanCoverageCheck::IsHiddenSsid(
       
   207         TUint aSsidLength,
       
   208         const TUint8* aSsid ) const
       
   209     {
       
   210     OstTraceFunctionEntryExt( CCMWLANCOVERAGECHECK_ISHIDDENSSID_ENTRY, this );
       
   211 
       
   212     const TUint8 CSPACE = 0x20;
       
   213     TBool result( EFalse );
       
   214     TBool result2( ETrue );
       
   215 
       
   216     if ( !aSsidLength )
       
   217         {
       
   218         result = ETrue;
       
   219         }
       
   220 
       
   221     TInt count( 0 );
       
   222     TUint8 temp( 0x00 );
       
   223 
       
   224     for ( TUint i( 0 ); i < aSsidLength; ++i )
       
   225         {
       
   226         temp = aSsid[i];
       
   227         count += temp; // in hidden networks characters are: 0x00
       
   228         result2 &= temp == CSPACE ;
       
   229         }
       
   230 
       
   231     if ( !count || result2 )
       
   232         {
       
   233         result = ETrue;
       
   234         }
       
   235 
       
   236     OstTraceFunctionExitExt( CCMWLANCOVERAGECHECK_ISHIDDENSSID_EXIT, this, result );
       
   237     return result;
       
   238     }
       
   239