--- 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 <QSharedPointer>
+
+// 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 <opensystemtrace.h>
-#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<WlanQtUtilsWlanAp *>&)),
- this,
- SLOT(updateAvailableWlanAps(QList<WlanQtUtilsWlanAp *>&)));
+ bool connectStatus = connect(
+ mConMonWrapper,
+ SIGNAL(availableWlanApsFromWrapper(
+ QList< QSharedPointer<WlanQtUtilsAp> >&)),
+ this,
+ SLOT(updateAvailableWlanAps(
+ QList< QSharedPointer<WlanQtUtilsAp> >&)));
+ 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<WlanQtUtilsConnection>(
+ 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<WlanQtUtilsWlanIap *> &wlanIapList,
- QList<WlanQtUtilsWlanAp *> &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<WlanQtUtilsIap> > &wlanIapList,
+ QList< QSharedPointer<WlanQtUtilsAp> > &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<QSharedPointer<WlanQtUtilsIap> > 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<WlanQtUtilsIap> iap, configuredIapList) {
+ foreach (QSharedPointer<WlanQtUtilsAp> 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<WlanQtUtilsAp> > &wlanApList) const
+{
+ OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_ENTRY, this);
- // Sort APs by their SSIDs.
- QMap<QString, WlanQtUtilsWlanAp *> 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<WlanQtUtilsIap> 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<WlanQtUtilsIap> > 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<WlanQtUtilsIap> 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<QSharedPointer<WlanQtUtilsIap> > &iaps,
+ const QList<QSharedPointer<WlanQtUtilsAp> > &aps) const
+{
+#ifndef OST_TRACE_COMPILER_IN_USE
+ Q_UNUSED(iaps);
+ Q_UNUSED(aps);
+#else
+ foreach (QSharedPointer<WlanQtUtilsIap> 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<WlanQtUtilsAp> 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<WlanQtUtilsWlanAp *> &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<QSharedPointer<WlanQtUtilsAp> > &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<WlanQtUtilsIap> 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<WlanQtUtilsConnection>(
+ 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<WlanQtUtilsIap *> 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<WlanQtUtilsWlanIap *>(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<WlanQtUtilsWlanIap *>(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);
}