diff -r dbe86d96ce5b -r 2dc6da6fb431 wlanutilities/wlanqtutilities/base/src/wlanqtutils_p.cpp --- a/wlanutilities/wlanqtutilities/base/src/wlanqtutils_p.cpp Thu May 27 13:59:00 2010 +0300 +++ b/wlanutilities/wlanqtutilities/base/src/wlanqtutils_p.cpp Fri Jun 11 14:43:07 2010 +0300 @@ -1,5 +1,5 @@ /* -* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* 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" @@ -12,12 +12,19 @@ * Contributors: * * Description: +* WLAN Qt Utilities private implementation. */ -#include "wlanqtutilswlanap.h" -#include "wlanqtutilswlaniap.h" -#include "wlanqtutilsactiveconn.h" -#include "wlanqtutilscmmwrapper.h" +// System includes + +#include + +// User includes + +#include "wlanqtutilsap.h" +#include "wlanqtutilsiap.h" +#include "wlanqtutilsconnection.h" +#include "wlanqtutilsiapsettings.h" #include "wlanqtutilsconmonwrapper.h" #include "wlanqtutilsesockwrapper.h" #include "wlanqtutilsconntestwrapper.h" @@ -25,466 +32,690 @@ #include "wlanqtutils.h" #include "wlanqtutils_p.h" -#ifdef WLANQTUTILS_NO_OST_TRACES_FLAG -#include -#else #include "OstTraceDefinitions.h" -#endif #ifdef OST_TRACE_COMPILER_IN_USE #include "wlanqtutils_pTraces.h" #endif +/*! + \class WlanQtUtilsPrivate + \brief Private implementation class for WLAN Qt Utilities. -WlanQtUtilsPrivate::WlanQtUtilsPrivate(WlanQtUtils *publicPtr) : - q_ptr(publicPtr), - wlanScanList_(), - wlanIapList_(), - toBeTestedIapId_(WlanQtUtilsInvalidIapId), - connectingIapId_(WlanQtUtilsInvalidIapId), - activeConnection_(NULL) + The private interface functions are identical to those in WlanQtUtils + class, so refer to that for descriptions. Other functions contain + implementation documentation. +*/ + + +// External function prototypes + +// Local constants + +// ======== LOCAL FUNCTIONS ======== + +// ======== MEMBER FUNCTIONS ======== + +/*! + Constructor. +*/ + +WlanQtUtilsPrivate::WlanQtUtilsPrivate(WlanQtUtils *q_ptr) : + q_ptr(q_ptr), + mSettings(new WlanQtUtilsIapSettings(this)), + mConMonWrapper(new WlanQtUtilsConMonWrapper(this)), + mEsockWrapper(new WlanQtUtilsEsockWrapper(this)), + mConnTestWrapper(new ConnTestWrapper(this)), + mWlanScanList(), + mToBeTestedIapId(WlanQtUtils::IapIdNone), + mConnectingIapId(WlanQtUtils::IapIdNone), + mConnection() { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_ENTRY, this ); - - // Let's allocate memory for wrapper objects. - // Engine is set as a parent for wrapper objects. - cmmWrapper_ = new CmmWrapper(this); - conMonWrapper_ = new ConMonWrapper(this); - esockWrapper_ = new EsockWrapper(this); - connTestWrapper_ = new ConnTestWrapper(this); - + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_ENTRY, this); + // Make all connections. - // Todo: having these as signals from the wrappers doesn't bring much benefit - // -> could be optimized as normal callbacks - connect( - conMonWrapper_, - SIGNAL(availableWlanApsFromWrapper(QList&)), - this, - SLOT(updateAvailableWlanAps(QList&))); + bool connectStatus = connect( + mConMonWrapper, + SIGNAL(availableWlanApsFromWrapper( + QList< QSharedPointer >&)), + this, + SLOT(updateAvailableWlanAps( + QList< QSharedPointer >&))); + Q_ASSERT(connectStatus); - connect( - esockWrapper_, - SIGNAL(connectionStatusFromWrapper(bool)), + connectStatus = connect( + mEsockWrapper, + SIGNAL(connectionStatusFromWrapper(bool)), this, SLOT(updateConnectionStatus(bool))); + Q_ASSERT(connectStatus); - connect( - connTestWrapper_, - SIGNAL(connectivityTestResult(bool)), + connectStatus = connect( + mConnTestWrapper, + SIGNAL(connectivityTestResult(bool)), this, SLOT(updateConnectivityTestResult(bool))); + Q_ASSERT(connectStatus); - connect( - conMonWrapper_, - SIGNAL(connCreatedEventFromWrapper(uint)), + connectStatus = connect( + mConMonWrapper, + SIGNAL(connCreatedEventFromWrapper(uint)), this, SLOT(addActiveConnection(uint))); + Q_ASSERT(connectStatus); - connect( - conMonWrapper_, - SIGNAL(connDeletedEventFromWrapper(uint)), + connectStatus = connect( + mConMonWrapper, + SIGNAL(connDeletedEventFromWrapper(uint)), this, SLOT(removeActiveConnection(uint))); - - connect( - conMonWrapper_, - SIGNAL(connStatusEventFromWrapper(uint, WlanQtUtilsConnectionStatus)), - this, - SLOT(updateActiveConnection(uint, WlanQtUtilsConnectionStatus))); + Q_ASSERT(connectStatus); - // Fetch the initial IAP configuration - fetchIaps(); + connectStatus = connect( + mConMonWrapper, + SIGNAL(connStatusEventFromWrapper(uint, WlanQtUtils::ConnStatus)), + this, + SLOT(updateActiveConnection(uint, WlanQtUtils::ConnStatus))); + Q_ASSERT(connectStatus); - // Retrieve initial status of active connections and update IAPs, if needed. - activeConnection_ = conMonWrapper_->activeConnection(); - if (activeConnection_ != NULL) { - updateIapConnectionStatuses(activeConnection_->iapId(), activeConnection_->connectionStatus()); - } + // Retrieve initial status of active connections + mConnection = QSharedPointer( + mConMonWrapper->activeConnection()); - // TODO: error handling + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_EXIT, this); +} - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_EXIT, this ); -} +/*! + Destructor. +*/ WlanQtUtilsPrivate::~WlanQtUtilsPrivate() { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_ENTRY, this ); - - // Delete WLAN scan list - for (int i = 0; i < wlanScanList_.count(); i++) { - delete wlanScanList_[i]; - } - wlanScanList_.clear(); + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_ENTRY, this); + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_EXIT, this); +} + +/*! + See WlanQtUtils::scanWlans(). +*/ + +void WlanQtUtilsPrivate::scanWlans() +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANS_ENTRY, this); + + // Just forward the request to wrapper, which triggers a single WLAN scan + mConMonWrapper->scanAvailableWlanAPs(); + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANS_EXIT, this); +} + +/*! + See WlanQtUtils::scanWlanAps(). +*/ + +void WlanQtUtilsPrivate::scanWlanAps() +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANAPS_ENTRY, this); - delete activeConnection_; - - delete cmmWrapper_; - delete conMonWrapper_; - delete esockWrapper_; - delete connTestWrapper_; + emit q_ptr->wlanScanApReady(); + // TODO: implement me (wizard requires this) - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_EXIT, this ); + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANAPS_EXIT, this); } -void WlanQtUtilsPrivate::availableWlanAps( - QList &wlanIapList, - QList &wlanApList) +/*! + See WlanQtUtils::scanWlanDirect(). +*/ + +void WlanQtUtilsPrivate::scanWlanDirect(const QString &ssid) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_ENTRY, this ); + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANDIRECT_ENTRY, this); + + Q_UNUSED(ssid); + + emit q_ptr->wlanScanDirectReady(); + // TODO: implement me (wizard requires this) + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANDIRECT_EXIT, this); +} + +/*! + See WlanQtUtils::stopWlanScan(). +*/ + +void WlanQtUtilsPrivate::stopWlanScan() +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_STOPWLANSCAN_ENTRY, this); + + mConMonWrapper->stopScan(); + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_STOPWLANSCAN_EXIT, this); +} + +/*! + See WlanQtUtils::availableWlans(). +*/ + +void WlanQtUtilsPrivate::availableWlans( + QList< QSharedPointer > &wlanIapList, + QList< QSharedPointer > &wlanApList) const +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_AVAILABLEWLAN_ENTRY, this); + wlanIapList.clear(); wlanApList.clear(); - - // Add possible connected or connecting IAP as the first item in the list - int activeIapId = WlanQtUtilsInvalidIapId; - if (activeConnection_ != NULL) { - activeIapId = activeConnection_->iapId(); - } else if (connectingIapId_ != WlanQtUtilsInvalidIapId) { - activeIapId = connectingIapId_; - } - if (wlanIapList_.contains(activeIapId)) { - wlanIapList_[activeIapId]->setSignalStrength(WlanQtUtilsWlanSignalStrengthMax); - wlanIapList_[activeIapId]->setConnectionStatus(WlanQtUtilsConnectionStatusConnected); - wlanIapList.append(wlanIapList_[activeIapId]); - } - - // Todo: IAPs with same SSID and security mode? probably we want to show only one of them? - + + // Read the list of configured IAPs + QList > configuredIapList; + mSettings->fetchIaps(configuredIapList); + // Match IAPs against WLAN scan results - foreach (WlanQtUtilsWlanIap *iap, wlanIapList_) { - foreach (WlanQtUtilsWlanAp *scanAp, wlanScanList_) { - // Todo: security mode check - if (iap->ssid() == scanAp->ssid()) { - // IAP found, add it to caller's list of known IAPs (signal strength needs to be - // updated manually since the IAP in our list does not have that information yet) - iap->setSignalStrength(scanAp->signalStrength()); - if (iap->id() != activeIapId) { - wlanIapList.append(iap); - } // else: connected IAP, added as the first item in the list already + foreach (QSharedPointer iap, configuredIapList) { + foreach (QSharedPointer scanAp, mWlanScanList) { + if (WlanQtUtilsAp::compare(iap.data(), scanAp.data()) == true) { + // IAP found, add it to caller's list of known IAPs + // (signal strength needs to be updated manually since + // the IAP in our list does not have that information yet) + iap->setValue( + WlanQtUtilsAp::ConfIdSignalStrength, + scanAp->value(WlanQtUtilsAp::ConfIdSignalStrength)); + wlanIapList.append(iap); break; } } } // Go through the scan results to find unknown APs - for (int i = 0; i < wlanScanList_.count(); i++) { - // Skip networks with empty SSID (hidden networks are handled by UI currently) - if (wlanScanList_[i]->ssid().isEmpty() == FALSE) { - // Check whether an IAP with these parameters exists in any SNAP (in which case this - // network should not be shown as available in this SNAP) - if (wlanIapExists(wlanScanList_[i]->ssid(), wlanScanList_[i]->securityMode()) == false) { - // No IAP found in any SNAP, copy the AP to caller's list of unknown APs - wlanApList.append(wlanScanList_[i]); - } + for (int i = 0; i < mWlanScanList.count(); i++) { + // Check whether an IAP with these parameters exists (in which + // case this network is already added as an IAP in the loop above) + if (!wlanIapExists(configuredIapList, mWlanScanList[i].data())) { + // No IAP found in, copy the AP to caller's list of + // unknown APs + wlanApList.append(mWlanScanList[i]); } } + + traceIapsAndAps(wlanIapList, wlanApList); + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_AVAILABLEWLAN_EXIT, this); +} + +/*! + See WlanQtUtils::availableWlanAps(). +*/ + +void WlanQtUtilsPrivate::availableWlanAps( + QList< QSharedPointer > &wlanApList) const +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_ENTRY, this); - // Sort APs by their SSIDs. - QMap wlanApMap; - // Loop the AP list copying the keys (lower case SSID) and elements - // into the map. - for (int i = 0; i < wlanApList.count(); i++ ) { - wlanApMap.insertMulti(wlanApList[i]->ssid().toLower(), wlanApList[i]); - } - wlanApList = wlanApMap.values(); + Q_UNUSED(wlanApList); + // TODO: implement me (wizard requires this) + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_EXIT, this); +} + +/*! + See WlanQtUtils::createIap(). +*/ - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_EXIT, this ); +int WlanQtUtilsPrivate::createIap(const WlanQtUtilsAp *wlanAp) +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_CREATEIAP_ENTRY, this); + + // Create the new IAP and return its ID + int newIapId = mSettings->createIap(wlanAp); + + OstTrace1( + TRACE_BORDER, + WLANQTUTILSPRIVATE_CREATEIAP, + "WlanQtUtilsPrivate::createIap;New IAP ID=%d", + newIapId); + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_CREATEIAP_EXIT, this); + return newIapId; } -int WlanQtUtilsPrivate::createWlanIap(const WlanQtUtilsWlanAp *wlanAp) +/*! + See WlanQtUtils::updateIap(). +*/ + +bool WlanQtUtilsPrivate::updateIap(int iapId, const WlanQtUtilsAp *wlanAp) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CREATEWLANIAP_ENTRY, this ); + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEIAP_ENTRY, this); + + bool success = mSettings->updateIap(iapId, wlanAp); - // Create the new IAP. Store its ID, because we need to run ICT for it later - WlanQtUtilsWlanIap *newIap = cmmWrapper_->createWlanIap(wlanAp); - toBeTestedIapId_ = newIap->id(); - wlanIapList_.insert(newIap->id(), newIap); - - OstTrace1( - TRACE_API, - WLANQTUTILSPRIVATE_CREATEWLANIAP, - "WlanQtUtilsPrivate::createWlanIap;New IAP ID=%d", toBeTestedIapId_ ); - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CREATEWLANIAP_EXIT, this ); - return toBeTestedIapId_; + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEIAP_EXIT, this); + return success; +} + +/*! + See WlanQtUtils::deleteIap(). +*/ + +void WlanQtUtilsPrivate::deleteIap(int iapId) +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_DELETEIAP_ENTRY, this); + + mSettings->deleteIap(iapId); + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_DELETEIAP_EXIT, this); } -void WlanQtUtilsPrivate::connectIap(int iapId) +/*! + See WlanQtUtils::connectIap(). +*/ + +void WlanQtUtilsPrivate::connectIap(int iapId, bool runIct) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CONNECTIAP_ENTRY, this ); - OstTrace1( TRACE_API, WLANQTUTILSPRIVATE_CONNECTIAP, "WlanQtUtilsPrivate::connectIap;IAP ID=%d", iapId ); + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_CONNECTIAP_ENTRY, this); - Q_ASSERT(activeConnection_ == NULL); - connectingIapId_ = iapId; - esockWrapper_->connectIap(iapId); + OstTraceExt2( + TRACE_BORDER, + WLANQTUTILSPRIVATE_CONNECTIAP, + "WlanQtUtilsPrivate::connectIap;IAP ID=%d;runIct=%hhu", + iapId, + runIct); + + Q_ASSERT(iapId != WlanQtUtils::IapIdNone); - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CONNECTIAP_EXIT, this ); + if (runIct) { + // Mark this IAP for ICT testing after it has been opened + mToBeTestedIapId = iapId; + } + mConnectingIapId = iapId; + mEsockWrapper->connectIap(iapId); + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_CONNECTIAP_EXIT, this); } +/*! + See WlanQtUtils::disconnectIap(). +*/ + void WlanQtUtilsPrivate::disconnectIap(int iapId) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_DISCONNECTIAP_ENTRY, this ); - OstTrace1( TRACE_API, WLANQTUTILSPRIVATE_DISCONNECTIAP, "WlanQtUtilsPrivate::disconnectIap;IAP ID=%d", iapId ); - - Q_ASSERT(activeConnection_ != NULL); - Q_ASSERT(activeConnection_->iapId() == iapId); - Q_ASSERT(wlanIapList_.contains(iapId)); + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_DISCONNECTIAP_ENTRY, this); - // Todo: IAP may have been opened by someone else... how to know when to disconnect RConnection? - esockWrapper_->disconnectIap(); - - // In order to close connection even if there are other users for the IAP, close also via ConMon - conMonWrapper_->disconnectIap(iapId); - // Change status of the IAP to non-connected - wlanIapList_[iapId]->setConnectionStatus(WlanQtUtilsConnectionStatusDisconnected); + OstTrace1( + TRACE_BORDER, + WLANQTUTILSPRIVATE_DISCONNECTIAP, + "WlanQtUtilsPrivate::disconnectIap;IAP ID=%d", iapId ); - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_DISCONNECTIAP_EXIT, this ); + if (iapId != WlanQtUtils::IapIdNone) { + // Close our RConnection handle, if needed. Wrapper ignores call, if + // no handle exists. + mEsockWrapper->disconnectIap(); + + // In order to close connection even if there are other users for the + // IAP, close also via ConMon + mConMonWrapper->disconnectIap(iapId); + } // else: just ignore call + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_DISCONNECTIAP_EXIT, this); } -WlanQtUtilsIap *WlanQtUtilsPrivate::iap(int iapId) const +/*! + See WlanQtUtils::connectionStatus(). +*/ + +WlanQtUtils::ConnStatus WlanQtUtilsPrivate::connectionStatus() const { - if (wlanIapList_.contains(iapId)) { - return wlanIapList_.value(iapId); + OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_CONNECTIONSTATUS_ENTRY); + + WlanQtUtils::ConnStatus status = WlanQtUtils::ConnStatusDisconnected; + + if (mConnection) { + status = mConnection->connectionStatus(); } - // else: no match - return NULL; + OstTrace1( + TRACE_BORDER, + WLANQTUTILSPRIVATE_CONNECTIONSTATUS, + "WlanQtUtilsPrivate::connectionStatus;status=%{ConnStatus};", + (TUint)status); + + OstTraceFunctionExit0(WLANQTUTILSPRIVATE_CONNECTIONSTATUS_EXIT); + return status; } -bool WlanQtUtilsPrivate::masterWlan() const +/*! + See WlanQtUtils::activeIap(). +*/ + +int WlanQtUtilsPrivate::activeIap() const { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_MASTERWLAN_ENTRY, this ); + OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_ACTIVEIAP_ENTRY); + + int iapId = WlanQtUtils::IapIdNone; + + if (mConnection) { + iapId = mConnection->iapId(); + } + OstTrace1( + TRACE_BORDER, + WLANQTUTILSPRIVATE_ACTIVEIAP, + "WlanQtUtilsPrivate::activeIap;iapId=%d", + iapId); - // TODO: Add actual implementation, this is just temporary dummy for testing wlanentryplugin! + OstTraceFunctionExit0(WLANQTUTILSPRIVATE_ACTIVEIAP_EXIT); + return iapId; +} + +/*! + See WlanQtUtils::iapName(). +*/ - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_MASTERWLAN_EXIT, this ); - return true; +QString WlanQtUtilsPrivate::iapName(int iapId) const +{ + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_IAPNAME_ENTRY, this); + + QString name; + // Read the IAP from settings and return its name + QSharedPointer iap = mSettings->fetchIap(iapId); + if (iap) { + name = iap->value(WlanQtUtilsIap::ConfIdName).toString(); + } + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_IAPNAME_EXIT, this); + return name; } -void WlanQtUtilsPrivate::setMasterWlan(bool enabled) -{ - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_SETMASTERWLAN_ENTRY, this ); +/*! + This function searches for a WLAN IAP matching the given WLAN AP. + + @param [in] list List to search from. + @param [in] ap Access point to search for. - // TODO: Add actual implementation. - (void)enabled; - - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_SETMASTERWLAN_EXIT, this ); -} + @return True, if suitable WLAN IAP found, false otherwise. +*/ -int WlanQtUtilsPrivate::connectedWlanId() const +bool WlanQtUtilsPrivate::wlanIapExists( + const QList< QSharedPointer > list, + const WlanQtUtilsAp *ap) const { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CONNECTEDWLANID_ENTRY, this ); - - int retVal = WlanQtUtilsInvalidIapId; - if (activeConnection_ != NULL) { - retVal = activeConnection_->iapId(); + bool match = false; // Return value + + foreach (QSharedPointer iap, list) { + if (WlanQtUtilsAp::compare(iap.data(), ap) == true) { + // Match found + match = true; + break; + } } - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CONNECTEDWLANID_EXIT, this ); - return retVal; + + return match; } -void WlanQtUtilsPrivate::scanWlans() -{ - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_SCANWLANS_ENTRY, this ); +/*! + This function traces the given IAPs and APs. + + @param [in] iaps IAPs to trace. + @param [in] aps APs to trace. +*/ - // Just forward the request to wrapper, which triggers a single WLAN scan - conMonWrapper_->scanAvailableWlanAPs(); - - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_SCANWLANS_EXIT, this ); +void WlanQtUtilsPrivate::traceIapsAndAps( + const QList > &iaps, + const QList > &aps) const +{ +#ifndef OST_TRACE_COMPILER_IN_USE + Q_UNUSED(iaps); + Q_UNUSED(aps); +#else + foreach (QSharedPointer iap, iaps) { + QString tmp(iap->value(WlanQtUtilsIap::ConfIdName).toString()); + TPtrC16 name(tmp.utf16(), tmp.length()); + OstTraceExt3( + TRACE_NORMAL, + WLANQTUTILSPRIVATE_TRACEAVAILABLEWLANAPS_IAP, + "WlanQtUtilsPrivate::traceAvailableWlanAps IAP;name=%S;iap->securityMode()=%d;iap->signalStrength()=%d", + name, + iap->value(WlanQtUtilsAp::ConfIdSecurityMode).toInt(), + iap->value(WlanQtUtilsAp::ConfIdSignalStrength).toInt()); + } + foreach (QSharedPointer ap, aps) { + QString tmp(ap->value(WlanQtUtilsAp::ConfIdSsid).toString()); + TPtrC16 ssid(tmp.utf16(), tmp.length()); + OstTraceExt3( + TRACE_NORMAL, + WLANQTUTILSPRIVATE_TRACEAVAILABLEWLANAPS_AP, + "WlanQtUtilsPrivate::traceAvailableWlanAps AP;ssid=%S;ap->securityMode()=%d;ap->signalStrength()=%d", + ssid, + ap->value(WlanQtUtilsAp::ConfIdSecurityMode).toInt(), + ap->value(WlanQtUtilsAp::ConfIdSignalStrength).toInt() ); + } +#endif } -void WlanQtUtilsPrivate::updateAvailableWlanAps(QList &availableWlanList) +/*! + Slot for handling WLAN scan result event from wrapper. Results are + stored in member variable (possible duplicates are removed). + + @param [in] availableWlanList WLAN networks found in scan. +*/ + +void WlanQtUtilsPrivate::updateAvailableWlanAps( + QList > &availableWlanList) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_ENTRY, this ); - + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_ENTRY, this); + // Old results are removed - wlanScanList_.clear(); - // Copy available WLAN's to engine's scan result list (duplicates are removed) + mWlanScanList.clear(); + // Copy available WLANs to scan result list (duplicates are removed) for (int i = 0; i < availableWlanList.count(); i++) { bool duplicate = false; - for (int j = 0; j < wlanScanList_.count(); j++) { - if (availableWlanList[i]->ssid() == wlanScanList_[j]->ssid() - && availableWlanList[i]->securityMode() == wlanScanList_[j]->securityMode()) { + for (int j = 0; j < mWlanScanList.count(); j++) { + if (WlanQtUtilsAp::compare( + availableWlanList[i].data(), + mWlanScanList[j].data()) == true) { duplicate = true; break; } } if (duplicate == false) { - wlanScanList_.append(availableWlanList[i]); + mWlanScanList.append(availableWlanList[i]); } - // Todo: else deallocate? } - // the information is forwarded to the UI + // The information is forwarded to the UI + OstTrace0( + TRACE_BORDER, + WLANQTUTILSPRIVATE_WLANSCANREADY, + "WlanQtUtilsPrivate::emit wlanScanReady"); emit q_ptr->wlanScanReady(); + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_EXIT, this); +} - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_EXIT, this ); -} +/*! + Slot for handling connection setup status event from wrapper. + + @param [in] isOpened Was connection setup successful? +*/ void WlanQtUtilsPrivate::updateConnectionStatus(bool isOpened) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_ENTRY, this ); - OstTrace1( - TRACE_API, - WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS, - "WlanQtUtilsPrivate::updateConnectionStatus;isOpened=%d", isOpened ); - + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_ENTRY, this); + if (isOpened == false) { - // Opening failed, update connection statuses, but don't inform UI about - // connection closing here. It is done always in removeActiveConnection(). - if (activeConnection_ != NULL) { - activeConnection_->setConnectionStatus(WlanQtUtilsConnectionStatusDisconnected); + // Opening failed, update connection status and inform UI + if (mConnection) { + mConnection->setConnectionStatus( + WlanQtUtils::ConnStatusDisconnected); } - updateIapConnectionStatuses(connectingIapId_, WlanQtUtilsConnectionStatusDisconnected); + + // Include the status code from connection wrapper + int status = mEsockWrapper->lastStatusCode(); + OstTraceExt2( + TRACE_BORDER, + WLANQTUTILSPRIVATE_WLANNETWORKCLOSED, + "WlanQtUtilsPrivate::emit wlanNetworkClosed;IAP ID=%d;status=%d", + mConnectingIapId, + status); + emit q_ptr->wlanNetworkClosed(mConnectingIapId, status); } else { - // Opening succeeded, update connection statuses and inform UI - if (activeConnection_ != NULL) { - activeConnection_->setConnectionStatus(WlanQtUtilsConnectionStatusConnected); + // Opening succeeded, update connection status and inform UI + if (mConnection) { + mConnection->setConnectionStatus( + WlanQtUtils::ConnStatusConnected); } - updateIapConnectionStatuses(connectingIapId_, WlanQtUtilsConnectionStatusConnected); - emit q_ptr->wlanNetworkOpened(connectingIapId_); + + OstTrace1( + TRACE_BORDER, + WLANQTUTILSPRIVATE_WLANNETWORKOPENED, + "WlanQtUtilsPrivate::emit wlanNetworkOpened;IAP ID=%d", + mConnectingIapId); + emit q_ptr->wlanNetworkOpened(mConnectingIapId); // Start ICT, if needed - if (connectingIapId_ == toBeTestedIapId_) { - WlanQtUtilsIap *iap = WlanQtUtilsPrivate::iap(toBeTestedIapId_); - connTestWrapper_->startConnectivityTest(toBeTestedIapId_, iap->networkId()); + if (mConnectingIapId == mToBeTestedIapId) { + QSharedPointer iap = + mSettings->fetchIap(mToBeTestedIapId); + mConnTestWrapper->startConnectivityTest( + mToBeTestedIapId, + iap->value(WlanQtUtilsIap::ConfIdNetworkId).toInt()); } } // IAP is no more in connecting state - connectingIapId_ = WlanQtUtilsInvalidIapId; + mConnectingIapId = WlanQtUtils::IapIdNone; + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_EXIT, this); +} - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_EXIT, this ); -} +/*! + Slot for handling connectivity test result event from wrapper. Tested + IAP is stored to Internet SNAP, if test was successful. + + @param [in] result Was the test successful? +*/ void WlanQtUtilsPrivate::updateConnectivityTestResult(bool result) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_ENTRY, this ); - OstTrace1( - TRACE_API, - WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT, - "WlanQtUtilsPrivate::updateConnectivityTestResult;result=%d", result ); - + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_ENTRY, this); + if (result == true) { // Move the tested IAP to Internet SNAP since the test passed - Q_ASSERT(toBeTestedIapId_ != WlanQtUtilsInvalidIapId); - cmmWrapper_->moveIapToInternetSnap(toBeTestedIapId_); + Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone); + mSettings->moveIapToInternetSnap(mToBeTestedIapId); } // else: do nothing, IAP remains to be uncategorized - else - { - // TODO: Remove this. This is needed now since the connectivity test fails - // and thus the IAP is not shown correctly. - cmmWrapper_->moveIapToInternetSnap(toBeTestedIapId_); + + // Inform UI + OstTraceExt2( + TRACE_NORMAL, + WLANQTUTILSPRIVATE_ICTRESULT, + "WlanQtUtilsPrivate::emit ictResult;result=%hhu;IAP ID=%d", + result, + mToBeTestedIapId); + + emit q_ptr->ictResult(mToBeTestedIapId, result); - } // This IAP is now tested - toBeTestedIapId_ = WlanQtUtilsInvalidIapId; + mToBeTestedIapId = WlanQtUtils::IapIdNone; + + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_EXIT, this); +} - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_EXIT, this ); -} +/*! + Slot for updating active connection status from wrapper. + + @param [in] connectionId ID of the new connection. +*/ void WlanQtUtilsPrivate::addActiveConnection(uint connectionId) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_ENTRY, this ); + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_ENTRY, this); OstTrace1( - TRACE_API, + TRACE_BORDER, WLANQTUTILSPRIVATE_ADDACTIVECONNECTION, - "WlanQtUtilsPrivate::addActiveConnection;connectionId=%u", connectionId ); + "WlanQtUtilsPrivate::addActiveConnection;connectionId=%u", + connectionId); - Q_ASSERT(activeConnection_ == NULL); - activeConnection_ = conMonWrapper_->connectionInfo(connectionId); - Q_ASSERT(wlanIapList_.contains(activeConnection_->iapId())); - updateIapConnectionStatuses(activeConnection_->iapId(), activeConnection_->connectionStatus()); + Q_ASSERT(mConnection == NULL); + mConnection = QSharedPointer( + mConMonWrapper->connectionInfo(connectionId)); - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_EXIT, this ); + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_EXIT, this); } +/*! + Slot for updating active connection status from wrapper. + + @param [in] connectionId ID of the deleted connection. +*/ + void WlanQtUtilsPrivate::removeActiveConnection(uint connectionId) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_ENTRY, this ); + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_ENTRY, this); OstTrace1( - TRACE_API, + TRACE_BORDER, WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION, - "WlanQtUtilsPrivate::removeActiveConnection;connectionId=%u", connectionId ); - - Q_ASSERT(activeConnection_ != NULL); - if (activeConnection_->connectionId() == connectionId) { - // Connection is closed, update connection statuses and inform UI. - // wlanNetworkClosed is sent from here (and only from here), because, in some cases, - // connection may be removed without any connection status updates. - int closedIapId = activeConnection_->iapId(); - updateIapConnectionStatuses(activeConnection_->iapId(), WlanQtUtilsConnectionStatusDisconnected); - delete activeConnection_; - activeConnection_ = NULL; - emit q_ptr->wlanNetworkClosed(closedIapId); + "WlanQtUtilsPrivate::removeActiveConnection;connectionId=%u", + connectionId); + + Q_ASSERT(mConnection); + if (mConnection->connectionId() == connectionId) { + int closedIapId = mConnection->iapId(); + mConnection.clear(); + + if (mConnectingIapId != closedIapId) { + // Connection is closed, inform UI. wlanNetworkClosed is sent + // from here instead of updateActiveConnection(closed), + // because, in some cases, connection may be removed without + // any connection status updates. + // Note: reason parameter is not accurate here, because it is + // only relevant for connections opened by this dll + // (updateConnectionStatus) + OstTraceExt2( + TRACE_BORDER, + DUP1_WLANQTUTILSPRIVATE_WLANNETWORKCLOSED, + "WlanQtUtilsPrivate::emit wlanNetworkClosed;IAP ID=%d;status=%d", + closedIapId, + KErrNone); + emit q_ptr->wlanNetworkClosed(closedIapId, KErrNone); + } + // else: connection creation started by thid dll, but creation failed + // -> wlanNetworkClosed is sent from updateConnectionStatus } - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_EXIT, this ); -} - -void WlanQtUtilsPrivate::updateActiveConnection(uint connectionId, WlanQtUtilsConnectionStatus connectionStatus) -{ - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_ENTRY, this ); - OstTraceExt2( - TRACE_API, - WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION, - "WlanQtUtilsPrivate::updateActiveConnection;connectionId=%u;connectionStatus=%u", connectionId, connectionStatus ); - - Q_ASSERT(activeConnection_ != NULL); - if (activeConnection_->connectionId() == connectionId - && activeConnection_->connectionStatus() != connectionStatus) { - // Update connection statuses and inform UI, if necessary - activeConnection_->setConnectionStatus(connectionStatus); - updateIapConnectionStatuses(activeConnection_->iapId(), connectionStatus); - if (connectionStatus == WlanQtUtilsConnectionStatusConnected) { - emit q_ptr->wlanNetworkOpened(activeConnection_->iapId()); - } - // Do not inform UI about connection closing here. It is done always in - // removeActiveConnection(), because that may occur without any connection status updates. - } // else: connection status did not change - - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_EXIT, this ); + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_EXIT, this); } -int WlanQtUtilsPrivate::fetchIaps() +/*! + Slot for updating active connection status from wrapper. + + @param [in] connectionId ID of the updated connection. + @param [in] connectionStatus New status of the connection. +*/ + +void WlanQtUtilsPrivate::updateActiveConnection( + uint connectionId, + WlanQtUtils::ConnStatus connectionStatus) { - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_FETCHIAPS_ENTRY, this ); - - QList list; - int error = 0; - // Read the IAP list and store WLAN IAPs in our internal map data structure - error = cmmWrapper_->fetchIaps(list); - foreach (WlanQtUtilsIap *iap, list) { - if (iap->bearerType() == WlanQtUtilsBearerTypeWlan) { - // Notice that insertMulti not used, because IAP IDs should be unique - wlanIapList_.insert(iap->id(), qobject_cast(iap)); - } - } - - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_FETCHIAPS_EXIT, this ); - return error; -} + OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_ENTRY, this); + OstTraceExt2( + TRACE_BORDER, + WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION, + "WlanQtUtilsPrivate::updateActiveConnection;connectionId=%u;connectionStatus=%u", + connectionId, + (uint)connectionStatus); -bool WlanQtUtilsPrivate::wlanIapExists(QString ssid, WlanQtUtilsWlanSecMode secMode) -{ - foreach (WlanQtUtilsWlanIap *iap, wlanIapList_) { - // todo: secmode - (void)secMode; - if (iap->ssid() == ssid) { - return true; + Q_ASSERT(mConnection); + if (mConnection->connectionId() == connectionId + && mConnection->connectionStatus() != connectionStatus) { + // Update connection status and inform UI, if necessary + mConnection->setConnectionStatus(connectionStatus); + if (connectionStatus == WlanQtUtils::ConnStatusConnected) { + OstTrace1( + TRACE_BORDER, + DUP1_WLANQTUTILSPRIVATE_WLANNETWORKOPENED, + "WlanQtUtilsPrivate::emit wlanNetworkOpened;IAP ID=%d", + mConnection->iapId()); + emit q_ptr->wlanNetworkOpened(mConnection->iapId()); } - } - - return false; -} + // Do not inform UI about connection closing here. It is done in + // removeActiveConnection(), because that may occur without any + // connection status updates. + } // else: connection status did not change -void WlanQtUtilsPrivate::updateIapConnectionStatuses(int iapId, WlanQtUtilsConnectionStatus status) -{ - OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATEIAPCONNECTIONSTATUSES_ENTRY, this ); - - const WlanQtUtilsWlanIap *referenceIap = qobject_cast(iap(iapId)); - foreach (WlanQtUtilsWlanIap *iap, wlanIapList_) { - // todo: security mode checking - if (iap->id() == referenceIap->id() || iap->ssid() == referenceIap->ssid()) { - iap->setConnectionStatus(status); - } - } - - OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATEIAPCONNECTIONSTATUSES_EXIT, this ); + OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_EXIT, this); }