Simplify current SSID handling

by extracting SSID from "Trying to associate"
message.

Change-Id: If90e85d5cedf2366947c810a55fb486d7559d66f
Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>

5 files changed, 47 insertions, 76 deletions

diff --git a/src/wifi/qwificontroller.cpp b/src/wifi/qwificontroller.cpp
index f63b554..216c70c 100644
--- a/src/wifi/qwificontroller.cpp
+++ b/src/wifi/qwificontroller.cpp
@@ -129,21 +129,6 @@ QT_BEGIN_NAMESPACE
 
 Q_LOGGING_CATEGORY(B2QT_WIFI, "qt.b2qt.wifi")
 
-class QWifiManagerEvent : public QEvent
-{
-public:
-    QWifiManagerEvent(QEvent::Type type, const QByteArray &data = QByteArray())
-        : QEvent(type)
-        , m_data(data)
-    {
-    }
-
-    QByteArray data() const { return m_data; }
-
-private:
-    QByteArray m_data;
-};
-
 class QWifiEventThread : public QThread
 {
 public:
@@ -155,7 +140,7 @@ public:
 
     void run() {
         qCDebug(B2QT_WIFI) << "running wifi event thread";
-        QWifiManagerEvent *event = 0;
+        QWifiEvent *event = 0;
         char buffer[2048];
         forever {
             int size = q_wifi_wait_for_event(m_interface, buffer, sizeof(buffer) - 1);
@@ -163,21 +148,24 @@ public:
                 buffer[size] = 0;
                 event = 0;
                 qCDebug(B2QT_WIFI) << "[event]: " << buffer;
+
                 if (m_controller->isWifiThreadExitRequested()) {
                     qCDebug(B2QT_WIFI) << "exit wifi event thread";
                     return;
                 }
+
                 if (strstr(buffer, "SCAN-RESULTS")) {
-                    event = new QWifiManagerEvent(WIFI_SCAN_RESULTS);
+                    event = new QWifiEvent(WIFI_SCAN_RESULTS);
                 } else if (strstr(buffer, "CTRL-EVENT-CONNECTED")) {
-                    event = new QWifiManagerEvent(WIFI_CONNECTED);
+                    event = new QWifiEvent(WIFI_CONNECTED);
                 } else if (strstr(buffer, "CTRL-EVENT-DISCONNECTED")) {
-                    event = new QWifiManagerEvent(WIFI_DISCONNECTED);
+                    event = new QWifiEvent(WIFI_DISCONNECTED);
                 } else if (strstr(buffer, "Trying to associate")) {
-                    event = new QWifiManagerEvent(WIFI_AUTHENTICATING);
+                    event = new QWifiEvent(WIFI_AUTHENTICATING, QLatin1String(buffer));
                 } else if (strstr(buffer, "Handshake failed")) {
-                    event = new QWifiManagerEvent(WIFI_HANDSHAKE_FAILED);
+                    event = new QWifiEvent(WIFI_HANDSHAKE_FAILED);
                 }
+
                 if (event)
                     QCoreApplication::postEvent(m_controller->wifiManager(), event);
             }
diff --git a/src/wifi/qwificontroller_p.h b/src/wifi/qwificontroller_p.h
index d79e1c2..63ad2ef 100644
--- a/src/wifi/qwificontroller_p.h
+++ b/src/wifi/qwificontroller_p.h
@@ -62,6 +62,20 @@ class QWifiEventThread;
 class QLocalSocket;
 #endif
 
+class QWifiEvent : public QEvent
+{
+public:
+    QWifiEvent(QEvent::Type type, const QString &data = QString())
+        : QEvent(type)
+        , m_data(data)
+    {
+    }
+    QString data() const { return m_data; }
+
+private:
+    QString m_data;
+};
+
 class QWifiController : public QThread
 {
     Q_OBJECT
diff --git a/src/wifi/qwifimanager.cpp b/src/wifi/qwifimanager.cpp
index d60ec13..14d839e 100644
--- a/src/wifi/qwifimanager.cpp
+++ b/src/wifi/qwifimanager.cpp
@@ -42,7 +42,6 @@ QWifiManagerPrivate::QWifiManagerPrivate(QWifiManager *manager)
         , m_interface(QWifiDevice::wifiInterfaceName())
         , m_backendState(QWifiManager::NotRunning)
         , m_networkState(QWifiManager::Disconnected)
-        , m_setCurrentSSID(true)
 {
     qCDebug(B2QT_WIFI) << "using wifi interface: " << m_interface;
 }
@@ -53,54 +52,29 @@ QWifiManagerPrivate::~QWifiManagerPrivate()
     delete m_networkListModel;
 }
 
-QString QWifiManagerPrivate::getConnectedNetwork()
-{
-    QStringList lists = call(QStringLiteral("LIST_NETWORKS")).split('\n');
-    QString connectedNetwork;
-    for (int i = 1; i < lists.size(); ++i) {
-        if (lists.at(i).toUpper().contains(QStringLiteral("[CURRENT]"))) {
-            connectedNetwork = lists.at(i);
-            break;
-        }
-    }
-    return connectedNetwork;
-}
-
-void QWifiManagerPrivate::emitCurrentSSIDChanged()
+void QWifiManagerPrivate::setCurrentSSID(const QString &ssid)
 {
     Q_Q(QWifiManager);
-    if (m_previousSSID != m_currentSSID) {
-        qCDebug(B2QT_WIFI) << "current SSID: " << m_previousSSID << " -> " << m_currentSSID;
-        m_previousSSID = m_currentSSID;
-        emit q->currentSSIDChanged(m_currentSSID);
-    }
+    qCDebug(B2QT_WIFI) << "current SSID: " << m_currentSSID << " -> " << ssid;
+    if (m_currentSSID == ssid)
+        return;
+
+    m_currentSSID = ssid;
+    emit q->currentSSIDChanged(m_currentSSID);
 }
 
-void QWifiManagerPrivate::setCurrentSSID()
+void QWifiManagerPrivate::handleAuthenticating(QWifiEvent *event)
 {
-    qCDebug(B2QT_WIFI, "setCurrentSSID");
-    m_setCurrentSSID = false;
-    QString connectedNetwork = getConnectedNetwork();
-    if (!connectedNetwork.isEmpty()) {
-        QString ssid = connectedNetwork.split('\t').at(1);
-        QWifiNetwork *network = m_networkListModel->networkForSSID(ssid);
-        if (network) {
-            m_currentSSID = network->ssid();
-            emitCurrentSSIDChanged();
-            if (call(QStringLiteral("STATUS")).contains(QStringLiteral("wpa_state=COMPLETED")))
-                updateNetworkState(QWifiManager::Connected);
-        }
-    }
+    QString data = event->data().trimmed();
+    QString ssid = data.mid(data.indexOf(QLatin1String("SSID")) + 6);
+    ssid = ssid.left(ssid.lastIndexOf(QLatin1Char('\'')));
+
+    setCurrentSSID(QWifiUtils::decodeHexEncoded(ssid));
+    updateNetworkState(QWifiManager::Authenticating);
 }
 
 void QWifiManagerPrivate::handleConnected()
 {
-    qCDebug(B2QT_WIFI, "handleConnected");
-    QString connectedNetwork = getConnectedNetwork();
-    if (connectedNetwork.isEmpty())
-        return;
-
-    m_currentSSID = QWifiUtils::decodeHexEncoded(connectedNetwork.split('\t').at(1));
     qCDebug(B2QT_WIFI) << "connected network: " << m_currentSSID;
     updateNetworkState(QWifiManager::ObtainingIPAddress);
     m_wifiController->call(QWifiController::AcquireIPAddress);
@@ -426,8 +400,6 @@ bool QWifiManager::event(QEvent *event)
     switch ((int) event->type()) {
     case WIFI_SCAN_RESULTS:
         d->m_networkListModel->parseScanResults(d->call(QStringLiteral("SCAN_RESULTS")));
-        if (d->m_setCurrentSSID || d->m_currentSSID.isEmpty())
-            d->setCurrentSSID();
         return true;
     case WIFI_CONNECTED:
         d->handleConnected();
@@ -436,11 +408,10 @@ bool QWifiManager::event(QEvent *event)
         d->handleDisconneced();
         return true;
     case WIFI_AUTHENTICATING:
-        d->updateNetworkState(Authenticating);
-        d->emitCurrentSSIDChanged();
+        d->handleAuthenticating(static_cast<QWifiEvent *>(event));
         return true;
     case WIFI_HANDSHAKE_FAILED:
-        d->updateNetworkState(HandshakeFailed);
+        d->updateNetworkState(QWifiManager::HandshakeFailed);
         return true;
     case QEvent::Timer: {
         int tid = static_cast<QTimerEvent *>(event)->timerId();
@@ -471,8 +442,8 @@ bool QWifiManager::connect(QWifiConfiguration *config)
     }
 
     d->call(QStringLiteral("DISABLE_NETWORK all"));
+    d->setCurrentSSID(config->ssid());
 
-    d->m_currentSSID = config->ssid();
     bool networkKnown = false;
     QString id;
     const QStringList configuredNetworks = d->call(QStringLiteral("LIST_NETWORKS")).split('\n');
@@ -558,9 +529,6 @@ void QWifiManager::handleBackendStateChanged(BackendState backendState)
 {
     Q_D(QWifiManager);
     switch (backendState) {
-    case Running:
-        d->m_setCurrentSSID = true;
-        break;
     case NotRunning:
         d->updateNetworkState(Disconnected);
         break;
@@ -575,7 +543,6 @@ void QWifiManager::handleDhcpRequestFinished(const QString &status)
     Q_D(QWifiManager);
     qCDebug(B2QT_WIFI) << "handleDhcpRequestFinished: " << status << " for " << d->m_currentSSID;
     if (status == QLatin1String("success")) {
-        d->emitCurrentSSIDChanged();
         d->updateNetworkState(Connected);
         d->call(QStringLiteral("SAVE_CONFIG"));
     } else {
diff --git a/src/wifi/qwifimanager_p.h b/src/wifi/qwifimanager_p.h
index ef8a0da..6142c83 100644
--- a/src/wifi/qwifimanager_p.h
+++ b/src/wifi/qwifimanager_p.h
@@ -25,6 +25,8 @@
 
 QT_BEGIN_NAMESPACE
 
+class QWifiEvent;
+
 class QWifiManagerPrivate
 {
     Q_DECLARE_PUBLIC(QWifiManager)
@@ -33,11 +35,10 @@ public:
     virtual ~QWifiManagerPrivate();
 
     // methods
-    QString getConnectedNetwork();
-    void setCurrentSSID();
-    void emitCurrentSSIDChanged();
+    void setCurrentSSID(const QString &ssid);
     void handleConnected();
     void handleDisconneced();
+    void handleAuthenticating(QWifiEvent *event);
 
     void updateNetworkState(QWifiManager::NetworkState networkState);
     void updateBackendState(QWifiManager::BackendState backendState);
@@ -57,9 +58,7 @@ public:
     QByteArray m_interface;
     QWifiManager::BackendState m_backendState;
     QWifiManager::NetworkState m_networkState;
-    bool m_setCurrentSSID;
     QString m_currentSSID;
-    QString m_previousSSID;
     QString m_lastError;
 };
 
diff --git a/src/wifi/qwifinetworklistmodel.cpp b/src/wifi/qwifinetworklistmodel.cpp
index e562b2b..7ed4be4 100644
--- a/src/wifi/qwifinetworklistmodel.cpp
+++ b/src/wifi/qwifinetworklistmodel.cpp
@@ -125,6 +125,9 @@ void QWifiNetworkListModel::parseScanResults(const QString &results)
         int pos = 0;
 
         QString ssid = QWifiUtils::decodeHexEncoded(info.at(4));
+        if (ssid.isEmpty())
+            continue;
+
         sensibleNetworks.insert(ssid);
         QWifiNetwork *knownNetwork = networkForSSID(ssid, &pos);
         if (!knownNetwork)