Bearer management changes from Qt Mobility (fca9891).

fca98911b75ce12e70d93cfc2932a9759758a605

2 files changed, 136 insertions, 66 deletions

diff --git a/src/plugins/bearer/corewlan/qcorewlanengine.h b/src/plugins/bearer/corewlan/qcorewlanengine.h
index 044b433..cfd89e4 100644
--- a/src/plugins/bearer/corewlan/qcorewlanengine.h
+++ b/src/plugins/bearer/corewlan/qcorewlanengine.h
@@ -46,6 +46,7 @@
 
 #include <QMap>
 #include <QTimer>
+#include <SystemConfiguration/SystemConfiguration.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -91,6 +92,11 @@ private:
     bool isKnownSsid(const QString &interfaceName, const QString &ssid);
     QList<QNetworkConfigurationPrivate *> foundConfigurations;
 
+    SCDynamicStoreRef storeSession;
+    CFRunLoopSourceRef runloopSource;
+
+    void startNetworkChangeLoop();
+
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/bearer/corewlan/qcorewlanengine.mm b/src/plugins/bearer/corewlan/qcorewlanengine.mm
index a5384d1..4ab4d88 100644
--- a/src/plugins/bearer/corewlan/qcorewlanengine.mm
+++ b/src/plugins/bearer/corewlan/qcorewlanengine.mm
@@ -105,12 +105,23 @@ static QString qGetInterfaceType(const QString &interfaceString)
     return networkInterfaces.value(interfaceString, QLatin1String("Unknown"));
 }
 
+void networkChangeCallback(SCDynamicStoreRef/* store*/, CFArrayRef changedKeys, void *info)
+{
+    for ( long i = 0; i < CFArrayGetCount(changedKeys); i++) {
+
+        CFStringRef changed = (CFStringRef)CFArrayGetValueAtIndex(changedKeys, i);
+        if( cfstringRefToQstring(changed).contains("/Network/Global/IPv4")) {
+            QCoreWlanEngine* wlanEngine = static_cast<QCoreWlanEngine*>(info);
+            wlanEngine->requestUpdate();
+        }
+    }
+    return;
+}
+
 QCoreWlanEngine::QCoreWlanEngine(QObject *parent)
 :   QBearerEngineImpl(parent)
 {
-    connect(&pollTimer, SIGNAL(timeout()), this, SLOT(doRequestUpdate()));
-    pollTimer.setInterval(10000);
-    doRequestUpdate();
+    startNetworkChangeLoop();
 }
 
 QCoreWlanEngine::~QCoreWlanEngine()
@@ -150,7 +161,6 @@ void QCoreWlanEngine::connectToId(const QString &id)
         NSEnumerator *enumerator = [remNets objectEnumerator];
         CWWirelessProfile *wProfile;
         NSUInteger index=0;
-        CWNetwork *apNetwork;
         NSDictionary *parametersDict;
         NSArray* apArray;
 
@@ -179,26 +189,24 @@ void QCoreWlanEngine::connectToId(const QString &id)
                 if(!err) {
 
                     for(uint row=0; row < [apArray count]; row++ ) {
-                        apNetwork = [apArray objectAtIndex:row];
+                        CWNetwork *apNetwork = [apArray objectAtIndex:row];
                         if([[apNetwork ssid] compare:[wProfile ssid]] == NSOrderedSame) {
 
                             bool result = [wifiInterface associateToNetwork: apNetwork parameters:[NSDictionary dictionaryWithDictionary:params] error:&err];
 
                             if(!result) {
-                                qWarning() <<"ERROR"<< nsstringToQString([err localizedDescription ]);
                                 emit connectionError(id, ConnectError);
                             } else {
-                                [apNetwork release];
                                 [autoreleasepool release];
                                 return;
                             }
                         }
+                        [apNetwork release];
                     }
                 }
             }
             index++;
         }
-        [apNetwork release];
 
         emit connectionError(id, InterfaceLookupError);
 #endif
@@ -350,81 +358,83 @@ QStringList QCoreWlanEngine::scanForSsids(const QString &interfaceName)
     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
 
     CWInterface *currentInterface = [CWInterface interfaceWithName:qstringToNSString(interfaceName)];
-    NSError *err = nil;
-    NSDictionary *parametersDict = nil;
-    NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];
+    if([currentInterface power]) {
+        NSError *err = nil;
+        NSDictionary *parametersDict = nil;
+        NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];
 
-    CWNetwork *apNetwork;
-    if (!err) {
-        for(uint row=0; row < [apArray count]; row++ ) {
-            NSAutoreleasePool *looppool = [[NSAutoreleasePool alloc] init];
+        CWNetwork *apNetwork;
+        if (!err) {
+            for(uint row=0; row < [apArray count]; row++ ) {
+                NSAutoreleasePool *looppool = [[NSAutoreleasePool alloc] init];
 
-            apNetwork = [apArray objectAtIndex:row];
+                apNetwork = [apArray objectAtIndex:row];
 
-            const QString networkSsid = nsstringToQString([apNetwork ssid]);
+                const QString networkSsid = nsstringToQString([apNetwork ssid]);
 
-            const QString id = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));
-            found.append(id);
+                const QString id = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));
+                found.append(id);
 
-            QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
+                QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
 
-            if ([currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
-                if (networkSsid == nsstringToQString([currentInterface ssid]))
-                    state = QNetworkConfiguration::Active;
-            } else {
-                if (isKnownSsid(interfaceName, networkSsid))
-                    state = QNetworkConfiguration::Discovered;
-                else
-                    state = QNetworkConfiguration::Defined;
-            }
+                if ([currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
+                    if (networkSsid == nsstringToQString([currentInterface ssid]))
+                        state = QNetworkConfiguration::Active;
+                } else {
+                    if (isKnownSsid(interfaceName, networkSsid))
+                        state = QNetworkConfiguration::Discovered;
+                    else
+                        state = QNetworkConfiguration::Defined;
+                }
 
-            if (accessPointConfigurations.contains(id)) {
-                QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+                if (accessPointConfigurations.contains(id)) {
+                    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
 
-                bool changed = false;
+                    bool changed = false;
 
-                if (!ptr->isValid) {
-                    ptr->isValid = true;
-                    changed = true;
-                }
+                    if (!ptr->isValid) {
+                        ptr->isValid = true;
+                        changed = true;
+                    }
 
-                if (ptr->name != networkSsid) {
-                    ptr->name = networkSsid;
-                    changed = true;
-                }
+                    if (ptr->name != networkSsid) {
+                        ptr->name = networkSsid;
+                        changed = true;
+                    }
 
-                if (ptr->id != id) {
-                    ptr->id = id;
-                    changed = true;
-                }
+                    if (ptr->id != id) {
+                        ptr->id = id;
+                        changed = true;
+                    }
 
-                if (ptr->state != state) {
-                    ptr->state = state;
-                    changed = true;
-                }
+                    if (ptr->state != state) {
+                        ptr->state = state;
+                        changed = true;
+                    }
 
-                if (changed)
-                    emit configurationChanged(ptr);
-            } else {
-                QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
+                    if (changed)
+                        emit configurationChanged(ptr);
+                } else {
+                    QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
 
-                ptr->name = networkSsid;
-                ptr->isValid = true;
-                ptr->id = id;
-                ptr->state = state;
-                ptr->type = QNetworkConfiguration::InternetAccessPoint;
-                ptr->bearer = QLatin1String("WLAN");
+                    ptr->name = networkSsid;
+                    ptr->isValid = true;
+                    ptr->id = id;
+                    ptr->state = state;
+                    ptr->type = QNetworkConfiguration::InternetAccessPoint;
+                    ptr->bearer = QLatin1String("WLAN");
 
-                accessPointConfigurations.insert(id, ptr);
-                configurationInterface.insert(id, interfaceName);
+                    accessPointConfigurations.insert(id, ptr);
+                    configurationInterface.insert(id, interfaceName);
 
-                emit configurationAdded(ptr);
+                    emit configurationAdded(ptr);
+                }
+                [looppool release];
             }
-            [looppool release];
-        }
-    } else {
-        qWarning() << "ERROR scanning for ssids" << nsstringToQString([err localizedDescription])
-                <<nsstringToQString([err domain]);
+        } /*else {
+            qWarning() << "ERROR scanning for ssids" << nsstringToQString([err localizedDescription])
+                    <<nsstringToQString([err domain]);
+        }*/
     }
 
     [autoreleasepool drain];
@@ -540,6 +550,60 @@ QNetworkConfigurationManager::Capabilities QCoreWlanEngine::capabilities() const
     return QNetworkConfigurationManager::ForcedRoaming;
 }
 
+void QCoreWlanEngine::startNetworkChangeLoop()
+{
+    storeSession = NULL;
+
+    SCDynamicStoreContext dynStoreContext = { 0, this/*(void *)storeSession*/, NULL, NULL, NULL };
+    storeSession = SCDynamicStoreCreate(NULL,
+                                 CFSTR("networkChangeCallback"),
+                                 networkChangeCallback,
+                                 &dynStoreContext);
+    if (!storeSession ) {
+        qWarning() << "could not open dynamic store: error:" << SCErrorString(SCError());
+        return;
+    }
+
+    CFMutableArrayRef notificationKeys;
+    notificationKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
+    CFMutableArrayRef patternsArray;
+    patternsArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
+
+    CFStringRef storeKey;
+    storeKey = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
+                                                     kSCDynamicStoreDomainState,
+                                                     kSCEntNetIPv4);
+    CFArrayAppendValue(notificationKeys, storeKey);
+    CFRelease(storeKey);
+
+    storeKey = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
+                                                      kSCDynamicStoreDomainState,
+                                                      kSCCompAnyRegex,
+                                                      kSCEntNetIPv4);
+    CFArrayAppendValue(patternsArray, storeKey);
+    CFRelease(storeKey);
+
+    if (!SCDynamicStoreSetNotificationKeys(storeSession , notificationKeys, patternsArray)) {
+        qWarning() << "register notification error:"<< SCErrorString(SCError());
+        CFRelease(storeSession );
+        CFRelease(notificationKeys);
+        CFRelease(patternsArray);
+        return;
+    }
+    CFRelease(notificationKeys);
+    CFRelease(patternsArray);
+
+    runloopSource = SCDynamicStoreCreateRunLoopSource(NULL, storeSession , 0);
+    if (!runloopSource) {
+        qWarning() << "runloop source error:"<< SCErrorString(SCError());
+        CFRelease(storeSession );
+        return;
+    }
+
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), runloopSource, kCFRunLoopDefaultMode);
+    return;
+}
+
 QNetworkSessionPrivate *QCoreWlanEngine::createSessionBackend()
 {
     return new QNetworkSessionPrivateImpl;