Ticket #46536: QtBearer-networkmanager-make-sure-to-set-flag-Active.patch

File QtBearer-networkmanager-make-sure-to-set-flag-Active.patch, 22.6 KB (added by RJVB (René Bertin), 10 years ago)

  • qtbase/src/plugins/bearer/linux_common/qofonoservice_linux.cpp 

    From dedb8c1c928edbbb4408a0c5889353b142b20d1c Mon Sep 17 00:00:00 2001
From: Lorn Potter <lorn.potter@gmail.com>
Date: Thu, 13 Nov 2014 13:06:49 +1000
Subject: [PATCH] QtBearer networkmanager make sure to set flag Active

Also, no need to create objects to get properties, when the properties
can be had for free.

Make plugin more robust to network-manager or ofono crashes

Change-Id: Ibadb46bd51aa27f130f8d245e8c50aa7bff5f9c8
---
 .../bearer/linux_common/qofonoservice_linux.cpp    |  12 +
 .../bearer/linux_common/qofonoservice_linux_p.h    |   2 +
 src/plugins/bearer/networkmanager/main.cpp         |   5 +-
 .../networkmanager/qnetworkmanagerengine.cpp       | 310 ++++++++++++++-------
 .../bearer/networkmanager/qnetworkmanagerengine.h  |  13 +
 .../networkmanager/qnetworkmanagerservice.cpp      |  22 ++
 .../bearer/networkmanager/qnetworkmanagerservice.h |   2 +
 7 files changed, 263 insertions(+), 103 deletions(-)
     
    269269    return contextList;
    270270}
    271271
     272PathPropertiesList QOfonoDataConnectionManagerInterface::contextsWithProperties()
     273{
     274    if (contextListProperties.isEmpty()) {
     275        QDBusPendingReply<PathPropertiesList > reply = call(QLatin1String("GetContexts"));
     276        reply.waitForFinished();
     277        if (!reply.isError()) {
     278            contextListProperties = reply.value();
     279        }
     280    }
     281    return contextListProperties;
     282}
     283
    272284bool QOfonoDataConnectionManagerInterface::roamingAllowed()
    273285{
    274286    QVariant var = getProperty(QStringLiteral("RoamingAllowed"));

  • qtbase/src/plugins/bearer/linux_common/qofonoservice_linux_p.h

     
    153153    ~QOfonoDataConnectionManagerInterface();
    154154
    155155    QStringList contexts();
     156    PathPropertiesList contextsWithProperties();
    156157    bool roamingAllowed();
    157158    QVariant getProperty(const QString &);
    158159    QString bearer();
    … …  
    162163    QVariantMap getProperties();
    163164    QVariantMap propertiesMap;
    164165    QStringList contextList;
     166    PathPropertiesList contextListProperties;
    165167private slots:
    166168    void propertyChanged(const QString &, const QDBusVariant &value);
    167169};

  • qtbase/src/plugins/bearer/networkmanager/main.cpp

     
    6666{
    6767    if (key == QLatin1String("networkmanager")) {
    6868        QNetworkManagerEngine *engine = new QNetworkManagerEngine;
    69         if (engine->networkManagerAvailable())
    70             return engine;
    71         else
    72             delete engine;
     69        return engine;
    7370    }
    7471
    7572    return 0;

  • qtbase/src/plugins/bearer/networkmanager/qnetworkmanagerengine.cpp

     
    5656
    5757QNetworkManagerEngine::QNetworkManagerEngine(QObject *parent)
    5858:   QBearerEngineImpl(parent),
    59     managerInterface(new QNetworkManagerInterface(this)),
    60     systemSettings(new QNetworkManagerSettings(NM_DBUS_SERVICE, this)),
    61     ofonoManager(new QOfonoManagerInterface(this))
     59    managerInterface(NULL),
     60    systemSettings(NULL),
     61    ofonoManager(NULL),
     62    nmAvailable(false)
    6263{
    63 
    64     if (!managerInterface->isValid())
    65         return;
    66 
    6764    qDBusRegisterMetaType<QNmSettingsMap>();
    6865
    69     connect(managerInterface, SIGNAL(deviceAdded(QDBusObjectPath)),
    70             this, SLOT(deviceAdded(QDBusObjectPath)));
    71     connect(managerInterface, SIGNAL(deviceRemoved(QDBusObjectPath)),
    72             this, SLOT(deviceRemoved(QDBusObjectPath)));
    73     connect(managerInterface, SIGNAL(activationFinished(QDBusPendingCallWatcher*)),
    74             this, SLOT(activationFinished(QDBusPendingCallWatcher*)));
    75     connect(managerInterface, SIGNAL(propertiesChanged(QMap<QString,QVariant>)),
    76             this, SLOT(interfacePropertiesChanged(QMap<QString,QVariant>)));
    77     managerInterface->setConnections();
     66    nmWatcher = new QDBusServiceWatcher(NM_DBUS_SERVICE,QDBusConnection::systemBus(),
     67            QDBusServiceWatcher::WatchForRegistration |
     68            QDBusServiceWatcher::WatchForUnregistration, this);
     69    connect(nmWatcher, SIGNAL(serviceRegistered(QString)),
     70            this, SLOT(nmRegistered(QString)));
     71    connect(nmWatcher, SIGNAL(serviceUnregistered(QString)),
     72            this, SLOT(nmUnRegistered(QString)));
     73
     74    ofonoWatcher = new QDBusServiceWatcher("org.ofono",QDBusConnection::systemBus(),
     75            QDBusServiceWatcher::WatchForRegistration |
     76            QDBusServiceWatcher::WatchForUnregistration, this);
     77    connect(ofonoWatcher, SIGNAL(serviceRegistered(QString)),
     78            this, SLOT(ofonoRegistered(QString)));
     79    connect(ofonoWatcher, SIGNAL(serviceUnregistered(QString)),
     80            this, SLOT(ofonoUnRegistered(QString)));
    7881
    79     connect(systemSettings, SIGNAL(newConnection(QDBusObjectPath)),
    80             this, SLOT(newConnection(QDBusObjectPath)));
    81     systemSettings->setConnections();
     82    if (QDBusConnection::systemBus().interface()->isServiceRegistered("org.ofono"))
     83        ofonoRegistered();
     84
     85    if (QDBusConnection::systemBus().interface()->isServiceRegistered(NM_DBUS_SERVICE))
     86        nmRegistered();
    8287}
    8388
    8489QNetworkManagerEngine::~QNetworkManagerEngine()
    … …  
    105110
    106111void QNetworkManagerEngine::initialize()
    107112{
    108     QMutexLocker locker(&mutex);
     113    if (nmAvailable)
     114        setupConfigurations();
     115}
    109116
    110     if (ofonoManager->isValid()) {
    111         Q_FOREACH (const QString &modem, ofonoManager->getModems()) {
    112             QOfonoDataConnectionManagerInterface *ofonoContextManager
    113                     = new QOfonoDataConnectionManagerInterface(modem,this);
    114             ofonoContextManagers.insert(modem, ofonoContextManager);
    115         }
    116     }
     117void QNetworkManagerEngine::setupConfigurations()
     118{
     119    QMutexLocker locker(&mutex);
    117120    // Get active connections.
    118121    foreach (const QDBusObjectPath &acPath, managerInterface->activeConnections()) {
    119122
    … …  
    151154
    152155bool QNetworkManagerEngine::networkManagerAvailable() const
    153156{
    154     return managerInterface->isValid();
     157    return nmAvailable;
    155158}
    156159
    157160QString QNetworkManagerEngine::getInterfaceFromId(const QString &settingsPath)
    … …  
    180183    const QString settingsPath = connection->connectionInterface()->path();
    181184    QString specificPath = configuredAccessPoints.key(settingsPath);
    182185
     186    if (isConnectionActive(settingsPath))
     187        return;
     188
    183189    QHashIterator<QString, QNetworkManagerInterfaceDevice*> i(interfaceDevices);
    184190    while (i.hasNext()) {
    185191        i.next();
    … …  
    229235
    230236void QNetworkManagerEngine::requestUpdate()
    231237{
    232     if (managerInterface->wirelessEnabled()) {
     238    if (managerInterface && managerInterface->wirelessEnabled()) {
    233239        QHashIterator<QString, QNetworkManagerInterfaceDeviceWireless *> i(wirelessDevices);
    234240        while (i.hasNext()) {
    235241            i.next();
    … …  
    282288                if (ptr) {
    283289                    ptr->mutex.lock();
    284290                    if (activeConnection->state() == NM_ACTIVE_CONNECTION_STATE_ACTIVATED &&
    285                         ptr->state != QNetworkConfiguration::Active) {
    286                         ptr->state = QNetworkConfiguration::Active;
     291                            (ptr->state & QNetworkConfiguration::Active) != QNetworkConfiguration::Active) {
     292
     293                        ptr->state |= QNetworkConfiguration::Active;
    287294
    288295                        if (activeConnectionsList.value(id) && activeConnectionsList.value(id)->defaultRoute()
    289296                                && managerInterface->state() < QNetworkManagerInterface::NM_STATE_CONNECTED_GLOBAL) {
    … …  
    339346
    340347    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
    341348    if (ptr) {
    342         ptr->mutex.lock();
    343         if (properties.value("State").toUInt() == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {
    344             QStringList devices = activeConnection->devices();
    345             if (!devices.isEmpty()) {
    346                 QNetworkManagerInterfaceDevice device(devices.at(0),this);
    347                 connectionInterfaces.insert(id,device.networkInterface());
    348             }
    349 
    350             ptr->state |= QNetworkConfiguration::Active;
    351             ptr->mutex.unlock();
    352 
    353             locker.unlock();
    354             emit configurationChanged(ptr);
    355             locker.relock();
    356         } else {
    357             connectionInterfaces.remove(id);
    358             ptr->mutex.unlock();
     349        if (properties.contains(QStringLiteral("State"))) {
     350            ptr->mutex.lock();
     351            if (properties.value("State").toUInt() == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {
     352                QStringList devices = activeConnection->devices();
     353                if (!devices.isEmpty()) {
     354                    QNetworkManagerInterfaceDevice device(devices.at(0),this);
     355                    connectionInterfaces.insert(id,device.networkInterface());
     356                }
     357
     358                ptr->state |= QNetworkConfiguration::Active;
     359                ptr->mutex.unlock();
     360
     361                locker.unlock();
     362                emit configurationChanged(ptr);
     363                locker.relock();
     364            } else {
     365                connectionInterfaces.remove(id);
     366                ptr->mutex.unlock();
     367            }
    359368        }
    360369    }
    361370}
    … …  
    403412        connect(wirelessDevice,SIGNAL(scanDone()),this,SLOT(scanFinished()));
    404413        wirelessDevice->setConnections();
    405414
    406         foreach (const QDBusObjectPath &apPath, wirelessDevice->getAccessPoints())
    407             newAccessPoint(apPath.path());
    408 
    409415        wirelessDevices.insert(path.path(), wirelessDevice);
    410416    }
    411417
    … …  
    518524        parseConnection(settingsPath, connection->getSettings());
    519525
    520526    // Check if connection is active.
    521     QHashIterator<QString, QNetworkManagerConnectionActive*> i(activeConnectionsList);
    522     while (i.hasNext()) {
    523         i.next();
    524         if (i.value()->connection().path() == settingsPath) {
    525             cpPriv->state |= QNetworkConfiguration::Active;
    526             break;
    527         }
    528     }
     527    if (isConnectionActive(settingsPath))
     528        cpPriv->state |= QNetworkConfiguration::Active;
     529
    529530    if (deviceType == DEVICE_TYPE_ETHERNET) {
    530531        QHashIterator<QString, QNetworkManagerInterfaceDevice*> i(interfaceDevices);
    531532        while (i.hasNext()) {
    … …  
    539540             }
    540541         }
    541542     }
     543
    542544    QNetworkConfigurationPrivatePointer ptr(cpPriv);
    543545    accessPointConfigurations.insert(ptr->id, ptr);
    544546    locker.unlock();
    545547    emit configurationAdded(ptr);
    546548}
    547549
     550bool QNetworkManagerEngine::isConnectionActive(const QString &settingsPath)
     551{
     552    QHashIterator<QString, QNetworkManagerConnectionActive*> i(activeConnectionsList);
     553    while (i.hasNext()) {
     554        i.next();
     555        if (i.value()->connection().path() == settingsPath) {
     556            if (i.value()->state() == NM_ACTIVE_CONNECTION_STATE_ACTIVATING
     557                    || i.value()->state() == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {
     558                return true;
     559            } else {
     560                break;
     561            }
     562        }
     563    }
     564
     565    QNetworkManagerSettingsConnection *settingsConnection = connectionFromId(settingsPath);
     566    if (settingsConnection->getType() == DEVICE_TYPE_MODEM) {
     567        return isActiveContext(settingsConnection->connectionInterface()->path());
     568    }
     569
     570    return false;
     571}
     572
    548573void QNetworkManagerEngine::removeConnection(const QString &path)
    549574{
    550575    QMutexLocker locker(&mutex);
    … …  
    652677void QNetworkManagerEngine::newAccessPoint(const QString &path)
    653678{
    654679    QMutexLocker locker(&mutex);
    655 
    656680    QNetworkManagerInterfaceAccessPoint *accessPoint =
    657681        new QNetworkManagerInterfaceAccessPoint(path,this);
    658682
    … …  
    683707                ptr->mutex.lock();
    684708                QNetworkConfiguration::StateFlags flag = QNetworkConfiguration::Defined;
    685709                ptr->state = (flag | QNetworkConfiguration::Discovered);
     710
     711                if (isConnectionActive(settingsPath))
     712                    ptr->state = (flag | QNetworkConfiguration::Active);
    686713                ptr->mutex.unlock();
    687714
    688715                locker.unlock();
    … …  
    762789    QMutexLocker locker(&mutex);
    763790    QNetworkConfigurationPrivate *cpPriv = new QNetworkConfigurationPrivate;
    764791    cpPriv->name = map.value("connection").value("id").toString();
    765 
    766792    cpPriv->isValid = true;
    767793    cpPriv->id = settingsPath;
    768794    cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
    … …  
    811837        }
    812838    } else if (connectionType == QLatin1String("gsm")) {
    813839
    814         const QString contextPath = map.value("connection").value("id").toString();
    815         cpPriv->name = contextName(contextPath);
    816         cpPriv->bearerType = currentBearerType(contextPath);
    817 
    818         if (map.value("connection").contains("timestamp")) {
    819             cpPriv->state |= QNetworkConfiguration::Discovered;
     840        const QString connectionPath = map.value("connection").value("id").toString();
     841        cpPriv->name = contextName(connectionPath);
     842        cpPriv->bearerType = currentBearerType(connectionPath);
     843
     844        if (ofonoManager && ofonoManager->isValid()) {
     845            const QString contextPart = connectionPath.section('/', -1);
     846            QHashIterator<QString, QOfonoDataConnectionManagerInterface*> i(ofonoContextManagers);
     847            while (i.hasNext()) {
     848                i.next();
     849                const QString path = i.key() +"/"+contextPart;
     850                if (isActiveContext(path)) {
     851                    cpPriv->state |= QNetworkConfiguration::Active;
     852                    break;
     853                }
     854            }
    820855        }
    821856    }
    822857
    823858    return cpPriv;
    824859}
    825860
     861bool QNetworkManagerEngine::isActiveContext(const QString &contextPath)
     862{
     863    if (ofonoManager && ofonoManager->isValid()) {
     864        const QString contextPart = contextPath.section('/', -1);
     865        QHashIterator<QString, QOfonoDataConnectionManagerInterface*> i(ofonoContextManagers);
     866        while (i.hasNext()) {
     867            i.next();
     868            PathPropertiesList list = i.value()->contextsWithProperties();
     869            for (int i = 0; i < list.size(); ++i) {
     870                if (list.at(i).path.path().contains(contextPart)) {
     871                    return list.at(i).properties.value(QStringLiteral("Active")).toBool();
     872
     873                }
     874            }
     875        }
     876    }
     877    return false;
     878}
     879
    826880QNetworkManagerSettingsConnection *QNetworkManagerEngine::connectionFromId(const QString &id) const
    827881{
    828882    for (int i = 0; i < connections.count(); ++i) {
    … …  
    9671021
    9681022QNetworkConfiguration::BearerType QNetworkManagerEngine::currentBearerType(const QString &id)
    9691023{
    970     if (ofonoManager->isValid()) {
    971         QString contextPart = id.section('/', -1);
     1024    QString contextPart = id.section('/', -1);
     1025    QHashIterator<QString, QOfonoDataConnectionManagerInterface*> i(ofonoContextManagers);
     1026    while (i.hasNext()) {
     1027        i.next();
     1028        QString contextPath = i.key() +"/"+contextPart;
    9721029
    973         QHashIterator<QString, QOfonoDataConnectionManagerInterface*> i(ofonoContextManagers);
    974         while (i.hasNext()) {
    975             i.next();
    976             QString contextPath = i.key() +"/"+contextPart;
    977             if (i.value()->contexts().contains(contextPath)) {
     1030        if (i.value()->contexts().contains(contextPath)) {
    9781031
    979                 QString bearer = i.value()->bearer();
    980                 if (bearer == QStringLiteral("gsm")) {
    981                     return QNetworkConfiguration::Bearer2G;
    982                 } else if (bearer == QStringLiteral("edge")) {
    983                     return QNetworkConfiguration::Bearer2G;
    984                 } else if (bearer == QStringLiteral("umts")) {
    985                     return QNetworkConfiguration::BearerWCDMA;
    986                 } else if (bearer == QStringLiteral("hspa")
    987                            || bearer == QStringLiteral("hsdpa")
    988                            || bearer == QStringLiteral("hsupa")) {
    989                     return QNetworkConfiguration::BearerHSPA;
    990                 } else if (bearer == QStringLiteral("lte")) {
    991                     return QNetworkConfiguration::BearerLTE;
    992                 }
     1032            QString bearer = i.value()->bearer();
     1033
     1034            if (bearer == QStringLiteral("gsm")) {
     1035                return QNetworkConfiguration::Bearer2G;
     1036            } else if (bearer == QStringLiteral("edge")) {
     1037                return QNetworkConfiguration::Bearer2G;
     1038            } else if (bearer == QStringLiteral("umts")) {
     1039                return QNetworkConfiguration::BearerWCDMA;
     1040            } else if (bearer == QStringLiteral("hspa")
     1041                       || bearer == QStringLiteral("hsdpa")
     1042                       || bearer == QStringLiteral("hsupa")) {
     1043                return QNetworkConfiguration::BearerHSPA;
     1044            } else if (bearer == QStringLiteral("lte")) {
     1045                return QNetworkConfiguration::BearerLTE;
    9931046            }
    9941047        }
    9951048    }
     1049
    9961050    return QNetworkConfiguration::BearerUnknown;
    9971051}
    9981052
    9991053QString QNetworkManagerEngine::contextName(const QString &path)
    10001054{
    1001     if (ofonoManager->isValid()) {
    1002         QString contextPart = path.section('/', -1);
    1003         QHashIterator<QString, QOfonoDataConnectionManagerInterface*> i(ofonoContextManagers);
    1004         while (i.hasNext()) {
    1005             i.next();
    1006             Q_FOREACH (const QString &oContext, i.value()->contexts()) {
    1007                 if (oContext.contains(contextPart)) {
    1008                     QOfonoConnectionContextInterface contextInterface(oContext,this);
    1009                     return contextInterface.name();
    1010                 }
     1055    QString contextPart = path.section('/', -1);
     1056    QHashIterator<QString, QOfonoDataConnectionManagerInterface*> i(ofonoContextManagers);
     1057    while (i.hasNext()) {
     1058        i.next();
     1059        PathPropertiesList list = i.value()->contextsWithProperties();
     1060        for (int i = 0; i < list.size(); ++i) {
     1061            if (list.at(i).path.path().contains(contextPart)) {
     1062                return list.at(i).properties.value(QStringLiteral("Name")).toString();
    10111063            }
    10121064        }
    10131065    }
    10141066    return path;
    10151067}
    10161068
     1069void QNetworkManagerEngine::nmRegistered(const QString &)
     1070{
     1071    if (ofonoManager) {
     1072        delete ofonoManager;
     1073        ofonoManager = NULL;
     1074    }
     1075    managerInterface = new QNetworkManagerInterface(this);
     1076    systemSettings = new QNetworkManagerSettings(NM_DBUS_SERVICE, this);
     1077
     1078    connect(managerInterface, SIGNAL(deviceAdded(QDBusObjectPath)),
     1079            this, SLOT(deviceAdded(QDBusObjectPath)));
     1080    connect(managerInterface, SIGNAL(deviceRemoved(QDBusObjectPath)),
     1081            this, SLOT(deviceRemoved(QDBusObjectPath)));
     1082    connect(managerInterface, SIGNAL(activationFinished(QDBusPendingCallWatcher*)),
     1083            this, SLOT(activationFinished(QDBusPendingCallWatcher*)));
     1084    connect(managerInterface, SIGNAL(propertiesChanged(QMap<QString,QVariant>)),
     1085            this, SLOT(interfacePropertiesChanged(QMap<QString,QVariant>)));
     1086    managerInterface->setConnections();
     1087
     1088    connect(systemSettings, SIGNAL(newConnection(QDBusObjectPath)),
     1089            this, SLOT(newConnection(QDBusObjectPath)));
     1090    systemSettings->setConnections();
     1091    nmAvailable = true;
     1092
     1093    setupConfigurations();
     1094}
     1095
     1096void QNetworkManagerEngine::nmUnRegistered(const QString &)
     1097{
     1098    if (systemSettings) {
     1099        delete systemSettings;
     1100        systemSettings = NULL;
     1101    }
     1102    if (managerInterface) {
     1103        delete managerInterface;
     1104        managerInterface = NULL;
     1105    }
     1106}
     1107
     1108void QNetworkManagerEngine::ofonoRegistered(const QString &)
     1109{
     1110    if (ofonoManager) {
     1111        delete ofonoManager;
     1112        ofonoManager = NULL;
     1113    }
     1114    ofonoManager = new QOfonoManagerInterface(this);
     1115    if (ofonoManager && ofonoManager->isValid()) {
     1116        Q_FOREACH (const QString &modem, ofonoManager->getModems()) {
     1117            QOfonoDataConnectionManagerInterface *ofonoContextManager
     1118                    = new QOfonoDataConnectionManagerInterface(modem,this);
     1119            ofonoContextManagers.insert(modem, ofonoContextManager);
     1120        }
     1121    }
     1122}
     1123
     1124void QNetworkManagerEngine::ofonoUnRegistered(const QString &)
     1125{
     1126    ofonoContextManagers.clear();
     1127}
     1128
    10171129QT_END_NAMESPACE
    10181130
    10191131#endif // QT_NO_DBUS

  • qtbase/src/plugins/bearer/networkmanager/qnetworkmanagerengine.h

     
    109109
    110110    void wiredCarrierChanged(bool);
    111111
     112    void nmRegistered(const QString &serviceName = QString());
     113    void nmUnRegistered(const QString &serviceName = QString());
     114
     115    void ofonoRegistered(const QString &serviceName = QString());
     116    void ofonoUnRegistered(const QString &serviceName = QString());
     117
    112118private:
    113119    QNetworkConfigurationPrivate *parseConnection(const QString &settingsPath,
    114120                                                  const QNmSettingsMap &map);
    … …  
    132138    QNetworkConfiguration::BearerType currentBearerType(const QString &id);
    133139    QString contextName(const QString &path);
    134140
     141    bool isConnectionActive(const QString &settingsPath);
     142    QDBusServiceWatcher *ofonoWatcher;
     143    QDBusServiceWatcher *nmWatcher;
     144
     145    bool isActiveContext(const QString &contextPath);
     146    bool nmAvailable;
     147    void setupConfigurations();
    135148};
    136149
    137150QT_END_NAMESPACE

  • qtbase/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp

     
    688688                                  QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
    689689                                  QLatin1String("PropertiesChanged"),
    690690                                  this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
     691
     692    QDBusPendingReply<QList<QDBusObjectPath> > reply
     693            = d->connectionInterface->asyncCall(QLatin1String("GetAccessPoints"));
     694
     695    QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(reply);
     696    connect(callWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
     697                     this, SLOT(accessPointsFinished(QDBusPendingCallWatcher*)));
     698
     699
    691700    d->valid = true;
    692701}
    693702
    … …  
    749758    return allOk;
    750759}
    751760
     761void QNetworkManagerInterfaceDeviceWireless::accessPointsFinished(QDBusPendingCallWatcher *watcher)
     762{
     763    QDBusPendingReply<QList<QDBusObjectPath> > reply(*watcher);
     764    watcher->deleteLater();
     765    if (!reply.isError()) {
     766        accessPointsList = reply.value();
     767    }
     768
     769    for (int i = 0; i < accessPointsList.size(); i++) {
     770        Q_EMIT accessPointAdded(accessPointsList.at(i).path());
     771    }
     772}
     773
    752774QDBusInterface *QNetworkManagerInterfaceDeviceWireless::connectionInterface() const
    753775{
    754776    return d->connectionInterface;

  • qtbase/src/plugins/bearer/networkmanager/qnetworkmanagerservice.h

     
    369369    void slotAccessPointAdded(QDBusObjectPath);
    370370    void slotAccessPointRemoved(QDBusObjectPath);
    371371
     372    void accessPointsFinished(QDBusPendingCallWatcher *watcher);
     373
    372374private:
    373375    QNetworkManagerInterfaceDeviceWirelessPrivate *d;
    374376    QVariantMap propertyMap;