diff -r ff3b37722600 -r 10810c91db26 wlanutilities/wlanqtutilities/base/src/wlanqtutils_p.cpp --- /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 +#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&)), + this, + SLOT(updateAvailableWlanAps(QList&))); + + 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 &wlanIapList, + QList &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 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 &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 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; +} + +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(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 ); +}