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 * WLAN Qt Utilities private implementation.

    16 */

    17 

    18 // System includes

    19 

    20 #include <QSharedPointer>

    21 

    22 // User includes

    23 

    24 #include "wlanqtutilsap.h"

    25 #include "wlanqtutilsiap.h"

    26 #include "wlanqtutilsconnection.h"

    27 #include "wlanqtutilsiapsettings.h"

    28 #include "wlanqtutilsconmonwrapper.h"

    29 #include "wlanqtutilsesockwrapper.h"

    30 #include "wlanqtutilsscan.h"

    31 

    32 #include "wlanqtutils.h"

    33 #include "wlanqtutils_p.h"

    34 

    35 #include "OstTraceDefinitions.h"

    36 #ifdef OST_TRACE_COMPILER_IN_USE

    37 #include "wlanqtutils_pTraces.h"

    38 #endif

    39 

    40 /*!

    41     \class WlanQtUtilsPrivate

    42     \brief Private implementation class for WLAN Qt Utilities.

    43 

    44     The private interface functions are identical to those in WlanQtUtils

    45     class, so refer to that for descriptions. Other functions contain

    46     implementation documentation.

    47 */

    48 

    49 

    50 // External function prototypes

    51 

    52 // Local constants

    53 

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

    55 

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

    57 

    58 /*!

    59     Constructor.

    60 */

    61 

    62 WlanQtUtilsPrivate::WlanQtUtilsPrivate(WlanQtUtils *q_ptr) :

    63     q_ptr(q_ptr),

    64     mSettings(new WlanQtUtilsIapSettings(this)),

    65     mConMonWrapper(new WlanQtUtilsConMonWrapper(this)),

    66     mScanWrapper(new WlanQtUtilsScan(this)),

    67     mEsockWrapper(new WlanQtUtilsEsockWrapper(this)),

    68     mIctService(),

    69     mScanMode(ScanModeNone),

    70     mIapScanList(),

    71     mWlanScanList(),

    72     mToBeTestedIapId(WlanQtUtils::IapIdNone), 

    73     mConnectingIapId(WlanQtUtils::IapIdNone),

    74     mConnection()

    75 {

    76     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_ENTRY, this);

    77 

    78     // Make all connections.

    79     bool connectStatus = connect(

    80         mScanWrapper,

    81         SIGNAL(availableWlanIaps(QList< QSharedPointer<WlanQtUtilsIap> > &)),

    82         this,

    83         SLOT(updateAvailableWlanIaps(QList< QSharedPointer<WlanQtUtilsIap> > &)));

    84     Q_ASSERT(connectStatus);

    85     

    86     connectStatus = connect(

    87         mScanWrapper, 

    88         SIGNAL(availableWlanAps(QList< QSharedPointer<WlanQtUtilsAp> >&)), 

    89         this, 

    90         SLOT(updateAvailableWlanAps(QList< QSharedPointer<WlanQtUtilsAp> >&)));

    91     Q_ASSERT(connectStatus);

    92     

    93     connectStatus = connect(

    94         mScanWrapper,

    95         SIGNAL(scanFailed(int)),

    96         this,

    97         SLOT(reportScanResult(int)));

    98     Q_ASSERT(connectStatus);

    99 

   100     connectStatus = connect(

   101         mEsockWrapper, 

   102         SIGNAL(connectionStatusFromWrapper(bool)), 

   103         this,

   104         SLOT(updateConnectionStatus(bool)));

   105     Q_ASSERT(connectStatus);

   106 

   107     connectStatus = connect(

   108         mConMonWrapper, 

   109         SIGNAL(connCreatedEventFromWrapper(uint)), 

   110         this,

   111         SLOT(addActiveConnection(uint)));

   112     Q_ASSERT(connectStatus);

   113 

   114     connectStatus = connect(

   115         mConMonWrapper, 

   116         SIGNAL(connDeletedEventFromWrapper(uint)), 

   117         this,

   118         SLOT(removeActiveConnection(uint)));

   119     Q_ASSERT(connectStatus);

   120 

   121     connectStatus = connect(

   122         mConMonWrapper, 

   123         SIGNAL(connStatusEventFromWrapper(uint, WlanQtUtils::ConnStatus)),

   124         this, 

   125         SLOT(updateActiveConnection(uint, WlanQtUtils::ConnStatus)));

   126     Q_ASSERT(connectStatus);

   127 

   128     // Retrieve initial status of active connections

   129     mConnection = QSharedPointer<WlanQtUtilsConnection>(

   130         mConMonWrapper->activeConnection());

   131 

   132     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_EXIT, this);

   133 }

   134 

   135 /*!

   136     Destructor. 

   137 */

   138 

   139 WlanQtUtilsPrivate::~WlanQtUtilsPrivate()

   140 {

   141     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_ENTRY, this);

   142     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_EXIT, this);

   143 }

   144 

   145 /*!

   146    See WlanQtUtils::scanWlans().

   147 */

   148 

   149 void WlanQtUtilsPrivate::scanWlans()

   150 {

   151     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANS_ENTRY, this);

   152 

   153     // Scanning while there is an ongoing scan is not supported

   154     Q_ASSERT(mScanMode == ScanModeNone);

   155     

   156     // Starting with an IAP scan, and continuing with AP scan

   157     mScanMode = ScanModeAvailableWlans;

   158     mScanWrapper->scanWlanIaps();

   159 

   160     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANS_EXIT, this);

   161 }

   162 

   163 /*!

   164    See WlanQtUtils::scanWlanAps().

   165 */

   166 

   167 void WlanQtUtilsPrivate::scanWlanAps()

   168 {

   169     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANAPS_ENTRY, this);

   170     

   171     // Scanning while there is an ongoing scan is not supported

   172     Q_ASSERT(mScanMode == ScanModeNone);

   173     

   174     // Just forward the request to wrapper, which triggers a broadcast WLAN scan

   175     mScanMode = ScanModeAvailableWlanAps;

   176     mScanWrapper->scanWlanAps();

   177 

   178     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANAPS_EXIT, this);

   179 }

   180 

   181 /*!

   182    See WlanQtUtils::scanWlanDirect().

   183 */

   184 

   185 void WlanQtUtilsPrivate::scanWlanDirect(const QString &ssid)

   186 {

   187     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANDIRECT_ENTRY, this);

   188 

   189     // Scanning while there is an ongoing scan is not supported

   190     Q_ASSERT(mScanMode == ScanModeNone);

   191     

   192     // Just forward the request to wrapper, which triggers a direct WLAN scan

   193     mScanMode = ScanModeDirect;

   194     mScanWrapper->scanWlanDirect(ssid);

   195     

   196     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANDIRECT_EXIT, this);

   197 }

   198 

   199 /*!

   200    See WlanQtUtils::stopWlanScan().

   201 */

   202 

   203 void WlanQtUtilsPrivate::stopWlanScan()

   204 {

   205     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_STOPWLANSCAN_ENTRY, this);

   206     

   207     if (mScanMode != ScanModeNone) {

   208         // Inform that scan was cancelled

   209         reportScanResult(WlanQtUtils::ScanStatusCancelled);

   210         

   211         // Stop the scan

   212         mScanMode = ScanModeNone;

   213         mScanWrapper->stopScan();

   214     }

   215     

   216     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_STOPWLANSCAN_EXIT, this);

   217 }

   218 

   219 /*!

   220    See WlanQtUtils::availableWlans().

   221 */

   222 

   223 void WlanQtUtilsPrivate::availableWlans(

   224     QList< QSharedPointer<WlanQtUtilsIap> > &wlanIapList,

   225     QList< QSharedPointer<WlanQtUtilsAp> > &wlanApList) const

   226 {

   227     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_AVAILABLEWLAN_ENTRY, this);

   228 

   229     wlanIapList.clear();

   230     wlanApList.clear();

   231 

   232     // Read the list of configured IAPs

   233     QList< QSharedPointer<WlanQtUtilsIap> > configuredIapList;

   234     mSettings->fetchIaps(configuredIapList);

   235 

   236     // Update the list of available IAPs

   237     foreach (QSharedPointer<WlanQtUtilsIap> iapIter, mIapScanList) {

   238         int iapId = iapIter->value(WlanQtUtilsIap::ConfIdIapId).toInt();

   239         QSharedPointer<WlanQtUtilsIap> iap(mSettings->fetchIap(iapId));

   240         if (iap) {

   241             // Only add the IAP if we (still) have the settings for it

   242             iap->setValue(

   243                 WlanQtUtilsAp::ConfIdSignalStrength,

   244                 iapIter->value(WlanQtUtilsAp::ConfIdSignalStrength));

   245             wlanIapList.append(iap);

   246         }

   247     }

   248 

   249     // Go through the scan results to find unknown APs

   250     for (int i = 0; i < mWlanScanList.count(); i++) {

   251         // Check whether an IAP with these parameters exists (in which

   252         // case this network is already added as an IAP in the loop above)

   253         if (!wlanIapExists(configuredIapList, mWlanScanList[i].data())) {

   254             // No IAP found in, copy the AP to caller's list of

   255             // unknown APs

   256             wlanApList.append(mWlanScanList[i]);

   257         }

   258     }

   259 

   260     traceIapsAndAps(wlanIapList, wlanApList);

   261 

   262     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_AVAILABLEWLAN_EXIT, this);

   263 }

   264 

   265 /*!

   266    See WlanQtUtils::availableWlanAps().

   267 */

   268 

   269 void WlanQtUtilsPrivate::availableWlanAps(

   270     QList< QSharedPointer<WlanQtUtilsAp> > &wlanApList) const

   271 {

   272     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_ENTRY, this);

   273     

   274     // Just copy the results

   275     wlanApList = mWlanScanList;

   276     

   277     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_EXIT, this);

   278 }

   279 

   280 /*!

   281    See WlanQtUtils::createIap().

   282 */

   283 

   284 int WlanQtUtilsPrivate::createIap(const WlanQtUtilsAp *wlanAp)

   285 {

   286     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_CREATEIAP_ENTRY, this);

   287 

   288     // Create the new IAP and return its ID

   289     int newIapId = mSettings->createIap(wlanAp);

   290 

   291     OstTrace1(

   292         TRACE_BORDER,

   293         WLANQTUTILSPRIVATE_CREATEIAP,

   294         "WlanQtUtilsPrivate::createIap;New IAP ID=%d",

   295         newIapId);

   296         

   297     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_CREATEIAP_EXIT, this);

   298     return newIapId;

   299 }

   300 

   301 /*!

   302    See WlanQtUtils::updateIap().

   303 */

   304 

   305 bool WlanQtUtilsPrivate::updateIap(int iapId, const WlanQtUtilsAp *wlanAp)

   306 {

   307     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEIAP_ENTRY, this);

   308 

   309     bool success = mSettings->updateIap(iapId, wlanAp);

   310     

   311     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEIAP_EXIT, this);

   312     return success;

   313 }

   314 

   315 /*!

   316    See WlanQtUtils::deleteIap().

   317 */

   318 

   319 void WlanQtUtilsPrivate::deleteIap(int iapId)

   320 {

   321     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_DELETEIAP_ENTRY, this);

   322 

   323     mSettings->deleteIap(iapId);

   324 

   325     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_DELETEIAP_EXIT, this);

   326 }

   327 

   328 /*!

   329    See WlanQtUtils::connectIap().

   330 */

   331 

   332 void WlanQtUtilsPrivate::connectIap(int iapId, bool runIct)

   333 {

   334     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_CONNECTIAP_ENTRY, this);

   335     

   336     OstTraceExt2(

   337         TRACE_BORDER,

   338         WLANQTUTILSPRIVATE_CONNECTIAP,

   339         "WlanQtUtilsPrivate::connectIap;IAP ID=%d;runIct=%hhu",

   340         iapId,

   341         runIct);

   342 

   343     Q_ASSERT(iapId != WlanQtUtils::IapIdNone);

   344 

   345     if (runIct) {

   346         // Mark this IAP for ICT testing after it has been opened

   347         mToBeTestedIapId = iapId;

   348     }

   349     mConnectingIapId = iapId;

   350     mEsockWrapper->connectIap(iapId);

   351 

   352     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_CONNECTIAP_EXIT, this);

   353 }

   354 

   355 /*!

   356    See WlanQtUtils::disconnectIap().

   357 */

   358 

   359 void WlanQtUtilsPrivate::disconnectIap(int iapId)

   360 {

   361     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_DISCONNECTIAP_ENTRY, this);

   362     

   363     OstTrace1(

   364         TRACE_BORDER,

   365         WLANQTUTILSPRIVATE_DISCONNECTIAP,

   366         "WlanQtUtilsPrivate::disconnectIap;IAP ID=%d",

   367         iapId);

   368 

   369     if (iapId != WlanQtUtils::IapIdNone) {

   370         // Close our RConnection handle, if needed. Wrapper ignores call, if

   371         // no handle exists.

   372         mEsockWrapper->disconnectIap();

   373         

   374         // In order to close connection even if there are other users for the

   375         // IAP, close also via ConMon

   376         mConMonWrapper->disconnectIap(iapId);

   377     } // else: just ignore call

   378 

   379     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_DISCONNECTIAP_EXIT, this);

   380 }

   381 

   382 /*!

   383    See WlanQtUtils::connectionStatus().

   384 */

   385 

   386 WlanQtUtils::ConnStatus WlanQtUtilsPrivate::connectionStatus() const

   387 {

   388     OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_CONNECTIONSTATUS_ENTRY);

   389 

   390     WlanQtUtils::ConnStatus status = WlanQtUtils::ConnStatusDisconnected;

   391     

   392     if (mConnection) {

   393         status = mConnection->connectionStatus();

   394     }

   395     OstTrace1(

   396         TRACE_BORDER,

   397         WLANQTUTILSPRIVATE_CONNECTIONSTATUS,

   398         "WlanQtUtilsPrivate::connectionStatus;status=%{ConnStatus};",

   399         (TUint)status);

   400     

   401     OstTraceFunctionExit0(WLANQTUTILSPRIVATE_CONNECTIONSTATUS_EXIT);

   402     return status;

   403 }

   404 

   405 /*!

   406    See WlanQtUtils::activeIap().

   407 */

   408 

   409 int WlanQtUtilsPrivate::activeIap() const

   410 {

   411     OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_ACTIVEIAP_ENTRY);

   412 

   413     int iapId = WlanQtUtils::IapIdNone;

   414     

   415     if (mConnection) {

   416         iapId = mConnection->iapId();

   417     }

   418     OstTrace1(

   419         TRACE_BORDER,

   420         WLANQTUTILSPRIVATE_ACTIVEIAP,

   421         "WlanQtUtilsPrivate::activeIap;iapId=%d",

   422         iapId);

   423     

   424     OstTraceFunctionExit0(WLANQTUTILSPRIVATE_ACTIVEIAP_EXIT);

   425     return iapId;

   426 }

   427 

   428 /*!

   429    See WlanQtUtils::iapName().

   430 */

   431 

   432 QString WlanQtUtilsPrivate::iapName(int iapId) const

   433 {

   434     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_IAPNAME_ENTRY, this);

   435     

   436     QString name;

   437     // Read the IAP from settings and return its name

   438     QSharedPointer<WlanQtUtilsIap> iap = mSettings->fetchIap(iapId);

   439     if (iap) {

   440         name = iap->value(WlanQtUtilsIap::ConfIdName).toString();

   441     }

   442 

   443     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_IAPNAME_EXIT, this);

   444     return name;

   445 }

   446 

   447 /*!

   448     This function searches for a WLAN IAP matching the given WLAN AP.

   449 

   450     @param [in] list List to search from.

   451     @param [in] ap Access point to search for.

   452     

   453     @return True, if suitable WLAN IAP found, false otherwise.

   454 */

   455 

   456 bool WlanQtUtilsPrivate::wlanIapExists(

   457     const QList< QSharedPointer<WlanQtUtilsIap> > list,

   458     const WlanQtUtilsAp *ap) const

   459 {

   460     bool match = false;     // Return value

   461     

   462     foreach (QSharedPointer<WlanQtUtilsIap> iap, list) {

   463         if (WlanQtUtilsAp::compare(iap.data(), ap) == 0) {

   464             // Match found

   465             match = true;

   466             break;

   467         }

   468     }

   469     

   470     return match;

   471 }

   472 

   473 /*!

   474     This function traces the given IAPs and APs.

   475 

   476     @param [in] iaps IAPs to trace.

   477     @param [in] aps APs to trace.

   478 */

   479 

   480 void WlanQtUtilsPrivate::traceIapsAndAps(

   481     const QList<QSharedPointer<WlanQtUtilsIap> > &iaps,

   482     const QList<QSharedPointer<WlanQtUtilsAp> > &aps) const

   483 {

   484 #ifndef OST_TRACE_COMPILER_IN_USE

   485     Q_UNUSED(iaps);

   486     Q_UNUSED(aps);

   487 #else

   488     foreach (QSharedPointer<WlanQtUtilsIap> iap, iaps) {

   489         QString tmp(iap->value(WlanQtUtilsIap::ConfIdName).toString());

   490         TPtrC16 name(tmp.utf16(), tmp.length());

   491         OstTraceExt3(

   492             TRACE_NORMAL,

   493             WLANQTUTILSPRIVATE_TRACEAVAILABLEWLANAPS_IAP,

   494             "WlanQtUtilsPrivate::traceAvailableWlanAps IAP;name=%S;secMode=%{WlanSecMode};signalStrength=%d",

   495             name,

   496             iap->value(WlanQtUtilsAp::ConfIdSecurityMode).toInt(),

   497             iap->value(WlanQtUtilsAp::ConfIdSignalStrength).toInt());

   498     }

   499     foreach (QSharedPointer<WlanQtUtilsAp> ap, aps) {

   500         QString tmp(ap->value(WlanQtUtilsAp::ConfIdSsid).toString());

   501         TPtrC16 ssid(tmp.utf16(), tmp.length());

   502         OstTraceExt3(

   503             TRACE_NORMAL,

   504             WLANQTUTILSPRIVATE_TRACEAVAILABLEWLANAPS_AP,

   505             "WlanQtUtilsPrivate::traceAvailableWlanAps AP;ssid=%S;secMode=%{WlanSecMode};signalStrength=%d",

   506             ssid,

   507             ap->value(WlanQtUtilsAp::ConfIdSecurityMode).toInt(),

   508             ap->value(WlanQtUtilsAp::ConfIdSignalStrength).toInt());

   509     }

   510 #endif

   511 }

   512 

   513 /*!

   514     Slot for handling WLAN IAP scan result event from wrapper. Results are

   515     stored in a member variable.

   516 

   517     @param [in] availableIaps Available WLAN IAP's found in scan.

   518 */

   519 

   520 void WlanQtUtilsPrivate::updateAvailableWlanIaps(

   521     QList< QSharedPointer<WlanQtUtilsIap> > &availableIaps)

   522 {

   523     OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANIAPS_ENTRY);

   524 

   525     // Store the new IAP list

   526     mIapScanList = availableIaps;

   527 

   528     // Continue with AP scan (which should come immediately from WLAN's scan cache)

   529     mScanWrapper->scanWlanAps();

   530     

   531     OstTraceFunctionExit0(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANIAPS_EXIT);

   532 }

   533 

   534 /*!

   535     Slot for handling WLAN AP scan result event from wrapper. Results are

   536     stored in member variable (possible duplicates are removed).

   537 

   538     @param [in] availableWlanList WLAN networks found in scan.

   539 */

   540 

   541 void WlanQtUtilsPrivate::updateAvailableWlanAps(

   542     QList< QSharedPointer<WlanQtUtilsAp> > &availableWlanList)

   543 {

   544     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_ENTRY, this);

   545 

   546     // Old results are removed

   547     mWlanScanList.clear();

   548     

   549     // Copy available WLANs to scan result list (duplicates are removed)

   550     for (int i = 0; i < availableWlanList.count(); i++) {

   551         bool duplicate = false;

   552         for (int j = 0; j < mWlanScanList.count(); j++) {

   553             if (WlanQtUtilsAp::compare(

   554                 availableWlanList[i].data(),

   555                 mWlanScanList[j].data()) == 0) {

   556                 duplicate = true;

   557                 break;

   558             }

   559         }

   560         if (duplicate == false) {

   561             mWlanScanList.append(availableWlanList[i]);

   562         }

   563     }

   564 

   565     // The information is forwarded to the client

   566     reportScanResult(WlanQtUtils::ScanStatusOk);

   567 

   568     // Scan is complete

   569     mScanMode = ScanModeNone;

   570 

   571     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_EXIT, this);

   572 }

   573 

   574 /*!

   575     Scan result handler. Reports the scanning result to the client.

   576         

   577     @param [in] status Scan status code (WlanQtUtils::ScanStatus).

   578 */

   579 

   580 void WlanQtUtilsPrivate::reportScanResult(int status)

   581 {

   582     switch (mScanMode) {

   583     case ScanModeAvailableWlans:

   584         OstTrace1(

   585             TRACE_BORDER,

   586             WLANQTUTILSPRIVATE_WLANSCANREADY,

   587             "WlanQtUtilsPrivate::reportScanResult emit wlanScanReady;status=%{ScanStatus};",

   588             status);

   589         emit q_ptr->wlanScanReady(status);

   590         break;

   591 

   592     case ScanModeAvailableWlanAps:

   593         OstTrace1(

   594             TRACE_BORDER,

   595             WLANQTUTILSPRIVATE_WLANSCANAPREADY,

   596             "WlanQtUtilsPrivate::reportScanResult emit wlanScanApReady;status=%{ScanStatus};",

   597             status);

   598         emit q_ptr->wlanScanApReady(status);

   599         break;

   600 

   601     case ScanModeDirect:

   602         OstTrace1(

   603             TRACE_BORDER,

   604             WLANQTUTILSPRIVATE_WLANSCANDIRECTREADY,

   605             "WlanQtUtilsPrivate::reportScanResult emit wlanScanDirectReady;status=%{ScanStatus};",

   606             status);

   607         emit q_ptr->wlanScanDirectReady(status);

   608         break;

   609 

   610 #ifndef QT_NO_DEBUG

   611     default:

   612         // Invalid scan mode detected

   613         Q_ASSERT(0);

   614         break;

   615 #endif        

   616     }

   617 }

   618 

   619 /*!

   620     Slot for handling connection setup status event from wrapper.

   621 

   622     @param [in] isOpened Was connection setup successful?

   623 */

   624 

   625 void WlanQtUtilsPrivate::updateConnectionStatus(bool isOpened)

   626 {

   627     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_ENTRY, this);

   628 

   629     if (isOpened == false) {

   630         // Opening failed, update connection status and inform UI

   631         if (mConnection) {

   632             mConnection->setConnectionStatus(

   633                 WlanQtUtils::ConnStatusDisconnected);

   634         }

   635         

   636         // Include the status code from connection wrapper

   637         int status = mEsockWrapper->lastStatusCode();

   638         OstTraceExt2(

   639             TRACE_BORDER,

   640             WLANQTUTILSPRIVATE_WLANNETWORKCLOSED,

   641             "WlanQtUtilsPrivate::emit wlanNetworkClosed;IAP ID=%d;status=%d",

   642             mConnectingIapId,

   643             status);

   644         emit q_ptr->wlanNetworkClosed(mConnectingIapId, status);

   645     } else {

   646         // Opening succeeded, update connection status and inform UI

   647         if (mConnection) {

   648             mConnection->setConnectionStatus(WlanQtUtils::ConnStatusConnected);

   649         }

   650         

   651         OstTrace1(

   652             TRACE_BORDER,

   653             WLANQTUTILSPRIVATE_WLANNETWORKOPENED,

   654             "WlanQtUtilsPrivate::emit wlanNetworkOpened;IAP ID=%d",

   655             mConnectingIapId);

   656         emit q_ptr->wlanNetworkOpened(mConnectingIapId);

   657 

   658         // Start ICT, if needed

   659         if (mConnectingIapId == mToBeTestedIapId) {

   660             QSharedPointer<WlanQtUtilsIap> iap(mSettings->fetchIap(mConnectingIapId));

   661             

   662             mIctService = QSharedPointer<IctsWlanLoginInterface>(

   663                 new IctsWlanLoginInterface(this));

   664             

   665             // IctsWlanLoginInterface instance is created for each connectivity test

   666             // Note: Queued connection is required since mIctService is deleted

   667             // when signal comes

   668             bool connectStatus = connect(

   669                 mIctService.data(),

   670                 SIGNAL(ictsResult(int)),

   671                 this,

   672                 SLOT(updateIctResult(int)),

   673                 Qt::QueuedConnection); 

   674             Q_ASSERT(connectStatus);            

   675             connectStatus = connect(

   676                 mIctService.data(),

   677                 SIGNAL(hotspotCase()),

   678                 this,

   679                 SLOT(updateIctHotspotCase()),

   680                 Qt::QueuedConnection);

   681             Q_ASSERT(connectStatus);

   682             

   683             mIctService->start(

   684                 mToBeTestedIapId,

   685                 iap->value(WlanQtUtilsIap::ConfIdNetworkId).toInt());

   686         }

   687     }

   688     // IAP is no more in connecting state

   689     mConnectingIapId = WlanQtUtils::IapIdNone;

   690 

   691     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_EXIT, this);

   692 }

   693 

   694 /*!

   695     Slot for handling internet connectivity test result event from wrapper.

   696     Tested IAP is stored to Internet SNAP, if test was successful. If the

   697     IAP needs Hotspot authentication, it remains ungategorized.

   698 

   699     @param [in] result Result of internet connectivity test and hotspot

   700                        authentication (IctsWlanLoginInterface::ictsResultType).

   701 */

   702 

   703 void WlanQtUtilsPrivate::updateIctResult(int ictsResult)

   704 {

   705     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEICTRESULT_ENTRY, this);

   706 

   707     Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone);

   708     WlanQtUtils::IctStatus result = WlanQtUtils::IctFailed;

   709     

   710     if (ictsResult == IctsWlanLoginInterface::IctsPassed) {

   711         // Move the tested IAP to Internet SNAP since the test passed

   712         Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone);

   713         mSettings->moveIapToInternetSnap(mToBeTestedIapId);

   714         result = WlanQtUtils::IctPassed;

   715     } else if (ictsResult == IctsWlanLoginInterface::IctsHotspotPassed) {

   716         Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone);

   717         result = WlanQtUtils::IctHotspotPassed;

   718     } else if (ictsResult == IctsWlanLoginInterface::IctsCanceled) {

   719         Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone);

   720         result = WlanQtUtils::IctCancelled;

   721     } else {

   722         // ICTS failed - IAP remains to be uncategorized and mIctService is deleted.

   723         mIctService.clear();

   724     }

   725     

   726     // Inform UI

   727     OstTraceExt2(

   728         TRACE_NORMAL,

   729         WLANQTUTILSPRIVATE_ICTRESULT,

   730         "WlanQtUtilsPrivate::emit ictResult;iapId=%d;result=%{IctStatus}",

   731         mToBeTestedIapId,

   732         result);

   733 

   734     emit q_ptr->ictResult(mToBeTestedIapId, result);

   735 

   736     // This IAP is now tested

   737     mToBeTestedIapId = WlanQtUtils::IapIdNone;

   738 

   739     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEICTRESULT_EXIT, this);

   740 }

   741 

   742 /*!

   743     Slot for setting IAP to be tested as hotspot IAP.

   744 */

   745 

   746 void WlanQtUtilsPrivate::updateIctHotspotCase()

   747 {

   748     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEICTHOTSPOTCASE_ENTRY, this);

   749 

   750     mSettings->setAsHotspotIap(mToBeTestedIapId);

   751   

   752     Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone);

   753     OstTrace1(

   754         TRACE_BORDER,

   755         WLANQTUTILSPRIVATE_UPDATEICTHOTSPOTCASE,

   756         "WlanQtUtilsPrivate::updateIctHotspotCase set as hotspot IAP;iapId=%d",

   757         mToBeTestedIapId);

   758         

   759     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEICTHOTSPOTCASE_EXIT, this);

   760 }

   761 

   762 /*!

   763     Slot for updating active connection status from wrapper.

   764 

   765     @param [in] connectionId ID of the new connection.

   766 */

   767 

   768 void WlanQtUtilsPrivate::addActiveConnection(uint connectionId)

   769 {

   770     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_ENTRY, this);

   771     OstTrace1(

   772         TRACE_BORDER,

   773         WLANQTUTILSPRIVATE_ADDACTIVECONNECTION,

   774         "WlanQtUtilsPrivate::addActiveConnection;connectionId=%u",

   775         connectionId);

   776 

   777     Q_ASSERT(mConnection == NULL);

   778     mConnection = QSharedPointer<WlanQtUtilsConnection>(

   779         mConMonWrapper->connectionInfo(connectionId));

   780 

   781     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_EXIT, this);

   782 }

   783 

   784 /*!

   785     Slot for updating active connection status from wrapper.

   786 

   787     @param [in] connectionId ID of the deleted connection.

   788 */

   789 

   790 void WlanQtUtilsPrivate::removeActiveConnection(uint connectionId)

   791 {

   792     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_ENTRY, this);

   793     OstTrace1(

   794         TRACE_BORDER,

   795         WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION,

   796         "WlanQtUtilsPrivate::removeActiveConnection;connectionId=%u",

   797         connectionId);

   798 

   799     Q_ASSERT(mConnection);

   800     if (mConnection->connectionId() == connectionId) {

   801         int closedIapId = mConnection->iapId();

   802         mConnection.clear();

   803 

   804         if (mConnectingIapId != closedIapId) {

   805             // Connection is closed, inform UI. wlanNetworkClosed is sent

   806             // from here instead of updateActiveConnection(closed),

   807             // because, in some cases, connection may be removed without

   808             // any connection status updates.

   809             // Note: reason parameter is not accurate here, because it is

   810             // only relevant for connections opened by this dll

   811             // (updateConnectionStatus)

   812             OstTraceExt2(

   813                 TRACE_BORDER,

   814                 DUP1_WLANQTUTILSPRIVATE_WLANNETWORKCLOSED,

   815                 "WlanQtUtilsPrivate::emit wlanNetworkClosed;iapID=%d;status=%d",

   816                 closedIapId,

   817                 KErrNone);

   818             emit q_ptr->wlanNetworkClosed(closedIapId, KErrNone);

   819         }

   820         // else: connection creation started by thid dll, but creation failed

   821         // -> wlanNetworkClosed is sent from updateConnectionStatus

   822     }

   823 

   824     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_EXIT, this);

   825 }

   826 

   827 /*!

   828     Slot for updating active connection status from wrapper.

   829 

   830     @param [in] connectionId ID of the updated connection.

   831     @param [in] connectionStatus New status of the connection.

   832 */

   833 

   834 void WlanQtUtilsPrivate::updateActiveConnection(

   835     uint connectionId,

   836     WlanQtUtils::ConnStatus connectionStatus)

   837 {

   838     OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_ENTRY, this);

   839     OstTraceExt2(

   840         TRACE_BORDER,

   841         WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION,

   842         "WlanQtUtilsPrivate::updateActiveConnection;connectionId=%u;connectionStatus=%{ConnStatus}",

   843         connectionId,

   844         (uint)connectionStatus);

   845 

   846     Q_ASSERT(mConnection);

   847     if (mConnection->connectionId() == connectionId

   848         && mConnection->connectionStatus() != connectionStatus) {

   849         // Update connection status and inform UI, if necessary

   850         mConnection->setConnectionStatus(connectionStatus);

   851         if (connectionStatus == WlanQtUtils::ConnStatusConnected) {

   852             OstTrace1(

   853                 TRACE_BORDER,

   854                 DUP1_WLANQTUTILSPRIVATE_WLANNETWORKOPENED,

   855                 "WlanQtUtilsPrivate::emit wlanNetworkOpened;iapId=%d",

   856                 mConnection->iapId());

   857             emit q_ptr->wlanNetworkOpened(mConnection->iapId());

   858         }

   859         // Do not inform UI about connection closing here. It is done in

   860         // removeActiveConnection(), because that may occur without any

   861         // connection status updates.

   862     } // else: connection status did not change

   863 

   864     OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_EXIT, this);

   865 }