--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wlanutilities/wlanqtutilities/base/src/wlanqtutils_p.cpp Fri Apr 16 16:07:56 2010 +0300
@@ -0,0 +1,490 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*/
+
+#include "wlanqtutilswlanap.h"
+#include "wlanqtutilswlaniap.h"
+#include "wlanqtutilsactiveconn.h"
+#include "wlanqtutilscmmwrapper.h"
+#include "wlanqtutilsconmonwrapper.h"
+#include "wlanqtutilsesockwrapper.h"
+#include "wlanqtutilsconntestwrapper.h"
+
+#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
+
+
+WlanQtUtilsPrivate::WlanQtUtilsPrivate(WlanQtUtils *publicPtr) :
+ q_ptr(publicPtr),
+ wlanScanList_(),
+ wlanIapList_(),
+ toBeTestedIapId_(WlanQtUtilsInvalidIapId),
+ connectingIapId_(WlanQtUtilsInvalidIapId),
+ activeConnection_(NULL)
+{
+ 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);
+
+ // 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 *>&)));
+
+ connect(
+ esockWrapper_,
+ SIGNAL(connectionStatusFromWrapper(bool)),
+ this,
+ SLOT(updateConnectionStatus(bool)));
+
+ connect(
+ connTestWrapper_,
+ SIGNAL(connectivityTestResult(bool)),
+ this,
+ SLOT(updateConnectivityTestResult(bool)));
+
+ connect(
+ conMonWrapper_,
+ SIGNAL(connCreatedEventFromWrapper(uint)),
+ this,
+ SLOT(addActiveConnection(uint)));
+
+ connect(
+ conMonWrapper_,
+ SIGNAL(connDeletedEventFromWrapper(uint)),
+ this,
+ SLOT(removeActiveConnection(uint)));
+
+ connect(
+ conMonWrapper_,
+ SIGNAL(connStatusEventFromWrapper(uint, WlanQtUtilsConnectionStatus)),
+ this,
+ SLOT(updateActiveConnection(uint, WlanQtUtilsConnectionStatus)));
+
+ // Fetch the initial IAP configuration
+ fetchIaps();
+
+ // Retrieve initial status of active connections and update IAPs, if needed.
+ activeConnection_ = conMonWrapper_->activeConnection();
+ if (activeConnection_ != NULL) {
+ updateIapConnectionStatuses(activeConnection_->iapId(), activeConnection_->connectionStatus());
+ }
+
+ // TODO: error handling
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_EXIT, this );
+}
+
+WlanQtUtilsPrivate::~WlanQtUtilsPrivate()
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_ENTRY, this );
+
+ // Delete WLAN scan list
+ for (int i = 0; i < wlanScanList_.count(); i++) {
+ delete wlanScanList_[i];
+ }
+ wlanScanList_.clear();
+
+ delete activeConnection_;
+
+ delete cmmWrapper_;
+ delete conMonWrapper_;
+ delete esockWrapper_;
+ delete connTestWrapper_;
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_EXIT, this );
+}
+
+void WlanQtUtilsPrivate::availableWlanAps(
+ QList<WlanQtUtilsWlanIap *> &wlanIapList,
+ QList<WlanQtUtilsWlanAp *> &wlanApList)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_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?
+
+ // 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
+ 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]);
+ }
+ }
+ }
+
+ // 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();
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_EXIT, this );
+}
+
+int WlanQtUtilsPrivate::createWlanIap(const WlanQtUtilsWlanAp *wlanAp)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CREATEWLANIAP_ENTRY, this );
+
+ // 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_;
+}
+
+void WlanQtUtilsPrivate::connectIap(int iapId)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CONNECTIAP_ENTRY, this );
+ OstTrace1( TRACE_API, WLANQTUTILSPRIVATE_CONNECTIAP, "WlanQtUtilsPrivate::connectIap;IAP ID=%d", iapId );
+
+ Q_ASSERT(activeConnection_ == NULL);
+ connectingIapId_ = iapId;
+ esockWrapper_->connectIap(iapId);
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CONNECTIAP_EXIT, this );
+}
+
+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));
+
+ // 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);
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_DISCONNECTIAP_EXIT, this );
+}
+
+WlanQtUtilsIap *WlanQtUtilsPrivate::iap(int iapId) const
+{
+ if (wlanIapList_.contains(iapId)) {
+ return wlanIapList_.value(iapId);
+ }
+ // else: no match
+ return NULL;
+}
+
+bool WlanQtUtilsPrivate::masterWlan() const
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_MASTERWLAN_ENTRY, this );
+
+ // TODO: Add actual implementation, this is just temporary dummy for testing wlanentryplugin!
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_MASTERWLAN_EXIT, this );
+ return true;
+}
+
+void WlanQtUtilsPrivate::setMasterWlan(bool enabled)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_SETMASTERWLAN_ENTRY, this );
+
+ // TODO: Add actual implementation.
+ (void)enabled;
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_SETMASTERWLAN_EXIT, this );
+}
+
+int WlanQtUtilsPrivate::connectedWlanId() const
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CONNECTEDWLANID_ENTRY, this );
+
+ int retVal = WlanQtUtilsInvalidIapId;
+ if (activeConnection_ != NULL) {
+ retVal = activeConnection_->iapId();
+ }
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CONNECTEDWLANID_EXIT, this );
+ return retVal;
+}
+
+void WlanQtUtilsPrivate::scanWlans()
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_SCANWLANS_ENTRY, this );
+
+ // Just forward the request to wrapper, which triggers a single WLAN scan
+ conMonWrapper_->scanAvailableWlanAPs();
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_SCANWLANS_EXIT, this );
+}
+
+void WlanQtUtilsPrivate::updateAvailableWlanAps(QList<WlanQtUtilsWlanAp *> &availableWlanList)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_ENTRY, this );
+
+ // Old results are removed
+ wlanScanList_.clear();
+ // Copy available WLAN's to engine's 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()) {
+ duplicate = true;
+ break;
+ }
+ }
+ if (duplicate == false) {
+ wlanScanList_.append(availableWlanList[i]);
+ }
+ // Todo: else deallocate?
+ }
+
+ // the information is forwarded to the UI
+ emit q_ptr->wlanScanReady();
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_EXIT, this );
+}
+
+void WlanQtUtilsPrivate::updateConnectionStatus(bool isOpened)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_ENTRY, this );
+ OstTrace1(
+ TRACE_API,
+ WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS,
+ "WlanQtUtilsPrivate::updateConnectionStatus;isOpened=%d", isOpened );
+
+ 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);
+ }
+ updateIapConnectionStatuses(connectingIapId_, WlanQtUtilsConnectionStatusDisconnected);
+ } else {
+ // Opening succeeded, update connection statuses and inform UI
+ if (activeConnection_ != NULL) {
+ activeConnection_->setConnectionStatus(WlanQtUtilsConnectionStatusConnected);
+ }
+ updateIapConnectionStatuses(connectingIapId_, WlanQtUtilsConnectionStatusConnected);
+ emit q_ptr->wlanNetworkOpened(connectingIapId_);
+
+ // Start ICT, if needed
+ if (connectingIapId_ == toBeTestedIapId_) {
+ WlanQtUtilsIap *iap = WlanQtUtilsPrivate::iap(toBeTestedIapId_);
+ connTestWrapper_->startConnectivityTest(toBeTestedIapId_, iap->networkId());
+ }
+ }
+ // IAP is no more in connecting state
+ connectingIapId_ = WlanQtUtilsInvalidIapId;
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_EXIT, this );
+}
+
+void WlanQtUtilsPrivate::updateConnectivityTestResult(bool result)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_ENTRY, this );
+ OstTrace1(
+ TRACE_API,
+ WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT,
+ "WlanQtUtilsPrivate::updateConnectivityTestResult;result=%d", result );
+
+ if (result == true) {
+ // Move the tested IAP to Internet SNAP since the test passed
+ Q_ASSERT(toBeTestedIapId_ != WlanQtUtilsInvalidIapId);
+ cmmWrapper_->moveIapToInternetSnap(toBeTestedIapId_);
+ } // 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_);
+
+ }
+ // This IAP is now tested
+ toBeTestedIapId_ = WlanQtUtilsInvalidIapId;
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_EXIT, this );
+}
+
+void WlanQtUtilsPrivate::addActiveConnection(uint connectionId)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_ENTRY, this );
+ OstTrace1(
+ TRACE_API,
+ WLANQTUTILSPRIVATE_ADDACTIVECONNECTION,
+ "WlanQtUtilsPrivate::addActiveConnection;connectionId=%u", connectionId );
+
+ Q_ASSERT(activeConnection_ == NULL);
+ activeConnection_ = conMonWrapper_->connectionInfo(connectionId);
+ Q_ASSERT(wlanIapList_.contains(activeConnection_->iapId()));
+ updateIapConnectionStatuses(activeConnection_->iapId(), activeConnection_->connectionStatus());
+
+ OstTraceFunctionExit1( WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_EXIT, this );
+}
+
+void WlanQtUtilsPrivate::removeActiveConnection(uint connectionId)
+{
+ OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_ENTRY, this );
+ OstTrace1(
+ TRACE_API,
+ 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);
+ }
+
+ 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 );
+}
+
+int WlanQtUtilsPrivate::fetchIaps()
+{
+ 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;
+}
+
+bool WlanQtUtilsPrivate::wlanIapExists(QString ssid, WlanQtUtilsWlanSecMode secMode)
+{
+ foreach (WlanQtUtilsWlanIap *iap, wlanIapList_) {
+ // todo: secmode
+ (void)secMode;
+ if (iap->ssid() == ssid) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+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 );
+}