libs/declarative/connectionicon.cpp

0001 /*
0002     SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
0003
0004     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
0005 */
0006
0007 #include "connectionicon.h"
0008 #include "configuration.h"
0009 #include "uiutils.h"
0010
0011 #include <NetworkManagerQt/BluetoothDevice>
0012 #include <NetworkManagerQt/Connection>
0013 #include <NetworkManagerQt/ConnectionSettings>
0014 #include <NetworkManagerQt/Device>
0015 #include <NetworkManagerQt/ModemDevice>
0016 #include <NetworkManagerQt/WiredDevice>
0017 #include <NetworkManagerQt/WirelessDevice>
0018 #include <NetworkManagerQt/WirelessSetting>
0019
0020 #include <ModemManagerQt/Manager>
0021
0022 ConnectionIcon::ConnectionIcon(QObject *parent)
0023     : QObject(parent)
0024     , m_wirelessNetwork(nullptr)
0025     , m_modemNetwork(nullptr)
0026 {
0027     connect(NetworkManager::notifier(), &NetworkManager::Notifier::primaryConnectionChanged, this, &ConnectionIcon::primaryConnectionChanged);
0028     connect(NetworkManager::notifier(), &NetworkManager::Notifier::activatingConnectionChanged, this, &ConnectionIcon::activatingConnectionChanged);
0029     connect(NetworkManager::notifier(), &NetworkManager::Notifier::activeConnectionAdded, this, &ConnectionIcon::activeConnectionAdded);
0030     connect(NetworkManager::notifier(), &NetworkManager::Notifier::connectivityChanged, this, &ConnectionIcon::connectivityChanged);
0031     connect(NetworkManager::notifier(), &NetworkManager::Notifier::deviceAdded, this, &ConnectionIcon::deviceAdded);
0032     connect(NetworkManager::notifier(), &NetworkManager::Notifier::deviceRemoved, this, &ConnectionIcon::deviceRemoved);
0033     connect(NetworkManager::notifier(), &NetworkManager::Notifier::networkingEnabledChanged, this, &ConnectionIcon::networkingEnabledChanged);
0034     connect(NetworkManager::notifier(), &NetworkManager::Notifier::statusChanged, this, &ConnectionIcon::statusChanged);
0035     connect(NetworkManager::notifier(), &NetworkManager::Notifier::wirelessEnabledChanged, this, &ConnectionIcon::wirelessEnabledChanged);
0036     connect(NetworkManager::notifier(), &NetworkManager::Notifier::wirelessHardwareEnabledChanged, this, &ConnectionIcon::wirelessEnabledChanged);
0037     connect(NetworkManager::notifier(), &NetworkManager::Notifier::wwanEnabledChanged, this, &ConnectionIcon::wwanEnabledChanged);
0038     connect(NetworkManager::notifier(), &NetworkManager::Notifier::wwanHardwareEnabledChanged, this, &ConnectionIcon::wwanEnabledChanged);
0039
0040     for (const NetworkManager::Device::Ptr &device : NetworkManager::networkInterfaces()) {
0041         if (device->type() == NetworkManager::Device::Ethernet) {
0042             NetworkManager::WiredDevice::Ptr wiredDevice = device.staticCast<NetworkManager::WiredDevice>();
0043             if (wiredDevice) {
0044                 connect(wiredDevice.data(), &NetworkManager::WiredDevice::carrierChanged, this, &ConnectionIcon::carrierChanged);
0045             }
0046         } else if (device->type() == NetworkManager::Device::Wifi) {
0047             NetworkManager::WirelessDevice::Ptr wifiDevice = device.staticCast<NetworkManager::WirelessDevice>();
0048             if (wifiDevice) {
0049                 connect(wifiDevice.data(), &NetworkManager::WirelessDevice::availableConnectionAppeared, this, &ConnectionIcon::wirelessNetworkAppeared);
0050                 connect(wifiDevice.data(), &NetworkManager::WirelessDevice::networkAppeared, this, &ConnectionIcon::wirelessNetworkAppeared);
0051             }
0052         }
0053     }
0054
0055     for (const NetworkManager::ActiveConnection::Ptr &activeConnection : NetworkManager::activeConnections()) {
0056         addActiveConnection(activeConnection->path());
0057     }
0058     setStates();
0059
0060     setIcons();
0061
0062     QDBusPendingReply<uint> pendingReply = NetworkManager::checkConnectivity();
0063     auto callWatcher = new QDBusPendingCallWatcher(pendingReply);
0064     connect(callWatcher, &QDBusPendingCallWatcher::finished, this, [this](QDBusPendingCallWatcher *watcher) {
0065         QDBusPendingReply<uint> reply = *watcher;
0066         if (reply.isValid()) {
0067             connectivityChanged((NetworkManager::Connectivity)reply.value());
0068         }
0069         watcher->deleteLater();
0070     });
0071 }
0072
0073 ConnectionIcon::~ConnectionIcon() = default;
0074
0075 bool ConnectionIcon::connecting() const
0076 {
0077     return m_connecting;
0078 }
0079
0080 QString ConnectionIcon::connectionIcon() const
0081 {
0082     if (m_vpn && !m_connectionIcon.contains(QLatin1String("available"))) {
0083         return m_connectionIcon + QStringLiteral("-locked");
0084     }
0085
0086     if (m_limited && !m_connectionIcon.contains(QLatin1String("available"))) {
0087         return m_connectionIcon + QStringLiteral("-limited");
0088     }
0089
0090     return m_connectionIcon;
0091 }
0092
0093 QString ConnectionIcon::connectionTooltipIcon() const
0094 {
0095     return m_connectionTooltipIcon;
0096 }
0097
0098 void ConnectionIcon::activatingConnectionChanged(const QString &connection)
0099 {
0100     Q_UNUSED(connection);
0101     setIcons();
0102 }
0103
0104 void ConnectionIcon::addActiveConnection(const QString &activeConnection)
0105 {
0106     NetworkManager::ActiveConnection::Ptr active = NetworkManager::findActiveConnection(activeConnection);
0107
0108     if (active) {
0109         NetworkManager::VpnConnection::Ptr vpnConnection;
0110         connect(active.data(), &NetworkManager::ActiveConnection::destroyed, this, &ConnectionIcon::activeConnectionDestroyed);
0111         if (active->vpn()) {
0112             vpnConnection = active.objectCast<NetworkManager::VpnConnection>();
0113             connect(vpnConnection.data(), &NetworkManager::VpnConnection::stateChanged, this, &ConnectionIcon::vpnConnectionStateChanged);
0114         } else {
0115             connect(active.data(), &NetworkManager::ActiveConnection::stateChanged, this, &ConnectionIcon::activeConnectionStateChanged, Qt::UniqueConnection);
0116         }
0117     }
0118 }
0119
0120 void ConnectionIcon::activeConnectionAdded(const QString &activeConnection)
0121 {
0122     addActiveConnection(activeConnection);
0123     setStates();
0124 }
0125
0126 void ConnectionIcon::activeConnectionStateChanged(NetworkManager::ActiveConnection::State state)
0127 {
0128     Q_UNUSED(state);
0129     setStates();
0130 }
0131
0132 void ConnectionIcon::activeConnectionDestroyed()
0133 {
0134     setStates();
0135 }
0136
0137 void ConnectionIcon::carrierChanged(bool carrier)
0138 {
0139     Q_UNUSED(carrier);
0140     setIcons();
0141 }
0142
0143 void ConnectionIcon::connectivityChanged(NetworkManager::Connectivity conn)
0144 {
0145     const bool needsPortal = conn == NetworkManager::Portal;
0146     if (needsPortal != m_needsPortal) {
0147         m_needsPortal = needsPortal;
0148         Q_EMIT needsPortalChanged(needsPortal);
0149     }
0150     setLimited(conn == NetworkManager::Portal || conn == NetworkManager::Limited);
0151 }
0152
0153 void ConnectionIcon::deviceAdded(const QString &device)
0154 {
0155     NetworkManager::Device::Ptr dev = NetworkManager::findNetworkInterface(device);
0156
0157     if (!dev) {
0158         return;
0159     }
0160
0161     if (dev->type() == NetworkManager::Device::Ethernet) {
0162         NetworkManager::WiredDevice::Ptr wiredDev = dev.objectCast<NetworkManager::WiredDevice>();
0163         connect(wiredDev.data(), &NetworkManager::WiredDevice::carrierChanged, this, &ConnectionIcon::carrierChanged);
0164     }
0165 }
0166
0167 void ConnectionIcon::deviceRemoved(const QString &device)
0168 {
0169     Q_UNUSED(device);
0170
0171     if (NetworkManager::status() == NetworkManager::Disconnected) {
0172         setDisconnectedIcon();
0173     }
0174 }
0175
0176 void ConnectionIcon::modemNetworkRemoved()
0177 {
0178     m_modemNetwork.clear();
0179 }
0180
0181 void ConnectionIcon::modemSignalChanged(ModemManager::SignalQualityPair signalQuality)
0182 {
0183     int diff = m_signal - signalQuality.signal;
0184
0185     if (diff >= 10 || diff <= -10) {
0186         m_signal = signalQuality.signal;
0187
0188         setIconForModem();
0189     }
0190 }
0191
0192 void ConnectionIcon::networkingEnabledChanged(bool enabled)
0193 {
0194     if (!enabled) {
0195         setConnectionIcon(QStringLiteral("network-unavailable"));
0196     }
0197 }
0198
0199 void ConnectionIcon::primaryConnectionChanged(const QString &connection)
0200 {
0201     if (!connection.isEmpty()) {
0202         setIcons();
0203     }
0204 }
0205
0206 void ConnectionIcon::statusChanged(NetworkManager::Status status)
0207 {
0208     if (status == NetworkManager::Disconnected) {
0209         setDisconnectedIcon();
0210     }
0211 }
0212
0213 void ConnectionIcon::vpnConnectionStateChanged(NetworkManager::VpnConnection::State state, NetworkManager::VpnConnection::StateChangeReason reason)
0214 {
0215     Q_UNUSED(state);
0216     Q_UNUSED(reason);
0217     setStates();
0218     setIcons();
0219 }
0220
0221 void ConnectionIcon::wirelessEnabledChanged(bool enabled)
0222 {
0223     Q_UNUSED(enabled);
0224     setIcons();
0225 }
0226
0227 void ConnectionIcon::wwanEnabledChanged(bool enabled)
0228 {
0229     Q_UNUSED(enabled);
0230     setIcons();
0231 }
0232
0233 void ConnectionIcon::wirelessNetworkAppeared(const QString &network)
0234 {
0235     Q_UNUSED(network);
0236     setIcons();
0237 }
0238
0239 void ConnectionIcon::setStates()
0240 {
0241     bool connecting = false;
0242     bool vpn = false;
0243     for (const NetworkManager::ActiveConnection::Ptr &activeConnection : NetworkManager::activeConnections()) {
0244         NetworkManager::VpnConnection::Ptr vpnConnection;
0245         if (activeConnection->vpn()) {
0246             vpnConnection = activeConnection.objectCast<NetworkManager::VpnConnection>();
0247         }
0248
0249         if (!vpnConnection) {
0250             if (activeConnection->state() == NetworkManager::ActiveConnection::Activating && UiUtils::isConnectionTypeSupported(activeConnection->type())) {
0251                 connecting = true;
0252             }
0253             if (activeConnection->type() == NetworkManager::ConnectionSettings::ConnectionType::WireGuard) {
0254                 vpn = true;
0255             }
0256         } else {
0257             if (vpnConnection->state() == NetworkManager::VpnConnection::Activated) {
0258                 vpn = true;
0259             } else if (vpnConnection->state() == NetworkManager::VpnConnection::Prepare //
0260                        || vpnConnection->state() == NetworkManager::VpnConnection::NeedAuth //
0261                        || vpnConnection->state() == NetworkManager::VpnConnection::Connecting //
0262                        || vpnConnection->state() == NetworkManager::VpnConnection::GettingIpConfig) {
0263                 connecting = true;
0264             }
0265         }
0266     }
0267
0268     setVpn(vpn);
0269     setConnecting(connecting);
0270 }
0271
0272 void ConnectionIcon::setIcons()
0273 {
0274     m_signal = 0;
0275     if (m_modemNetwork) {
0276         disconnect(m_modemNetwork.data(), nullptr, this, nullptr);
0277         m_modemNetwork.clear();
0278     }
0279     if (m_wirelessNetwork) {
0280         disconnect(m_wirelessNetwork.data(), nullptr, this, nullptr);
0281         m_wirelessNetwork.clear();
0282     }
0283
0284     NetworkManager::ActiveConnection::Ptr connection = NetworkManager::activatingConnection();
0285
0286     // Set icon based on the current primary connection if the activating connection is virtual
0287     // since we're not setting icons for virtual connections
0288     if (!connection || (connection && UiUtils::isConnectionTypeVirtual(connection->type()))
0289         || connection->type() == NetworkManager::ConnectionSettings::WireGuard) {
0290         connection = NetworkManager::primaryConnection();
0291     }
0292
0293     /* Fallback: If we still don't have an active connection with default route or the default route goes through a connection
0294                  of generic type (some type of VPNs) we need to go through all other active connections and pick the one with
0295                  highest probability of being the main one (order is: vpn, wired, wireless, gsm, cdma, bluetooth) */
0296     if ((!connection && !NetworkManager::activeConnections().isEmpty()) || (connection && connection->type() == NetworkManager::ConnectionSettings::Generic)
0297         || (connection && connection->type() == NetworkManager::ConnectionSettings::Tun)) {
0298         for (const NetworkManager::ActiveConnection::Ptr &activeConnection : NetworkManager::activeConnections()) {
0299             const NetworkManager::ConnectionSettings::ConnectionType type = activeConnection->type();
0300             if (type == NetworkManager::ConnectionSettings::Bluetooth) {
0301                 if (connection && connection->type() <= NetworkManager::ConnectionSettings::Bluetooth) {
0302                     connection = activeConnection;
0303                 }
0304             } else if (type == NetworkManager::ConnectionSettings::Cdma) {
0305                 if (connection && connection->type() <= NetworkManager::ConnectionSettings::Cdma) {
0306                     connection = activeConnection;
0307                 }
0308             } else if (type == NetworkManager::ConnectionSettings::Gsm) {
0309                 if (connection && connection->type() <= NetworkManager::ConnectionSettings::Gsm) {
0310                     connection = activeConnection;
0311                 }
0312             } else if (type == NetworkManager::ConnectionSettings::Vpn) {
0313                 connection = activeConnection;
0314             } else if (type == NetworkManager::ConnectionSettings::WireGuard) {
0315                 connection = activeConnection;
0316             } else if (type == NetworkManager::ConnectionSettings::Wired) {
0317                 if (connection
0318                     && (connection->type() != NetworkManager::ConnectionSettings::Vpn //
0319                         || connection->type() != NetworkManager::ConnectionSettings::WireGuard)) {
0320                     connection = activeConnection;
0321                 }
0322             } else if (type == NetworkManager::ConnectionSettings::Wireless) {
0323                 if (connection
0324                     && (connection->type() != NetworkManager::ConnectionSettings::Vpn //
0325                         && (connection->type() != NetworkManager::ConnectionSettings::Wired))) {
0326                     connection = activeConnection;
0327                 }
0328             }
0329         }
0330     }
0331
0332     if (connection && !connection->devices().isEmpty()) {
0333         NetworkManager::Device::Ptr device = NetworkManager::findNetworkInterface(connection->devices().first());
0334
0335         if (device) {
0336             NetworkManager::Device::Type type = device->type();
0337             if (type == NetworkManager::Device::Wifi) {
0338                 NetworkManager::WirelessDevice::Ptr wifiDevice = device.objectCast<NetworkManager::WirelessDevice>();
0339                 if (wifiDevice->mode() == NetworkManager::WirelessDevice::Adhoc) {
0340                     setWirelessIconForSignalStrength(100);
0341                 } else {
0342                     NetworkManager::AccessPoint::Ptr ap = wifiDevice->activeAccessPoint();
0343                     if (ap) {
0344                         setWirelessIcon(device, ap->ssid());
0345                     }
0346                 }
0347             } else if (type == NetworkManager::Device::Ethernet) {
0348                 setConnectionIcon(QStringLiteral("network-wired-activated"));
0349                 setConnectionTooltipIcon(QStringLiteral("network-wired-activated"));
0350             } else if (type == NetworkManager::Device::Modem) {
0351                 setModemIcon(device);
0352             } else if (type == NetworkManager::Device::Bluetooth) {
0353                 NetworkManager::BluetoothDevice::Ptr btDevice = device.objectCast<NetworkManager::BluetoothDevice>();
0354                 if (btDevice) {
0355                     if (btDevice->bluetoothCapabilities().testFlag(NetworkManager::BluetoothDevice::Dun)) {
0356                         setModemIcon(device);
0357                     } else {
0358                         setConnectionIcon(QStringLiteral("network-bluetooth-activated"));
0359                         setConnectionTooltipIcon(QStringLiteral("preferences-system-bluetooth"));
0360                     }
0361                 }
0362             } else if (type == 29) { // TODO change to WireGuard enum value once it is added
0363                 // WireGuard is a VPN but is not implemented
0364                 // in NetworkManager as a VPN, so we don't want to
0365                 // do anything just because it has a device
0366                 // associated with it.
0367             } else {
0368                 // Ignore other devices (bond/bridge/team etc.)
0369                 setDisconnectedIcon();
0370             }
0371         }
0372     } else {
0373         setDisconnectedIcon();
0374     }
0375 }
0376
0377 void ConnectionIcon::setDisconnectedIcon()
0378 {
0379     if (Configuration::self().airplaneModeEnabled()) {
0380         setConnectionIcon(QStringLiteral("network-flightmode-on"));
0381         return;
0382     }
0383
0384     if (NetworkManager::status() == NetworkManager::Unknown //
0385         || NetworkManager::status() == NetworkManager::Asleep) {
0386         setConnectionIcon(QStringLiteral("network-unavailable"));
0387         return;
0388     }
0389
0390     bool wired = false;
0391     bool wireless = false;
0392     bool modem = false;
0393
0394     m_limited = false;
0395     m_vpn = false;
0396
0397     for (const NetworkManager::Device::Ptr &device : NetworkManager::networkInterfaces()) {
0398         if (device->type() == NetworkManager::Device::Ethernet) {
0399             NetworkManager::WiredDevice::Ptr wiredDev = device.objectCast<NetworkManager::WiredDevice>();
0400             if (wiredDev->carrier()) {
0401                 wired = true;
0402             }
0403         } else if (device->type() == NetworkManager::Device::Wifi //
0404                    && NetworkManager::isWirelessEnabled() //
0405                    && NetworkManager::isWirelessHardwareEnabled()) {
0406             NetworkManager::WirelessDevice::Ptr wifiDevice = device.objectCast<NetworkManager::WirelessDevice>();
0407             if (!wifiDevice->accessPoints().isEmpty() || !wifiDevice->availableConnections().isEmpty()) {
0408                 wireless = true;
0409             }
0410         } else if (device->type() == NetworkManager::Device::Modem //
0411                    && NetworkManager::isWwanEnabled() //
0412                    && NetworkManager::isWwanHardwareEnabled()) {
0413             modem = true;
0414         }
0415     }
0416
0417     if (wired) {
0418         setConnectionIcon(QStringLiteral("network-wired-available"));
0419         setConnectionTooltipIcon(QStringLiteral("network-wired"));
0420         return;
0421     } else if (wireless) {
0422         setConnectionIcon(QStringLiteral("network-wireless-available"));
0423         setConnectionTooltipIcon(QStringLiteral("network-wireless-connected-00"));
0424         return;
0425     } else if (modem) {
0426         setConnectionIcon(QStringLiteral("network-mobile-available"));
0427         setConnectionTooltipIcon(QStringLiteral("phone"));
0428         return;
0429     } else {
0430         setConnectionIcon(QStringLiteral("network-unavailable"));
0431         setConnectionTooltipIcon(QStringLiteral("network-wired"));
0432     }
0433 }
0434
0435 void ConnectionIcon::setModemIcon(const NetworkManager::Device::Ptr &device)
0436 {
0437     NetworkManager::ModemDevice::Ptr modemDevice = device.objectCast<NetworkManager::ModemDevice>();
0438
0439     if (!modemDevice) {
0440         setConnectionIcon(QStringLiteral("network-mobile-100"));
0441
0442         return;
0443     }
0444
0445     ModemManager::ModemDevice::Ptr modem = ModemManager::findModemDevice(device->udi());
0446     if (modem) {
0447         if (modem->hasInterface(ModemManager::ModemDevice::ModemInterface)) {
0448             m_modemNetwork = modem->interface(ModemManager::ModemDevice::ModemInterface).objectCast<ModemManager::Modem>();
0449         }
0450     }
0451
0452     if (m_modemNetwork) {
0453         connect(m_modemNetwork.data(), &ModemManager::Modem::signalQualityChanged, this, &ConnectionIcon::modemSignalChanged, Qt::UniqueConnection);
0454         connect(m_modemNetwork.data(), &ModemManager::Modem::accessTechnologiesChanged, this, &ConnectionIcon::setIconForModem, Qt::UniqueConnection);
0455         connect(m_modemNetwork.data(), &ModemManager::Modem::destroyed, this, &ConnectionIcon::modemNetworkRemoved);
0456
0457         m_signal = m_modemNetwork->signalQuality().signal;
0458         setIconForModem();
0459     } else {
0460         setConnectionIcon(QStringLiteral("network-mobile-0"));
0461         setConnectionTooltipIcon(QStringLiteral("phone"));
0462         return;
0463     }
0464 }
0465
0466 void ConnectionIcon::setIconForModem()
0467 {
0468     if (!m_signal) {
0469         m_signal = m_modemNetwork->signalQuality().signal;
0470     }
0471     QString strength = QStringLiteral("00");
0472
0473     if (m_signal == 0) {
0474         strength = QLatin1Char('0');
0475     } else if (m_signal < 20) {
0476         strength = QStringLiteral("20");
0477     } else if (m_signal < 40) {
0478         strength = QStringLiteral("40");
0479     } else if (m_signal < 60) {
0480         strength = QStringLiteral("60");
0481     } else if (m_signal < 80) {
0482         strength = QStringLiteral("80");
0483     } else {
0484         strength = QStringLiteral("100");
0485     }
0486
0487     QString result;
0488
0489     switch (m_modemNetwork->accessTechnologies()) {
0490     case MM_MODEM_ACCESS_TECHNOLOGY_GSM:
0491     case MM_MODEM_ACCESS_TECHNOLOGY_GSM_COMPACT:
0492         result = QStringLiteral("network-mobile-%1");
0493         break;
0494     case MM_MODEM_ACCESS_TECHNOLOGY_GPRS:
0495         result = QStringLiteral("network-mobile-%1-gprs");
0496         break;
0497     case MM_MODEM_ACCESS_TECHNOLOGY_EDGE:
0498         result = QStringLiteral("network-mobile-%1-edge");
0499         break;
0500     case MM_MODEM_ACCESS_TECHNOLOGY_UMTS:
0501         result = QStringLiteral("network-mobile-%1-umts");
0502         break;
0503     case MM_MODEM_ACCESS_TECHNOLOGY_HSDPA:
0504         result = QStringLiteral("network-mobile-%1-hsdpa");
0505         break;
0506     case MM_MODEM_ACCESS_TECHNOLOGY_HSUPA:
0507         result = QStringLiteral("network-mobile-%1-hsupa");
0508         break;
0509     case MM_MODEM_ACCESS_TECHNOLOGY_HSPA:
0510     case MM_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS:
0511         result = QStringLiteral("network-mobile-%1-hspa");
0512         break;
0513     case MM_MODEM_ACCESS_TECHNOLOGY_LTE:
0514         result = QStringLiteral("network-mobile-%1-lte");
0515         break;
0516 #if MM_CHECK_VERSION(1, 14, 0)
0517     case MM_MODEM_ACCESS_TECHNOLOGY_5GNR:
0518         result = QStringLiteral("network-mobile-%1-5g");
0519         break;
0520 #endif
0521     default:
0522         result = QStringLiteral("network-mobile-%1");
0523         break;
0524     }
0525
0526     setConnectionIcon(QString(result).arg(strength));
0527     setConnectionTooltipIcon(QStringLiteral("phone"));
0528 }
0529
0530 void ConnectionIcon::setWirelessIcon(const NetworkManager::Device::Ptr &device, const QString &ssid)
0531 {
0532     NetworkManager::WirelessDevice::Ptr wirelessDevice = device.objectCast<NetworkManager::WirelessDevice>();
0533     if (device) {
0534         m_wirelessNetwork = wirelessDevice->findNetwork(ssid);
0535     } else {
0536         m_wirelessNetwork.clear();
0537     }
0538
0539     if (m_wirelessNetwork) {
0540         connect(m_wirelessNetwork.data(),
0541                 &NetworkManager::WirelessNetwork::signalStrengthChanged,
0542                 this,
0543                 &ConnectionIcon::setWirelessIconForSignalStrength,
0544                 Qt::UniqueConnection);
0545
0546         setWirelessIconForSignalStrength(m_wirelessNetwork->signalStrength());
0547     } else {
0548         setDisconnectedIcon();
0549     }
0550 }
0551
0552 void ConnectionIcon::setWirelessIconForSignalStrength(int strength)
0553 {
0554     int iconStrength = 100;
0555     if (strength == 0) {
0556         iconStrength = 0;
0557         setConnectionTooltipIcon(QStringLiteral("network-wireless-connected-00"));
0558     } else if (strength < 20) {
0559         iconStrength = 20;
0560         setConnectionTooltipIcon(QStringLiteral("network-wireless-connected-20"));
0561     } else if (strength < 40) {
0562         iconStrength = 40;
0563         setConnectionTooltipIcon(QStringLiteral("network-wireless-connected-40"));
0564     } else if (strength < 60) {
0565         iconStrength = 60;
0566         setConnectionTooltipIcon(QStringLiteral("network-wireless-connected-60"));
0567     } else if (strength < 80) {
0568         iconStrength = 80;
0569         setConnectionTooltipIcon(QStringLiteral("network-wireless-connected-80"));
0570     } else if (strength < 100) {
0571         setConnectionTooltipIcon(QStringLiteral("network-wireless-connected-100"));
0572     }
0573
0574     const QString icon = QStringLiteral("network-wireless-%1").arg(iconStrength);
0575
0576     setConnectionIcon(icon);
0577 }
0578
0579 void ConnectionIcon::setConnecting(bool connecting)
0580 {
0581     if (connecting != m_connecting) {
0582         m_connecting = connecting;
0583         Q_EMIT connectingChanged(m_connecting);
0584     }
0585 }
0586
0587 void ConnectionIcon::setConnectionIcon(const QString &icon)
0588 {
0589     if (icon != m_connectionIcon) {
0590         m_connectionIcon = icon;
0591         Q_EMIT connectionIconChanged(connectionIcon());
0592     }
0593 }
0594
0595 void ConnectionIcon::setConnectionTooltipIcon(const QString &icon)
0596 {
0597     if (icon != m_connectionTooltipIcon) {
0598         m_connectionTooltipIcon = icon;
0599         Q_EMIT connectionTooltipIconChanged(m_connectionTooltipIcon);
0600     }
0601 }
0602
0603 void ConnectionIcon::setVpn(bool vpn)
0604 {
0605     if (m_vpn != vpn) {
0606         m_vpn = vpn;
0607         Q_EMIT connectionIconChanged(connectionIcon());
0608     }
0609 }
0610
0611 void ConnectionIcon::setLimited(bool limited)
0612 {
0613     if (m_limited != limited) {
0614         m_limited = limited;
0615         Q_EMIT connectionIconChanged(connectionIcon());
0616     }
0617 }