[Wifi] Add new enums and make some API changes

- Now QtWifi can provide feedback when incorrect password is
  entered.

- networkStateChanged signal provides a reference to the
  currently active network connection.

- bug fixes in QWifiManager::connect

Task-number: QTEE-408

Change-Id: Ic7458b864f09aef3cfca40fb081dec45e0bba7db
Reviewed-by: Eirik Aavitsland <eirik.aavitsland@digia.com>

6 files changed, 152 insertions, 85 deletions

diff --git a/src/imports/wifi/qwifimanager.cpp b/src/imports/wifi/qwifimanager.cpp
index bc4b6fe..af6f5d3 100644
--- a/src/imports/wifi/qwifimanager.cpp
+++ b/src/imports/wifi/qwifimanager.cpp
@@ -32,6 +32,7 @@ static bool QT_WIFI_DEBUG = !qgetenv("QT_WIFI_DEBUG").isEmpty();
 
 const QEvent::Type WIFI_SCAN_RESULTS = (QEvent::Type) (QEvent::User + 2001);
 const QEvent::Type WIFI_CONNECTED = (QEvent::Type) (QEvent::User + 2002);
+const QEvent::Type WIFI_HANDSHAKE_FAILED = (QEvent::Type) (QEvent::User + 2003);
 
 /*
  * This function is borrowed from /system/core/libnetutils/dhcp_utils.c
@@ -89,28 +90,30 @@ public:
     }
 
     void run() {
-        if (QT_WIFI_DEBUG) qDebug("EventReceiver thread is running");
+        if (QT_WIFI_DEBUG) qDebug("WiFi event thread is running");
+        QWifiManagerEvent *event = 0;
         char buffer[2048];
         while (1) {
             int size = wifi_wait_for_event(m_if.constData(), buffer, sizeof(buffer) - 1);
             if (size > 0) {
                 buffer[size] = 0;
-
-                if (QT_WIFI_DEBUG) qDebug("EVENT: %s", buffer);
-
-                char *event = &buffer[11];
-                if (strstr(event, "SCAN-RESULTS")) {
-                    if (m_manager->exitingEventThread())
+                event = 0;
+                if (strstr(buffer, "SCAN-RESULTS")) {
+                    if (m_manager->exitingEventThread()) {
+                        if (QT_WIFI_DEBUG) qDebug() << "Exiting WiFi event thread";
                         return;
-                    QWifiManagerEvent *e = new QWifiManagerEvent(WIFI_SCAN_RESULTS);
-                    QCoreApplication::postEvent(m_manager, e);
-                } else if (strstr(event, "CONNECTED")) {
-                    QWifiManagerEvent *e = new QWifiManagerEvent(WIFI_CONNECTED);
-                    QCoreApplication::postEvent(m_manager, e);
-                } else if (strstr(event, "TERMINATING")) {
+                    }
+                    event = new QWifiManagerEvent(WIFI_SCAN_RESULTS);
+                } else if (strstr(buffer, "CONNECTED")) {
+                    event = new QWifiManagerEvent(WIFI_CONNECTED);
+                } else if (strstr(buffer, "Handshake failed")) {
+                    event = new QWifiManagerEvent(WIFI_HANDSHAKE_FAILED);
+                } else if (strstr(buffer, "TERMINATING")) {
                     // stop monitoring for events when supplicant is terminating
                     return;
                 }
+                if (event)
+                    QCoreApplication::postEvent(m_manager, event);
             }
         }
     }
@@ -161,6 +164,8 @@ public:
 
     \list
     \li \e WifiManager.Disconnected - Not connected to any network
+    \li \e WifiManager.Authenticating - Verifying password with the network provider
+    \li \e WifiManager.HandshakeFailed - Incorrect password provided
     \li \e WifiManager.ObtainingIPAddress - Requesting IP address from DHCP server
     \li \e WifiManager.DhcpRequestFailed - Could not retrieve IP address
     \li \e WifiManager.Connected - Ready to process network requests
@@ -212,8 +217,8 @@ public:
 /*!
     \qmlproperty WifiNetworkListModel WifiManager::networks
 
-    This property holds a list of networks that can be sensed by a device and should be used as a
-    data model in ListView. List is updated every 5 seconds.
+    This property holds a list of networks that can be sensed by a device. Use the returned
+    model as data model in ListView, model is updated every 5 seconds.
 
     WifiNetworkListModel is a simple data model consisting of WifiNetwork objects, accessed with
     the "network" data role. Instances of WifiNetwork cannot be created directly from the QML system.
@@ -313,9 +318,10 @@ public:
 */
 
 /*!
-    \qmlsignal void WifiManager::networkStateChanged()
+    \qmlsignal void WifiManager::networkStateChanged(WifiNetwork network)
 
-    This signal is emitted whenever changes in a network state occur.
+    This signal is emitted whenever changes in a network state occur. Network \a network is the
+    the currently active network connection.
 
     \sa networkState
 */
@@ -338,12 +344,14 @@ public:
 */
 
 QWifiManager::QWifiManager()
-    : m_networks(this)
+    : m_networkListModel(this)
     , m_eventThread(0)
     , m_scanTimer(0)
     , m_scanning(false)
     , m_daemonClientSocket(0)
     , m_exitingEventThread(false)
+    , m_startingUp(true)
+    , m_network(0)
 {
     char interface[PROPERTY_VALUE_MAX];
     property_get(WIFI_INTERFACE, interface, NULL);
@@ -361,15 +369,15 @@ QWifiManager::QWifiManager()
         qWarning() << "QWifiManager: failed to connect to qconnectivity socket";
     }
     // check if backend has already been initialized
-    char backend_status[PROPERTY_VALUE_MAX];
-    if (property_get(QT_WIFI_BACKEND, backend_status, NULL)) {
-        if (strcmp(backend_status, "running") == 0) {
+    char backendStatus[PROPERTY_VALUE_MAX];
+    if (property_get(QT_WIFI_BACKEND, backendStatus, NULL)) {
+        if (strcmp(backendStatus, "running") == 0) {
             // let it re-connect, in most cases this will see that everything is working properly
             // and will do nothing. Special case is when process has crashed or was killed by a system
             // signal in previous execution, which results in broken connection to a supplicant,
             // connectToBackend will fix it..
             connectToBackend();
-        } else if (strcmp(backend_status, "stopped") == 0) {
+        } else if (strcmp(backendStatus, "stopped") == 0) {
             // same here, cleans up the state
             disconnectFromBackend();
         }
@@ -378,12 +386,7 @@ QWifiManager::QWifiManager()
 
 QWifiManager::~QWifiManager()
 {
-    // exit event thread if it is running
-    if (m_eventThread->isRunning()) {
-        m_exitingEventThread = true;
-        call("SCAN");
-        m_eventThread->wait();
-    }
+    exitEventThread();
     delete m_eventThread;
     delete m_daemonClientSocket;
 }
@@ -395,14 +398,12 @@ void QWifiManager::handleDhcpReply()
         receivedMessage = m_daemonClientSocket->readLine(m_daemonClientSocket->bytesAvailable());
         if (QT_WIFI_DEBUG) qDebug() << "QWifiManager: reply from qconnectivity: " << receivedMessage;
         if (receivedMessage == "success") {
-            m_state = Connected;
-            emit networkStateChanged();
+            updateNetworkState(Connected);
             emit connectedSSIDChanged(m_connectedSSID);
             // Store settings of a working wifi connection
             call("SAVE_CONFIG");
         } else if (receivedMessage == "failed") {
-            m_state = DhcpRequestFailed;
-            emit networkStateChanged();
+            updateNetworkState(DhcpRequestFailed);
         } else {
             qWarning() << "QWifiManager: unknown message: " << receivedMessage;
         }
@@ -428,12 +429,16 @@ void QWifiManager::connectedToDaemon()
 void QWifiManager::start()
 {
     if (QT_WIFI_DEBUG) qDebug("QWifiManager: connecting to the backend");
+    if (m_backendReady)
+        return;
     connectToBackend();
 }
 
 void QWifiManager::stop()
 {
     if (QT_WIFI_DEBUG) qDebug("QWifiManager: shutting down");
+    if (!m_backendReady)
+        return;
     disconnectFromBackend();
 }
 
@@ -462,15 +467,12 @@ void QWifiManager::connectToBackend()
     if (QT_WIFI_DEBUG) qDebug("QWifiManager: started successfully");
     m_exitingEventThread = false;
     m_eventThread->start();
-    handleConnected();
+    call("SCAN");
 }
 
 void QWifiManager::disconnectFromBackend()
 {
-    m_exitingEventThread = true;
-    call("SCAN");
-    m_eventThread->wait();
-
+    exitEventThread();
     if (wifi_stop_supplicant(0) < 0)
         qWarning("QWifiManager: failed to stop supplicant");
     wifi_close_supplicant_connection(m_interface.constData());
@@ -479,9 +481,18 @@ void QWifiManager::disconnectFromBackend()
     emit backendReadyChanged();
 }
 
+void QWifiManager::exitEventThread()
+{
+    if (m_eventThread->isRunning()) {
+        m_exitingEventThread = true;
+        call("SCAN");
+        m_eventThread->wait();
+    }
+}
+
 void QWifiManager::setScanning(bool scanning)
 {
-    if (m_scanning == scanning)
+    if (!m_backendReady || m_scanning == scanning)
         return;
 
     m_scanning = scanning;
@@ -517,15 +528,27 @@ bool QWifiManager::checkedCall(const char *command) const
     return call(command).trimmed().toUpper() == "OK";
 }
 
+void QWifiManager::updateNetworkState(NetworkState state)
+{
+    m_state = state;
+    if (m_network)
+        emit networkStateChanged(m_network);
+}
+
 bool QWifiManager::event(QEvent *e)
 {
     switch ((int) e->type()) {
     case WIFI_SCAN_RESULTS:
-        m_networks.parseScanResults(call("SCAN_RESULTS"));
+        m_networkListModel.parseScanResults(call("SCAN_RESULTS"));
+        if (m_startingUp)
+            handleConnected();
         return true;
     case WIFI_CONNECTED:
         handleConnected();
         break;
+    case WIFI_HANDSHAKE_FAILED:
+        updateNetworkState(HandshakeFailed);
+        break;
     case QEvent::Timer: {
         int tid = static_cast<QTimerEvent *>(e)->timerId();
         if (tid == m_scanTimer) {
@@ -541,10 +564,13 @@ bool QWifiManager::event(QEvent *e)
 
 void QWifiManager::connect(QWifiNetwork *network, const QString &passphrase)
 {
+    m_network = network;
     if (network->ssid() == m_connectedSSID) {
-        if (QT_WIFI_DEBUG) qDebug("QWifiManager::connect(), already connected to %s", network->ssid().constData());
+        if (QT_WIFI_DEBUG)
+            qDebug("QWifiManager::connect(), already connected to %s", network->ssid().constData());
         return;
     }
+    updateNetworkState(Authenticating);
 
     call("DISABLE_NETWORK all");
     if (!m_connectedSSID.isEmpty()) {
@@ -552,16 +578,13 @@ void QWifiManager::connect(QWifiNetwork *network, const QString &passphrase)
         emit connectedSSIDChanged(m_connectedSSID);
     }
 
-    m_state = ObtainingIPAddress;
-    emit networkStateChanged();
     bool networkKnown = false;
     QByteArray id;
     QByteArray listResult = call("LIST_NETWORKS");
     QList<QByteArray> lines = listResult.split('\n');
     foreach (const QByteArray &line, lines) {
         if (line.contains(network->ssid())) {
-            int networkId = line.toInt();
-            id = QByteArray::number(networkId);
+            id = line.split('\t').at(0);
             networkKnown = true;
             break;
         }
@@ -569,7 +592,7 @@ void QWifiManager::connect(QWifiNetwork *network, const QString &passphrase)
 
     if (!networkKnown) {
         bool ok;
-        QByteArray id = call("ADD_NETWORK").trimmed();
+        id = call("ADD_NETWORK").trimmed();
         id.toInt(&ok);
         if (!ok) {
             qWarning("QWifiManager::connect(), failed to add network");
@@ -612,9 +635,8 @@ void QWifiManager::disconnect()
     call("DISCONNECT");
     QByteArray req = m_interface;
     sendDhcpRequest(req.append(" disconnect"));
-    m_state = Disconnected;
     m_connectedSSID.clear();
-    emit networkStateChanged();
+    updateNetworkState(Disconnected);
     emit connectedSSIDChanged(m_connectedSSID);
 }
 
@@ -622,7 +644,7 @@ void QWifiManager::handleConnected()
 {
     QList<QByteArray> lists = call("LIST_NETWORKS").split('\n');
     QByteArray connectedNetwork;
-    for (int i=1; i<lists.size(); ++i) {
+    for (int i = 1; i < lists.size(); ++i) {
         if (lists.at(i).toUpper().contains("[CURRENT]")) {
             connectedNetwork = lists.at(i);
             break;
@@ -631,8 +653,6 @@ void QWifiManager::handleConnected()
 
     if (connectedNetwork.isEmpty()) {
         if (QT_WIFI_DEBUG) qDebug("QWifiManager::handleConnected: not connected to a network...");
-        m_state = Disconnected;
-        emit networkStateChanged();
         return;
     }
 
@@ -641,6 +661,15 @@ void QWifiManager::handleConnected()
     QList<QByteArray> info = connectedNetwork.split('\t');
     m_connectedSSID = info.at(1);
 
+    if (m_startingUp) {
+        m_startingUp = false;
+        if (!m_network) {
+            int pos = 0; // unused
+            m_network = m_networkListModel.networkForSSID(info.at(1), &pos);
+        }
+    }
+
+    updateNetworkState(ObtainingIPAddress);
     QByteArray req = m_interface;
     sendDhcpRequest(req.append(" connect"));
 }
diff --git a/src/imports/wifi/qwifimanager.h b/src/imports/wifi/qwifimanager.h
index 4b76368..162190e 100644
--- a/src/imports/wifi/qwifimanager.h
+++ b/src/imports/wifi/qwifimanager.h
@@ -42,6 +42,8 @@ class QWifiManager : public QObject
 public:
     enum NetworkState {
         Disconnected,
+        Authenticating,
+        HandshakeFailed,
         ObtainingIPAddress,
         DhcpRequestFailed,
         Connected
@@ -50,7 +52,7 @@ public:
     QWifiManager();
     ~QWifiManager();
 
-    QWifiNetworkListModel *networks() { return &m_networks; }
+    QWifiNetworkListModel *networks() { return &m_networkListModel; }
     QString connectedSSID() const { return m_connectedSSID; }
     bool scanning() const { return m_scanning; }
     void setScanning(bool scanning);
@@ -65,10 +67,10 @@ public slots:
     void disconnect();
 
 signals:
-    void scanningChanged(bool arg);
-    void networkStateChanged();
+    void scanningChanged(bool scanning);
+    void networkStateChanged(QWifiNetwork *network);
     void backendReadyChanged();
-    void connectedSSIDChanged(const QString &);
+    void connectedSSIDChanged(const QString &ssid);
 
 protected:
     bool event(QEvent *);
@@ -76,8 +78,10 @@ protected:
     void handleConnected();
     void connectToBackend();
     void disconnectFromBackend();
+    void exitEventThread();
     QByteArray call(const char *command) const;
     bool checkedCall(const char *command) const;
+    void updateNetworkState(NetworkState state);
 
 protected slots:
     void connectedToDaemon();
@@ -87,7 +91,7 @@ private:
     friend class QWifiManagerEventThread;
 
     QString m_connectedSSID;
-    QWifiNetworkListModel m_networks;
+    QWifiNetworkListModel m_networkListModel;
     QWifiManagerEventThread *m_eventThread;
 
     int m_scanTimer;
@@ -99,6 +103,8 @@ private:
     QLocalSocket *m_daemonClientSocket;
     QByteArray m_request;
     bool m_exitingEventThread;
+    bool m_startingUp;
+    QWifiNetwork *m_network;
 };
 
 #endif // QWIFIMANAGER_H
diff --git a/src/imports/wifi/qwifinetwork.cpp b/src/imports/wifi/qwifinetwork.cpp
index 38e031c..d4c20ef 100644
--- a/src/imports/wifi/qwifinetwork.cpp
+++ b/src/imports/wifi/qwifinetwork.cpp
@@ -45,7 +45,7 @@
 /*!
     \qmlproperty int WifiNetwork::signalStrength
 
-    This property holds the current strength of a WiFi signal. New readings are
+    This property holds the current strength of a WiFi signal, measured in dBm. New readings are
     taken every 5 seconds.
 
     \sa signalStrengthChanged
@@ -81,19 +81,10 @@
     This signal is emitted whenever signal strength has changed comparing the the
     previous reading, the new signal's strength is \a strength.
 
-    \code
-    function handleStrengthChanged(currentStrength) {
-        if (currentStrength < UNTOLERABLE_SPEED)
-            print("network speed has dropped under " + UNTOLERABLE_SPEED)
-    }
-
-    Component.onCompleted: {
-        network.onSignalStrengthChanged.connect(handleStrengthChanged)
-    }
-    \endcode
 */
 
-QWifiNetwork::QWifiNetwork()
+QWifiNetwork::QWifiNetwork() :
+    m_outOfRange(false)
 {
 }
 
@@ -104,3 +95,10 @@ void QWifiNetwork::setSignalStrength(int strength)
     m_signalStrength = strength;
     emit signalStrengthChanged(m_signalStrength);
 }
+
+void QWifiNetwork::setOutOfRange(bool outOfRange)
+{
+    if (m_outOfRange == outOfRange)
+        return;
+    m_outOfRange = outOfRange;
+}
diff --git a/src/imports/wifi/qwifinetwork.h b/src/imports/wifi/qwifinetwork.h
index 780fc87..5ecc6a3 100644
--- a/src/imports/wifi/qwifinetwork.h
+++ b/src/imports/wifi/qwifinetwork.h
@@ -22,8 +22,6 @@
 #include <QtCore/QByteArray>
 #include <QtCore/QObject>
 
-class QWifiManager;
-
 class QWifiNetwork : public QObject
 {
     Q_OBJECT
@@ -48,6 +46,9 @@ public:
     int signalStrength() const { return m_signalStrength; }
     void setSignalStrength(int strength);
 
+    void setOutOfRange(bool outOfRange);
+    bool outOfRange() { return m_outOfRange; }
+
     QByteArray flags() const { return m_flags; }
     void setFlags(const QByteArray &f) { m_flags = f; }
     bool supportsWPA2() const { return m_flags.contains("WPA2"); }
@@ -56,7 +57,7 @@ public:
     bool supportsWPS() const { return m_flags.contains("WPS"); }
 
 signals:
-    void signalStrengthChanged(int arg);
+    void signalStrengthChanged(int strength);
 
 private:
     QByteArray m_bssid;
@@ -64,6 +65,7 @@ private:
     int m_signalStrength;
 
     QByteArray m_flags;
+    bool m_outOfRange;
 };
 
 #endif // QWIFINETWORK_H
diff --git a/src/imports/wifi/qwifinetworklistmodel.cpp b/src/imports/wifi/qwifinetworklistmodel.cpp
index bd1d37d..4fbf25f 100644
--- a/src/imports/wifi/qwifinetworklistmodel.cpp
+++ b/src/imports/wifi/qwifinetworklistmodel.cpp
@@ -27,6 +27,14 @@ QWifiNetworkListModel::QWifiNetworkListModel(QWifiManager *manager)
 {
 }
 
+QWifiNetworkListModel::~QWifiNetworkListModel()
+{
+    qDeleteAll(m_networks);
+    qDeleteAll(m_outOfRangeNetworks);
+    m_networks.clear();
+    m_outOfRangeNetworks.clear();
+}
+
 QHash<int, QByteArray> QWifiNetworkListModel::roleNames() const
 {
     QHash<int, QByteArray> names;
@@ -48,7 +56,7 @@ QVariant QWifiNetworkListModel::data(const QModelIndex &index, int role) const
 
 QWifiNetwork *QWifiNetworkListModel::networkForSSID(const QByteArray &ssid, int *pos)
 {
-    for (int i=0; i<m_networks.size(); ++i) {
+    for (int i = 0; i < m_networks.size(); ++i) {
         if (m_networks.at(i)->ssid() == ssid) {
             if (pos)
                 *pos = i;
@@ -58,21 +66,32 @@ QWifiNetwork *QWifiNetworkListModel::networkForSSID(const QByteArray &ssid, int
     return 0;
 }
 
+QWifiNetwork *QWifiNetworkListModel::outOfRangeListContains(const QByteArray &ssid)
+{
+    for (int i = 0; i < m_outOfRangeNetworks.length(); ++i)
+        if (m_outOfRangeNetworks.at(i)->ssid() == ssid)
+            return m_outOfRangeNetworks.takeAt(i);
+    return 0;
+}
+
 void QWifiNetworkListModel::parseScanResults(const QByteArray &results)
 {
     QList<QByteArray> lines = results.split('\n');
-
     QSet<QByteArray> sensibleNetworks;
-    for (int i=1; i<lines.size(); ++i) {
+
+    for (int i = 1; i < lines.size(); ++i) {
         QList<QByteArray> info = lines.at(i).split('\t');
         if (info.size() < 5 || info.at(4).isEmpty() || info.at(0).isEmpty())
             continue;
         int pos = 0;
-        if (!sensibleNetworks.contains(info.at(4)))
-            sensibleNetworks.insert(info.at(4));
-        QWifiNetwork *existingNetwork = networkForSSID(info.at(4), &pos);
-        if (!existingNetwork) {
+        sensibleNetworks.insert(info.at(4));
+        QWifiNetwork *knownNetwork = networkForSSID(info.at(4), &pos);
+        if (!knownNetwork)
+            knownNetwork = outOfRangeListContains(info.at(4));
+
+        if (!knownNetwork) {
             QWifiNetwork *network = new QWifiNetwork();
+            network->setOutOfRange(false);
             network->setBssid(info.at(0));
             network->setFlags(info.at(3));
             // signal strength is in dBm
@@ -82,13 +101,23 @@ void QWifiNetworkListModel::parseScanResults(const QByteArray &results)
             m_networks << network;
             endInsertRows();
         } else {
+            if (knownNetwork->outOfRange()) {
+                // known network has come back into a range
+                knownNetwork->setOutOfRange(false);
+                beginInsertRows(QModelIndex(), m_networks.size(), m_networks.size());
+                m_networks << knownNetwork;
+                endInsertRows();
+                pos = m_networks.length() - 1;
+            }
             // ssids are the same, compare bssids..
-            if (existingNetwork->bssid() == info.at(0)) {
+            if (knownNetwork->bssid() == info.at(0)) {
                 // same access point, simply update the signal strength
-                existingNetwork->setSignalStrength(info.at(2).toInt());
+                knownNetwork->setSignalStrength(info.at(2).toInt());
+                knownNetwork->setOutOfRange(false);
                 dataChanged(createIndex(pos, 0), createIndex(pos, 0));
-            } else if (existingNetwork->signalStrength() < info.at(2).toInt()) {
+            } else if (knownNetwork->signalStrength() < info.at(2).toInt()) {
                 // replace with a stronger access point within the same network
+                m_networks.at(pos)->setOutOfRange(false);
                 m_networks.at(pos)->setBssid(info.at(0));
                 m_networks.at(pos)->setFlags(info.at(3));
                 m_networks.at(pos)->setSignalStrength(info.at(2).toInt());
@@ -97,16 +126,16 @@ void QWifiNetworkListModel::parseScanResults(const QByteArray &results)
             }
         }
     }
-    // remove networks that have gone out of range
-    for (int i = 0; i < m_networks.size(); ++i) {
+    // remove out-of-range networks from the data model
+    for (int i = 0; i < m_networks.size();) {
         if (!sensibleNetworks.contains(m_networks.at(i)->ssid())) {
             beginRemoveRows(QModelIndex(), i, i);
-            delete m_networks.takeAt(i);
+            QWifiNetwork *n = m_networks.takeAt(i);
+            n->setOutOfRange(true);
+            m_outOfRangeNetworks.append(n);
             endRemoveRows();
         } else {
             ++i;
         }
     }
 }
-
-
diff --git a/src/imports/wifi/qwifinetworklistmodel.h b/src/imports/wifi/qwifinetworklistmodel.h
index 2827c8a..91ca231 100644
--- a/src/imports/wifi/qwifinetworklistmodel.h
+++ b/src/imports/wifi/qwifinetworklistmodel.h
@@ -33,10 +33,12 @@ class QWifiNetworkListModel : public QAbstractListModel
 public:
 
     QWifiNetworkListModel(QWifiManager *manager);
+    ~QWifiNetworkListModel();
 
     void parseScanResults(const QByteArray &data);
 
     QWifiNetwork *networkForSSID(const QByteArray &ssid, int *pos);
+    QWifiNetwork *outOfRangeListContains(const QByteArray &ssid);
 
     int rowCount(const QModelIndex &) const { return m_networks.size(); }
     QVariant data(const QModelIndex &index, int role) const;
@@ -46,6 +48,7 @@ public:
 private:
     QWifiManager *m_manager;
     QList<QWifiNetwork *> m_networks;
+    QList<QWifiNetwork *> m_outOfRangeNetworks;
 };
 
 #endif // QWIFINETWORKLISTMODEL_H