17 files changed, 2565 insertions, 15 deletions
diff --git a/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview.cpp b/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview.cpp
index 0342c9f..9dcba60 100644
--- a/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview.cpp
@@ -612,7 +612,7 @@ QAction* QDeclarativeWebView::stopAction() const
 #endif // QT_NO_ACTION
 
 /*!
-    \qmlproperty real WebView::title
+    \qmlproperty string WebView::title
     This property holds the title of the web page currently viewed
 
     By default, this property contains an empty string.
diff --git a/src/corelib/tools/qlocale.cpp b/src/corelib/tools/qlocale.cpp
index a51ee81..6b1de5e 100644
--- a/src/corelib/tools/qlocale.cpp
+++ b/src/corelib/tools/qlocale.cpp
@@ -2096,6 +2096,7 @@ QDataStream &operator>>(QDataStream &ds, QLocale &l)
     \value Serbia
     \value SaintBarthelemy
     \value SaintMartin
+    \value LatinAmericaAndTheCaribbean
     \omitvalue LastCountry
 
     \sa country()
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index 9e8a128..ec26e81 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -2485,7 +2485,7 @@ extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wPa
             if (OkCommand)
                 QApplication::postEvent(widget, new QEvent(QEvent::OkRequest));
             if (CancelCommand)
-                QApplication::postEvent(widget, new QEvent(QEvent::Close));
+                widget->showMinimized();
             else
 #ifndef QT_NO_MENUBAR
                 QMenuBar::wceCommands(LOWORD(wParam));
diff --git a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
index 5dcf613..7a9dc70 100644
--- a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
+++ b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
@@ -196,7 +196,6 @@ static void cleanupCocoaApplicationDelegate()
             qAppInstance()->quit();
             startedQuit = false;
         }
-        return NSTerminateNow;
     }
 
     if (qtPrivate->threadData->eventLoops.size() == 0) {
diff --git a/src/gui/kernel/qguifunctions_wince.cpp b/src/gui/kernel/qguifunctions_wince.cpp
index f5004b0..377dfe3 100644
--- a/src/gui/kernel/qguifunctions_wince.cpp
+++ b/src/gui/kernel/qguifunctions_wince.cpp
@@ -76,6 +76,10 @@ struct AygSIPINFO
 #define SHIDIF_SIZEDLGFULLSCREEN 0x0004
 #endif
 
+#ifndef SHDB_HIDE
+#define SHDB_HIDE 0x0002
+#endif
+
 #ifndef SHFS_SHOWTASKBAR
 #define SHFS_SHOWTASKBAR 0x0001
 #endif
@@ -112,10 +116,12 @@ struct AygSIPINFO
 typedef BOOL (*AygInitDialog)(AygSHINITDLGINFO*);
 typedef BOOL (*AygFullScreen)(HWND, DWORD);
 typedef BOOL (*AygSHSipInfo)(UINT, UINT, PVOID, UINT);
+typedef BOOL (*AygSHDoneButton)(HWND, DWORD);
 
 static AygInitDialog ptrAygInitDialog = 0;
 static AygFullScreen ptrAygFullScreen = 0;
 static AygSHSipInfo  ptrAygSHSipInfo  = 0;
+static AygSHDoneButton ptrAygSHDoneButton = 0;
 static bool aygResolved = false;
 
 static void resolveAygLibs()
@@ -128,18 +134,10 @@ static void resolveAygLibs()
         ptrAygInitDialog = (AygInitDialog) ayglib.resolve("SHInitDialog");
         ptrAygFullScreen = (AygFullScreen) ayglib.resolve("SHFullScreen");
         ptrAygSHSipInfo  = (AygSHSipInfo)  ayglib.resolve("SHSipInfo");
+        ptrAygSHDoneButton = (AygSHDoneButton) ayglib.resolve("SHDoneButton");
     }
 }
 
-struct DIBINFO : public BITMAPINFO
-{
-    RGBQUAD arColors[255];
-
-    operator LPBITMAPINFO() { return (LPBITMAPINFO) this; }
-    operator LPBITMAPINFOHEADER() { return &bmiHeader; }
-    RGBQUAD* ColorTable() { return bmiColors; }
-};
-
 int qt_wince_GetDIBits(HDC /*hdc*/ , HBITMAP hSourceBitmap, uint, uint, LPVOID lpvBits, LPBITMAPINFO, uint)
 {
     if (!lpvBits) {
@@ -323,6 +321,8 @@ void qt_wince_maximize(QWidget *widget)
             shidi.dwFlags |= SHIDIF_CANCELBUTTON;
         if (widget->windowFlags() & Qt::WindowOkButtonHint)
             shidi.dwFlags |= SHIDIF_DONEBUTTON;
+        if (!(widget->windowFlags() & (Qt::WindowCancelButtonHint | Qt::WindowOkButtonHint)))
+            shidi.dwFlags |= SHIDIF_CANCELBUTTON;
         resolveAygLibs();
         if (ptrAygInitDialog)
             ptrAygInitDialog(&shidi);
@@ -334,6 +334,16 @@ void qt_wince_maximize(QWidget *widget)
     }
 }
 
+void qt_wince_unmaximize(QWidget *widget)
+{
+    if (ptrAygSHDoneButton && qt_wince_is_mobile()
+        && !(widget->windowFlags() & (Qt::WindowCancelButtonHint | Qt::WindowOkButtonHint)))
+    {
+        // Hide the [X] button, we've added in qt_wince_maximize.
+        ptrAygSHDoneButton(widget->winId(), SHDB_HIDE);
+    }
+}
+
 void qt_wince_minimize(HWND hwnd)
 {
 #ifdef Q_OS_WINCE_WM
diff --git a/src/gui/kernel/qwidget_win.cpp b/src/gui/kernel/qwidget_win.cpp
index 0f05c6b..23f57da 100644
--- a/src/gui/kernel/qwidget_win.cpp
+++ b/src/gui/kernel/qwidget_win.cpp
@@ -70,6 +70,7 @@
 #include "qguifunctions_wince.h"
 QT_USE_NAMESPACE
 extern void qt_wince_maximize(QWidget *widget);                          //defined in qguifunctions_wince.cpp
+extern void qt_wince_unmaximize(QWidget *widget);                        //defined in qguifunctions_wince.cpp
 extern void qt_wince_minimize(HWND hwnd);                                //defined in qguifunctions_wince.cpp
 extern void qt_wince_full_screen(HWND hwnd, bool fullScreen, UINT swpf); //defined in qguifunctions_wince.cpp
 extern bool qt_wince_is_mobile();                                        //defined in qguifunctions_wince.cpp
diff --git a/src/gui/kernel/qwidget_wince.cpp b/src/gui/kernel/qwidget_wince.cpp
index fc1e52c..76532ed 100644
--- a/src/gui/kernel/qwidget_wince.cpp
+++ b/src/gui/kernel/qwidget_wince.cpp
@@ -498,6 +498,7 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
                 int style = GetWindowLong(internalWinId(), GWL_STYLE) | WS_BORDER | WS_POPUP | WS_CAPTION;
                 SetWindowLong(internalWinId(), GWL_STYLE, style);
                 SetWindowLong(internalWinId(), GWL_EXSTYLE, GetWindowLong (internalWinId(), GWL_EXSTYLE) & ~ WS_EX_NODRAG);
+                qt_wince_unmaximize(this);
             }
             if (isVisible() && newstate & Qt::WindowMaximized)
                 qt_wince_maximize(this);
diff --git a/src/network/kernel/qnetworkproxy_mac.cpp b/src/network/kernel/qnetworkproxy_mac.cpp
index 1e22212..4139a7e 100644
--- a/src/network/kernel/qnetworkproxy_mac.cpp
+++ b/src/network/kernel/qnetworkproxy_mac.cpp
@@ -157,8 +157,10 @@ QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query)
         return result;          // failed
     }
 
-    if (isHostExcluded(dict, query.peerHostName()))
+    if (isHostExcluded(dict, query.peerHostName())) {
+        CFRelease(dict);
         return result;          // no proxy for this host
+    }
 
     // is there a PAC enabled? If so, use it first.
     CFNumberRef pacEnabled;
@@ -222,6 +224,7 @@ QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query)
             result << https;
     }
 
+    CFRelease(dict);
     return result;
 }
 
diff --git a/src/plugins/bearer/bearer.pro b/src/plugins/bearer/bearer.pro
index f95e8af..6d8f7f2 100644
--- a/src/plugins/bearer/bearer.pro
+++ b/src/plugins/bearer/bearer.pro
@@ -4,7 +4,8 @@ contains(QT_CONFIG, dbus) {
     contains(QT_CONFIG, icd) {
         SUBDIRS += icd
     } else {
-        SUBDIRS += networkmanager generic
+        SUBDIRS += generic
+        !mac:SUBDIRS += connman networkmanager 
     }
 }
 
diff --git a/src/plugins/bearer/connman/connman.pro b/src/plugins/bearer/connman/connman.pro
new file mode 100644
index 0000000..4be752b
--- /dev/null
+++ b/src/plugins/bearer/connman/connman.pro
@@ -0,0 +1,19 @@
+TARGET = qconnmanbearer
+include(../../qpluginbase.pri)
+
+QT = core network dbus
+
+HEADERS += qconnmanservice_linux_p.h \
+           qconnmanengine.h \
+           ../qnetworksession_impl.h \
+           ../qbearerengine_impl.h
+
+SOURCES += main.cpp \
+           qconnmanservice_linux.cpp \
+           qconnmanengine.cpp \
+           ../qnetworksession_impl.cpp
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
+
diff --git a/src/plugins/bearer/connman/main.cpp b/src/plugins/bearer/connman/main.cpp
new file mode 100644
index 0000000..d483cf0
--- /dev/null
+++ b/src/plugins/bearer/connman/main.cpp
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qconnmanengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+#ifndef QT_NO_BEARERMANAGEMENT
+#ifndef QT_NO_DBUS
+
+QT_BEGIN_NAMESPACE
+
+class QConnmanEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QConnmanEnginePlugin();
+    ~QConnmanEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QConnmanEnginePlugin::QConnmanEnginePlugin()
+{
+}
+
+QConnmanEnginePlugin::~QConnmanEnginePlugin()
+{
+}
+
+QStringList QConnmanEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("connman");
+}
+
+QBearerEngine *QConnmanEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("connman")) {
+        QConnmanEngine *engine = new QConnmanEngine;
+        if (engine->connmanAvailable())
+            return engine;
+        else
+            delete engine;
+    }
+    return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QConnmanEnginePlugin)
+Q_EXPORT_PLUGIN2(qconnmanbearer, QConnmanEnginePlugin)
+
+QT_END_NAMESPACE
+
+#endif
+#endif // QT_NO_BEARERMANAGEMENT
diff --git a/src/plugins/bearer/connman/qconnmanengine.cpp b/src/plugins/bearer/connman/qconnmanengine.cpp
new file mode 100644
index 0000000..8775623
--- /dev/null
+++ b/src/plugins/bearer/connman/qconnmanengine.cpp
@@ -0,0 +1,787 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qconnmanengine.h"
+#include "qconnmanservice_linux_p.h"
+#include "../qnetworksession_impl.h"
+
+#include <QtNetwork/private/qnetworkconfiguration_p.h>
+
+#include <QtNetwork/qnetworksession.h>
+
+#include <QtCore/qdebug.h>
+
+#include <QtDBus/QtDBus>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusReply>
+
+#ifndef QT_NO_BEARERMANAGEMENT
+#ifndef QT_NO_DBUS
+
+QT_BEGIN_NAMESPACE
+
+QConnmanEngine::QConnmanEngine(QObject *parent)
+:   QBearerEngineImpl(parent),
+    connmanManager(new QConnmanManagerInterface(this))
+{
+}
+
+QConnmanEngine::~QConnmanEngine()
+{
+}
+
+bool QConnmanEngine::connmanAvailable() const
+{
+    QMutexLocker locker(&mutex);
+    return connmanManager->isValid();
+}
+
+void QConnmanEngine::initialize()
+{
+    connect(connmanManager,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+            this,SLOT(propertyChangedContext(QString,QString,QDBusVariant)));
+
+    foreach(const QString techPath, connmanManager->getTechnologies()) {
+        QConnmanTechnologyInterface *tech;
+        tech = new QConnmanTechnologyInterface(techPath, this);
+
+        connect(tech,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                this,SLOT(technologyPropertyChangedContext(QString,QString,QDBusVariant)));
+
+        foreach(const QString devicePath,tech->getDevices()) {
+            QConnmanDeviceInterface *dev;
+            dev = new QConnmanDeviceInterface(devicePath);
+            if(!deviceMap.value(techPath).contains(devicePath)) {
+                connect(dev,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                        this,SLOT(devicePropertyChangedContext(QString,QString,QDBusVariant)));
+                deviceMap.insert(techPath,QStringList() << devicePath);
+                foreach(const QString network,dev->getNetworks()) {
+                    serviceNetworks.insert(getServiceForNetwork(network),network);
+                }
+            }
+        }
+    }
+
+    // Get current list of access points.
+    getConfigurations();
+}
+
+QList<QNetworkConfigurationPrivate *> QConnmanEngine::getConfigurations()
+{
+    QMutexLocker locker(&mutex);
+  //  foundConfigurations.clear();
+    getNetworkListing();
+    QList<QNetworkConfigurationPrivate *> fetchedConfigurations;
+    QNetworkConfigurationPrivate* cpPriv = 0;
+
+    for (int i = 0; i < foundConfigurations.count(); ++i) {
+        QNetworkConfigurationPrivate *config = new QNetworkConfigurationPrivate;
+        cpPriv = foundConfigurations.at(i);
+
+        config->name = cpPriv->name;
+        config->isValid = cpPriv->isValid;
+        config->id = cpPriv->id;
+        config->state = cpPriv->state;
+        config->type = cpPriv->type;
+        config->roamingSupported = cpPriv->roamingSupported;
+        config->purpose = cpPriv->purpose;
+        config->bearer = cpPriv->bearer;
+
+        fetchedConfigurations.append(config);
+    }
+    return fetchedConfigurations;
+//    return foundConfigurations;
+}
+
+void QConnmanEngine::getNetworkListing()
+{
+    QMutexLocker locker(&mutex);
+    QMapIterator<QString,QStringList> i(deviceMap);
+    while(i.hasNext()) {
+        i.next();
+        QConnmanDeviceInterface dev(i.value().at(0));
+        if(dev.isValid()) {
+            foreach(const QString network,dev.getNetworks()) {
+                addNetworkConfiguration(network);
+            }
+        }
+    }
+}
+
+
+
+void QConnmanEngine::doRequestUpdate()
+{
+    connmanManager->requestScan("");
+    getConfigurations();
+    emit updateCompleted();
+}
+
+QString QConnmanEngine::getInterfaceFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    return configInterfaces.value(id);
+}
+
+bool QConnmanEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    return accessPointConfigurations.contains(id);
+}
+
+QString QConnmanEngine::bearerName(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    QConnmanServiceInterface serv(serviceFromId(id));
+    QString connectionType = serv.getType();
+
+    if (connectionType == "ethernet")
+        return QLatin1String("Ethernet");
+    else if (connectionType == "wifi")
+        return QLatin1String("WLAN");
+    else if (connectionType == "cellular") {
+        QString mode = serv.getMode();
+        if(mode == "gprs" || mode == "edge") {
+            return QLatin1String("2G");
+        } else if(mode == "umts") {
+            return QLatin1String("WCDMA");
+        }
+    }
+    else if (connectionType == "wimax")
+        return QLatin1String("WIMAX");
+
+    return QString();
+}
+
+void QConnmanEngine::connectToId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    QConnmanConnectThread *thread;
+    thread = new QConnmanConnectThread(this);
+    thread->setServicePath(serviceFromId(id));
+    thread->setIdentifier(id);
+    connect(thread,SIGNAL(connectionError(QString,QBearerEngineImpl::ConnectionError)),
+            this,SIGNAL(connectionError(QString,QBearerEngineImpl::ConnectionError)));
+    thread->start();
+}
+
+void QConnmanEngine::disconnectFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    QConnmanServiceInterface serv(serviceFromId(id));
+    if(!serv.isValid()) {
+        emit connectionError(id, DisconnectionError);
+    } else {
+        serv.disconnect();
+    }
+}
+
+void QConnmanEngine::requestUpdate()
+{
+    QMutexLocker locker(&mutex);
+    QTimer::singleShot(0, this, SLOT(doRequestUpdate()));
+}
+
+QString QConnmanEngine::serviceFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    foreach(const QString service, serviceNetworks.keys()) {
+        if (id == QString::number(qHash(service)))
+            return service;
+    }
+
+    return QString();
+}
+
+QNetworkSession::State QConnmanEngine::sessionStateForId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+    if (!ptr)
+        return QNetworkSession::Invalid;
+
+    if (!ptr->isValid) {
+        return QNetworkSession::Invalid;
+
+    }
+    QString service = serviceFromId(id);
+    QConnmanServiceInterface serv(service);
+    QString servState = serv.getState();
+
+    if(serv.isFavorite() && (servState == "idle" || servState == "failure")) {
+        return QNetworkSession::Disconnected;
+    }
+
+    if(servState == "association" || servState == "configuration" || servState == "login") {
+        return QNetworkSession::Connecting;
+    }
+    if(servState == "ready" || servState == "online") {
+        return QNetworkSession::Connected;
+    }
+
+    if ((ptr->state & QNetworkConfiguration::Discovered) ==
+                QNetworkConfiguration::Discovered) {
+        return QNetworkSession::Disconnected;
+    } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {
+        return QNetworkSession::NotAvailable;
+    } else if ((ptr->state & QNetworkConfiguration::Undefined) ==
+                QNetworkConfiguration::Undefined) {
+        return QNetworkSession::NotAvailable;
+    }
+
+    return QNetworkSession::Invalid;
+}
+
+quint64 QConnmanEngine::bytesWritten(const QString &id)
+{//TODO use connman counter API
+    QMutexLocker locker(&mutex);
+    quint64 result = 0;
+    QString devFile = getInterfaceFromId(id);
+    QFile tx("/sys/class/net/"+devFile+"/statistics/tx_bytes");
+    if(tx.exists() && tx.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        QTextStream in(&tx);
+        in >> result;
+        tx.close();
+    }
+
+    return result;
+}
+
+quint64 QConnmanEngine::bytesReceived(const QString &id)
+{//TODO use connman counter API
+    QMutexLocker locker(&mutex);
+    quint64 result = 0;
+    QString devFile = getInterfaceFromId(id);
+    QFile rx("/sys/class/net/"+devFile+"/statistics/rx_bytes");
+    if(rx.exists() && rx.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        QTextStream in(&rx);
+        in >> result;
+        rx.close();
+    }
+    return result;
+}
+
+quint64 QConnmanEngine::startTime(const QString &/*id*/)
+{
+    // TODO
+    QMutexLocker locker(&mutex);
+    if (activeTime.isNull()) {
+        return 0;
+    }
+    return activeTime.secsTo(QDateTime::currentDateTime());
+}
+
+QNetworkConfigurationManager::Capabilities QConnmanEngine::capabilities() const
+{
+    return QNetworkConfigurationManager::ForcedRoaming |
+            QNetworkConfigurationManager::DataStatistics |
+           QNetworkConfigurationManager::CanStartAndStopInterfaces;
+}
+
+QNetworkSessionPrivate *QConnmanEngine::createSessionBackend()
+{
+     return new QNetworkSessionPrivateImpl;
+}
+
+QNetworkConfigurationPrivatePointer QConnmanEngine::defaultConfiguration()
+{
+    return QNetworkConfigurationPrivatePointer();
+}
+
+
+QString QConnmanEngine::getServiceForNetwork(const QString &netPath)
+{
+    QMutexLocker locker(&mutex);
+    QConnmanNetworkInterface network(netPath, this);
+    foreach(QString service,connmanManager->getServices()) {
+        QConnmanServiceInterface serv(service,this);
+        if(serv.getName() == network.getName()
+            && network.getSignalStrength() == serv.getSignalStrength()) {
+            return service;
+        }
+    }
+    return QString();
+}
+
+
+void QConnmanEngine::propertyChangedContext(const QString &path,const QString &item, const QDBusVariant &value)
+{
+    Q_UNUSED(path);
+//    qDebug() << __FUNCTION__ << path << item << value.variant();
+
+    QMutexLocker locker(&mutex);
+    if(item == "Services") {
+        QDBusArgument arg = qvariant_cast<QDBusArgument>(value.variant());
+        QStringList list = qdbus_cast<QStringList>(arg);
+
+        if(list.count() > accessPointConfigurations.count()) {
+            foreach(const QString service, list) {
+                addServiceConfiguration(service);
+            }
+        }
+    }
+
+    if(item == "Technologies") {
+        QDBusArgument arg = qvariant_cast<QDBusArgument>(value.variant());
+        QStringList newlist = qdbus_cast<QStringList>(arg);
+        if(newlist.count() > 0) {
+            QMap<QString,QConnmanTechnologyInterface *> oldtech = technologies;
+
+            foreach(const QString listPath, newlist) {
+                if(!oldtech.contains(listPath)) {
+                    QConnmanTechnologyInterface *tech;
+                    tech = new QConnmanTechnologyInterface(listPath,this);
+                    connect(tech,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                            this,SLOT(technologyPropertyChangedContext(QString,QString,QDBusVariant)));
+                    technologies.insert(listPath, tech);
+                }
+            }
+
+            foreach(const QString old, oldtech.keys()) {
+                if(!newlist.contains(old)) {
+                    QConnmanTechnologyInterface *tech = oldtech.value(old);
+                    disconnect(tech,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                               this,SLOT(technologyPropertyChangedContext(QString,QString,QDBusVariant)));
+
+                    technologies.remove(old);
+                    getNetworkListing();
+                }
+            }
+        }
+    }
+    if(item == "State") {
+// qDebug() << value.variant();
+    }
+}
+
+void QConnmanEngine::servicePropertyChangedContext(const QString &path,const QString &item, const QDBusVariant &value)
+{
+    QMutexLocker locker(&mutex);
+    if(item == "State") {
+        configurationChange(QString::number(qHash(path)));
+
+        if(value.variant().toString() == "failure") {
+            QConnmanServiceInterface serv(path);
+            emit connectionError(QString::number(qHash(path)), ConnectError);
+        }
+    }
+}
+
+void QConnmanEngine::networkPropertyChangedContext(const QString &/*path*/,const QString &/*item*/, const QDBusVariant &/*value*/)
+{
+    QMutexLocker locker(&mutex);
+}
+
+void QConnmanEngine::devicePropertyChangedContext(const QString &devpath,const QString &item,const QDBusVariant &value)
+{
+    QMutexLocker locker(&mutex);
+    if(item == "Networks") {
+        QDBusArgument arg = qvariant_cast<QDBusArgument>(value.variant());
+        QStringList remainingNetworks  = qdbus_cast<QStringList>(arg);
+        QString devicetype;
+        QMapIterator<QString,QStringList> i(deviceMap);
+        while(i.hasNext()) {
+            i.next();
+            if(i.value().contains(devpath)) {
+                devicetype = i.key().section("/",-1);
+            }
+        }
+
+        QStringList oldnetworks = knownNetworks[devicetype];
+
+        if(remainingNetworks.count() > oldnetworks.count()) {
+            foreach(const QString netPath, remainingNetworks) {
+                if(!oldnetworks.contains(netPath)) {
+                    addNetworkConfiguration(netPath);
+                }
+            }
+        } else {
+            foreach(const QString netPath, oldnetworks) {
+                QString servicePath = serviceNetworks.key(netPath);
+                if(!remainingNetworks.contains(netPath)) {
+                    if(servicePath.isEmpty()) {
+                        removeConfiguration(QString::number(qHash(netPath)));
+                    }  else {
+                        removeConfiguration(QString::number(qHash(servicePath)));
+                    }
+                    knownNetworks[devicetype].removeAll(netPath);
+                }
+            }
+        }
+    }
+}
+
+void QConnmanEngine::technologyPropertyChangedContext(const QString & path, const QString &item, const QDBusVariant &value)
+{
+  if(item == "Devices") {
+      QDBusArgument arg = qvariant_cast<QDBusArgument>(value.variant());
+      QStringList list = qdbus_cast<QStringList>(arg);
+  }
+  if(item == "State") {
+
+      if(value.variant().toString() == "available") {
+          QConnmanTechnologyInterface tech(connmanManager->getPathForTechnology(path));
+          foreach(const QString devPath, tech.getDevices()) {
+
+              if(!deviceMap.value(path).contains(devPath)) {
+                  QConnmanDeviceInterface *dev;
+                  dev = new QConnmanDeviceInterface(devPath,this);
+                  connect(dev,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                          this,SLOT(devicePropertyChangedContext(QString,QString,QDBusVariant)));
+                  deviceMap.insert(path,QStringList() << devPath);
+              }
+          }
+      }
+      if(value.variant().toString() == "offline") {
+          deviceMap.remove(path);
+      }
+  }
+}
+
+void QConnmanEngine::configurationChange(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    if (accessPointConfigurations.contains(id)) {
+
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+        QString servicePath = serviceFromId(id);
+        QConnmanServiceInterface *serv;
+        serv = new QConnmanServiceInterface(servicePath);
+        QString networkName = serv->getName();
+
+        QNetworkConfiguration::StateFlags curState = getStateForService(servicePath);
+
+        ptr->mutex.lock();
+
+        if (!ptr->isValid) {
+            ptr->isValid = true;
+        }
+
+        if (ptr->name != networkName) {
+            ptr->name = networkName;
+        }
+
+        if (ptr->state != curState) {
+            ptr->state = curState;
+        }
+
+        ptr->mutex.unlock();
+
+        locker.unlock();
+        emit configurationChanged(ptr);
+        locker.relock();
+
+    }
+     locker.unlock();
+     emit updateCompleted();
+}
+
+QNetworkConfiguration::StateFlags QConnmanEngine::getStateForService(const QString &service)
+{
+    QMutexLocker locker(&mutex);
+    QConnmanServiceInterface serv(service);
+    QNetworkConfiguration::StateFlags flag = QNetworkConfiguration::Defined;
+    if(serv.isFavorite()) {
+        flag = ( flag | QNetworkConfiguration::Discovered);
+    } else {
+        flag = QNetworkConfiguration::Undefined;
+    }
+
+    if(serv.getState() == "ready" || serv.getState() == "online") {
+        flag = ( flag | QNetworkConfiguration::Active);
+    }
+
+    return flag;
+}
+
+QString QConnmanEngine::typeToBearer(const QString &type)
+{
+    QMutexLocker locker(&mutex);
+    if(type == "wifi")
+        return "WLAN";
+    if(type == "ethernet")
+        return "Ethernet";
+    if(type == "bluetooth")
+        return "Bluetooth";
+    if(type == "cellular") {
+        return "Cellular";
+        // not handled: CDMA2000 HSPA
+    }
+    if(type == "wimax")
+        return "WiMax";
+//    if(type == "gps")
+//    if(type == "vpn")
+
+    return "Unknown";
+}
+
+void QConnmanEngine::removeConfiguration(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    if (accessPointConfigurations.contains(id)) {
+
+        QString service = serviceFromId(id);
+        QConnmanServiceInterface serv(service);
+
+        disconnect(&serv,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                   this,SLOT(servicePropertyChangedContext(QString,QString, QDBusVariant)));
+
+        QString netPath = serviceNetworks.value(service);
+        serviceNetworks.remove(service);
+
+        QConnmanServiceInterface network(netPath);
+        disconnect(&network,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                   this,SLOT(networkPropertyChangedContext(QString,QString, QDBusVariant)));
+
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(id);
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+    }
+}
+
+void QConnmanEngine::addServiceConfiguration(const QString &servicePath)
+{
+
+    QMutexLocker locker(&mutex);
+    QConnmanServiceInterface *serv;
+    serv = new QConnmanServiceInterface(servicePath);
+    const QString netPath = serviceNetworks.value(servicePath);
+
+    QConnmanNetworkInterface *network;
+    network = new QConnmanNetworkInterface(netPath, this);
+
+
+    const QString id = QString::number(qHash(servicePath));
+
+    if (!accessPointConfigurations.contains(id)) {
+        QConnmanDeviceInterface device(netPath.section("/",0,5),this);
+
+        serviceNetworks.insert(servicePath,netPath);
+
+        knownNetworks[device.getType()].append(netPath);
+
+        connect(serv,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                this,SLOT(servicePropertyChangedContext(QString,QString, QDBusVariant)));
+        QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
+
+        QString networkName = serv->getName();
+
+        if(serv->getType() == "Cellular") {
+            networkName = serv->getAPN();
+        }
+
+        cpPriv->name = networkName;
+        cpPriv->isValid = true;
+        cpPriv->id = id;
+        cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+        cpPriv->bearer = bearerName(id);
+
+        if(serv->getSecurity() == "none") {
+            cpPriv->purpose = QNetworkConfiguration::PublicPurpose;
+        } else {
+            cpPriv->purpose = QNetworkConfiguration::PrivatePurpose;
+        }
+
+        connect(network,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                this,SLOT(networkPropertyChangedContext(QString,QString, QDBusVariant)));
+
+        cpPriv->state = getStateForService(servicePath);
+
+        QNetworkConfigurationPrivatePointer ptr(cpPriv);
+        accessPointConfigurations.insert(ptr->id, ptr);
+        foundConfigurations.append(cpPriv);
+        configInterfaces[cpPriv->id] = device.getInterface();
+
+
+        locker.unlock();
+        emit configurationAdded(ptr);
+        locker.relock();
+        emit updateCompleted();
+    }
+}
+
+void QConnmanEngine::addNetworkConfiguration(const QString &networkPath)
+{
+    QMutexLocker locker(&mutex);
+
+    QConnmanNetworkInterface *network;
+    network = new QConnmanNetworkInterface(networkPath, this);
+    QString servicePath = getServiceForNetwork(networkPath);
+    QConnmanServiceInterface *serv;
+
+    QString id;
+    QConnmanDeviceInterface device(networkPath.section("/",0,5),this);
+
+    if(servicePath.isEmpty()) {
+        id = QString::number(qHash(networkPath));
+    } else {
+        id = QString::number(qHash(servicePath));
+            serv = new QConnmanServiceInterface(servicePath,this);
+            connect(serv,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                    this,SLOT(servicePropertyChangedContext(QString,QString, QDBusVariant)));
+    }
+
+    if (!accessPointConfigurations.contains(id)) {
+
+        knownNetworks[device.getType()].append(networkPath);
+
+        serviceNetworks.insert(servicePath,networkPath);
+
+        connect(network,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+                this,SLOT(networkPropertyChangedContext(QString,QString, QDBusVariant)));
+
+        QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
+
+        QString networkName = network->getName();
+
+        if(networkName.isEmpty())
+            networkName = "Hidden Network";
+
+        QString bearerName;
+
+        if(servicePath.isEmpty()) {
+            QString devicePath = networkPath.section("/",0,5);
+            QConnmanDeviceInterface device(devicePath,this);
+            bearerName = typeToBearer(device.getType());
+        } else {
+            bearerName = typeToBearer(serv->getType());
+        }
+
+        if(bearerName == "Cellular") {
+            QString mode = serv->getMode();
+            if(mode == "gprs" || mode == "edge") {
+                bearerName = "2G";
+            } else if(mode == "umts") {
+                bearerName = "WCDMA";
+            }
+            networkName = serv->getAPN();
+        }
+
+        cpPriv->name = networkName;
+        cpPriv->isValid = true;
+        cpPriv->id = id;
+        cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+        cpPriv->bearer = bearerName;
+
+        if(network->getWifiSecurity() == "none") {
+            cpPriv->purpose = QNetworkConfiguration::PublicPurpose;
+        } else {
+            cpPriv->purpose = QNetworkConfiguration::PrivatePurpose;
+        }
+
+        if(servicePath.isEmpty())
+            cpPriv->state = QNetworkConfiguration::Undefined;
+        else
+            cpPriv->state = getStateForService(servicePath);
+
+        QNetworkConfigurationPrivatePointer ptr(cpPriv);
+        accessPointConfigurations.insert(ptr->id, ptr);
+        foundConfigurations.append(cpPriv);
+        configInterfaces[cpPriv->id] = device.getInterface();
+
+        locker.unlock();
+        emit configurationAdded(ptr);
+        locker.relock();
+        emit updateCompleted();
+    }
+}
+
+bool QConnmanEngine::requiresPolling() const
+{
+    return false;
+}
+
+
+QConnmanConnectThread::QConnmanConnectThread(QObject *parent)
+    :QThread(parent),
+    servicePath(), identifier()
+{
+}
+
+QConnmanConnectThread::~QConnmanConnectThread()
+{
+}
+
+void QConnmanConnectThread::stop()
+{
+    if(currentThread() != this) {
+        QMetaObject::invokeMethod(this, "quit",
+                                  Qt::QueuedConnection);
+    } else {
+        quit();
+    }
+    wait();
+}
+
+void QConnmanConnectThread::run()
+{
+    QConnmanServiceInterface serv(servicePath);
+    if(!serv.isValid()) {
+        emit connectionError(identifier, QBearerEngineImpl::InterfaceLookupError);
+    } else {
+        serv.connect();
+    }
+}
+
+void QConnmanConnectThread::setServicePath(const QString &path)
+{
+    QMutexLocker locker(&mutex);
+    servicePath = path;
+}
+
+void QConnmanConnectThread::setIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    identifier = id;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_DBUS
+#endif // QT_NO_BEARERMANAGEMENT
diff --git a/src/plugins/bearer/connman/qconnmanengine.h b/src/plugins/bearer/connman/qconnmanengine.h
new file mode 100644
index 0000000..0f6dc1c
--- /dev/null
+++ b/src/plugins/bearer/connman/qconnmanengine.h
@@ -0,0 +1,179 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCONNMANENGINE_P_H
+#define QCONNMANENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "../qbearerengine_impl.h"
+
+#include "qconnmanservice_linux_p.h"
+
+#include <QMap>
+#include <QVariant>
+#include <QtCore/qthread.h>
+
+#ifndef QT_NO_BEARERMANAGEMENT
+#ifndef QT_NO_DBUS
+
+QT_BEGIN_NAMESPACE
+
+class QConnmanConnectThread;
+class QConnmanEngine : public QBearerEngineImpl
+{
+    Q_OBJECT
+
+public:
+    QConnmanEngine(QObject *parent = 0);
+    ~QConnmanEngine();
+
+    bool connmanAvailable() const;
+
+    virtual QString getInterfaceFromId(const QString &id);
+    bool hasIdentifier(const QString &id);
+
+    virtual QString bearerName(const QString &id);
+
+    virtual void connectToId(const QString &id);
+    virtual void disconnectFromId(const QString &id);
+
+    Q_INVOKABLE void initialize();
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkSession::State sessionStateForId(const QString &id);
+    QNetworkSessionPrivate *createSessionBackend();
+
+    virtual quint64 bytesWritten(const QString &id);
+    virtual quint64 bytesReceived(const QString &id);
+    virtual quint64 startTime(const QString &id);
+
+
+    virtual QNetworkConfigurationManager::Capabilities capabilities() const;
+    virtual QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+    void configurationChange(const QString &id);
+    QList<QNetworkConfigurationPrivate *> getConfigurations();
+
+
+private Q_SLOTS:
+
+    void doRequestUpdate();
+    void servicePropertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+    void networkPropertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+    void devicePropertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+    void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+    void technologyPropertyChangedContext(const QString &,const QString &, const QDBusVariant &);
+
+private:
+    QConnmanManagerInterface *connmanManager;
+
+    QList<QNetworkConfigurationPrivate *> foundConfigurations;
+
+    void getNetworkListing();
+
+    QString getServiceForNetwork(const QString &network);
+
+    QString serviceFromId(const QString &id);
+    QString networkFromId(const QString &id);
+
+    QNetworkConfiguration::StateFlags getStateForService(const QString &service);
+    QString typeToBearer(const QString &type);
+
+    void removeConfiguration(const QString &servicePath);
+    void addServiceConfiguration(const QString &servicePath);
+    void addNetworkConfiguration(const QString &worknetPath);
+    QDateTime activeTime;
+
+
+    QMap<QString,QConnmanTechnologyInterface *> technologies; // techpath, tech interface
+    QMap<QString,QString> configInterfaces; // id, interface name
+    QMap<QString,QStringList> knownNetworks; //device path, net paths list
+    QMap<QString,QStringList> deviceMap; //tech path,  device path
+    QMap<QString, QString> serviceNetworks; //service, network
+
+
+protected:
+    bool requiresPolling() const;
+    QConnmanConnectThread *connThread;
+};
+
+class QConnmanConnectThread : public QThread
+{
+    Q_OBJECT
+
+public:
+    QConnmanConnectThread(QObject *parent = 0);
+    ~QConnmanConnectThread();
+    bool keepRunning;
+    void stop();
+    void setServicePath(const QString &path);
+    void setIdentifier(const QString &id);
+
+Q_SIGNALS:
+    void connectionError(const QString &id, QBearerEngineImpl::ConnectionError error);
+
+protected:
+    void run();
+    QString servicePath;
+    QString identifier;
+
+private:
+    QMutex mutex;
+
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_DBUS
+#endif // QT_NO_BEARERMANAGEMENT
+
+#endif
+
diff --git a/src/plugins/bearer/connman/qconnmanservice_linux.cpp b/src/plugins/bearer/connman/qconnmanservice_linux.cpp
new file mode 100644
index 0000000..b20e7c1
--- /dev/null
+++ b/src/plugins/bearer/connman/qconnmanservice_linux.cpp
@@ -0,0 +1,1072 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QObject>
+#include <QList>
+#include <QtDBus/QtDBus>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusError>
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusReply>
+#include <QtDBus/QDBusPendingCallWatcher>
+#include <QtDBus/QDBusObjectPath>
+#include <QtDBus/QDBusPendingCall>
+
+#include "qconnmanservice_linux_p.h"
+
+
+QT_BEGIN_NAMESPACE
+static QDBusConnection dbusConnection = QDBusConnection::systemBus();
+
+
+QConnmanManagerInterface::QConnmanManagerInterface( QObject *parent)
+        : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                                 QLatin1String(CONNMAN_MANAGER_PATH),
+                                 CONNMAN_MANAGER_INTERFACE,
+                                 QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanManagerInterface::~QConnmanManagerInterface()
+{
+}
+
+void QConnmanManagerInterface::connectNotify(const char *signal)
+{
+if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+        if(!connection().connect(QLatin1String(CONNMAN_SERVICE),
+                               QLatin1String(CONNMAN_MANAGER_PATH),
+                               QLatin1String(CONNMAN_MANAGER_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+            qWarning() << "PropertyCHanged not connected";
+        }
+    }
+
+    if (QLatin1String(signal) == SIGNAL(stateChanged(QString))) {
+        if (!connection().connect(QLatin1String(CONNMAN_SERVICE),
+                                    QLatin1String(CONNMAN_MANAGER_PATH),
+                                    QLatin1String(CONNMAN_MANAGER_INTERFACE),
+                                    QLatin1String("StateChanged"),
+                                    this,SIGNAL(stateChanged(const QString&)))) {
+            qWarning() << "StateChanged not connected";
+
+        }
+    }
+    if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+        QConnmanDBusHelper *helper;
+        helper = new QConnmanDBusHelper(this);
+
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               QLatin1String(CONNMAN_MANAGER_PATH),
+                               QLatin1String(CONNMAN_MANAGER_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+        QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+                this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+    }
+}
+
+void QConnmanManagerInterface::disconnectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+    }
+}
+
+QVariant QConnmanManagerInterface::getProperty(const QString &property)
+{
+    QVariant var;
+    QVariantMap map = getProperties();
+    if (map.contains(property)) {
+        var = map.value(property);
+    } else {
+        qDebug() << "does not contain" << property;
+    }
+    return var;
+}
+
+QVariantMap QConnmanManagerInterface::getProperties()
+{
+    QDBusReply<QVariantMap > reply =  this->call(QLatin1String("GetProperties"));
+    return reply.value();
+}
+
+QString QConnmanManagerInterface::getState()
+{
+    QDBusReply<QString > reply =  this->call("GetState");
+    return reply.value();
+}
+
+bool QConnmanManagerInterface::setProperty(const QString &name, const QDBusVariant &value)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(value);
+    return false;
+}
+
+QDBusObjectPath QConnmanManagerInterface::createProfile(const QString &/*name*/)
+{
+    return QDBusObjectPath();
+}
+
+bool QConnmanManagerInterface::removeProfile(QDBusObjectPath /*path*/)
+{
+    return false;
+}
+
+bool QConnmanManagerInterface::requestScan(const QString &type)
+{
+    QDBusReply<QString> reply =  this->call(QLatin1String("RequestScan"), QVariant::fromValue(type));
+
+    bool ok = true;
+    if(reply.error().type() == QDBusError::InvalidArgs) {
+        qWarning() << reply.error().message();
+        ok = false;
+    }
+    return ok;
+}
+
+bool QConnmanManagerInterface::enableTechnology(const QString &type)
+{
+    QDBusReply<QList<QDBusObjectPath> > reply =  this->call(QLatin1String("EnableTechnology"), QVariant::fromValue(type));
+    bool ok = true;
+    if(reply.error().type() == QDBusError::InvalidArgs) {
+        qWarning() << reply.error().message();
+        ok = false;
+    }
+    return ok;
+}
+
+bool QConnmanManagerInterface::disableTechnology(const QString &type)
+{
+    QDBusReply<QList<QDBusObjectPath> > reply =  this->call(QLatin1String("DisableTechnology"), QVariant::fromValue(type));
+    bool ok = true;
+    if(reply.error().type() == QDBusError::InvalidArgs) {
+        qWarning() << reply.error().message();
+        ok = false;
+    }
+    return ok;
+}
+
+QDBusObjectPath QConnmanManagerInterface::connectService(QVariantMap &map)
+{
+    QDBusReply<QDBusObjectPath > reply =  this->call(QLatin1String("ConnectService"), QVariant::fromValue(map));
+    if(!reply.isValid()) {
+        qDebug() << reply.error().message();
+
+    }
+    return reply;
+}
+
+void QConnmanManagerInterface::registerAgent(QDBusObjectPath &/*path*/)
+{
+}
+
+void QConnmanManagerInterface::unregisterAgent(QDBusObjectPath /*path*/)
+{
+}
+
+void QConnmanManagerInterface::registerCounter(const QString &path, quint32 interval)
+{   QDBusReply<QList<QDBusObjectPath> > reply =  this->call(QLatin1String("RegisterCounter"),
+                                                            QVariant::fromValue(path),
+                                                            QVariant::fromValue(interval));
+    bool ok = true;
+    if(reply.error().type() == QDBusError::InvalidArgs) {
+        qWarning() << reply.error().message();
+    }
+}
+
+void QConnmanManagerInterface::unregisterCounter(const QString &path)
+{   QDBusReply<QList<QDBusObjectPath> > reply =  this->call(QLatin1String("UnregisterCounter"),
+                                                            QVariant::fromValue(path));
+    bool ok = true;
+    if(reply.error().type() == QDBusError::InvalidArgs) {
+        qWarning() << reply.error().message();
+    }
+}
+
+QString QConnmanManagerInterface::requestSession(const QString &bearerName)
+{
+    QDBusReply<QList<QDBusObjectPath> > reply =  this->call(QLatin1String("RequestSession"),
+                                                            QVariant::fromValue(bearerName));
+    return QString();
+}
+
+void QConnmanManagerInterface::releaseSession()
+{
+    QDBusReply<QList<QDBusObjectPath> > reply =  this->call(QLatin1String("ReleaseSession"));
+}
+
+
+QDBusObjectPath QConnmanManagerInterface::lookupService(const QString &service)
+{
+    QDBusReply<QDBusObjectPath > reply =  this->call(QLatin1String("LookupService"), QVariant::fromValue(service));
+    if(!reply.isValid()) {
+        qDebug() << reply.error().message();
+    }
+    return reply;
+}
+
+// properties
+
+QStringList QConnmanManagerInterface::getAvailableTechnologies()
+{
+    QVariant var = getProperty("AvailableTechnologies");
+    return qdbus_cast<QStringList>(var);
+}
+
+QStringList QConnmanManagerInterface::getEnabledTechnologies()
+{
+    QVariant var = getProperty("EnabledTechnologies");
+    return qdbus_cast<QStringList>(var);
+}
+
+QStringList QConnmanManagerInterface::getConnectedTechnologies()
+{
+    QVariant var = getProperty("ConnectedTechnologies");
+    return qdbus_cast<QStringList>(var);
+}
+
+QString QConnmanManagerInterface::getDefaultTechnology()
+{
+    QVariant var = getProperty("DefaultTechnology");
+    return qdbus_cast<QString>(var);
+}
+
+bool QConnmanManagerInterface::getOfflineMode()
+{
+    QVariant var = getProperty("OfflineMode");
+    return qdbus_cast<bool>(var);
+}
+
+QString QConnmanManagerInterface::getActiveProfile()
+{
+    QVariant var = getProperty("ActiveProfile");
+    return qdbus_cast<QString>(var);
+}
+
+QStringList QConnmanManagerInterface::getProfiles()
+{
+    QVariant var = getProperty("Profiles");
+    return qdbus_cast<QStringList>(var);
+}
+
+QStringList QConnmanManagerInterface::getTechnologies()
+{
+    QVariant var = getProperty("Technologies");
+    return qdbus_cast<QStringList >(var);
+}
+
+QStringList QConnmanManagerInterface::getServices()
+{
+    QVariant var = getProperty("Services");
+    return qdbus_cast<QStringList >(var);
+}
+
+QString QConnmanManagerInterface::getPathForTechnology(const QString &name)
+{
+    foreach(const QString path, getTechnologies()) {
+        if(path.contains(name)) {
+            return path;
+        }
+    }
+    return "";
+}
+
+QConnmanNetworkInterface::QConnmanNetworkInterface(const QString &dbusPathName, QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                             dbusPathName,
+                             CONNMAN_NETWORK_INTERFACE,
+                             QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanNetworkInterface::~QConnmanNetworkInterface()
+{
+}
+
+void QConnmanNetworkInterface::connectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+        if(!connection().connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_NETWORK_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               this,SIGNAL(propertyChanged(QString,QDBusVariant))) ) {
+            qWarning() << "network properties not connected";
+        }
+    }
+    if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+        QConnmanDBusHelper *helper;
+        helper = new QConnmanDBusHelper(this);
+
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_NETWORK_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+        QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+                this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+    }
+}
+
+void QConnmanNetworkInterface::disconnectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+
+    }
+}
+
+QVariantMap QConnmanNetworkInterface::getProperties()
+{
+    QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+    return reply.value();
+}
+
+QVariant QConnmanNetworkInterface::getProperty(const QString &property)
+{
+    QVariant var;
+    QVariantMap map = getProperties();
+    if (map.contains(property)) {
+        var = map.value(property);
+    }
+    return var;
+}
+
+//properties
+
+QString QConnmanNetworkInterface::getAddress()
+{
+    QVariant var = getProperty("Address");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanNetworkInterface::getName()
+{
+    QVariant var = getProperty("Name");
+    return qdbus_cast<QString>(var);
+}
+
+bool QConnmanNetworkInterface::isConnected()
+{
+    QVariant var = getProperty("Connected");
+    return qdbus_cast<bool>(var);
+}
+
+quint8 QConnmanNetworkInterface::getSignalStrength()
+{
+    QVariant var = getProperty("Strength");
+    return qdbus_cast<quint8>(var);
+}
+
+QString QConnmanNetworkInterface::getDevice()
+{
+    QVariant var = getProperty("Device");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanNetworkInterface::getWifiSsid()
+{
+    QVariant var = getProperty("WiFi.SSID");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanNetworkInterface::getWifiMode()
+{
+    QVariant var = getProperty("WiFi.Mode");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanNetworkInterface::getWifiSecurity()
+{
+    QVariant var = getProperty("WiFi.Security");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanNetworkInterface::getWifiPassphrase()
+{
+    QVariant var = getProperty("WiFi.Passphrase");
+    return qdbus_cast<QString>(var);
+}
+
+
+//////////////////////////
+
+QConnmanProfileInterface::QConnmanProfileInterface(const QString &dbusPathName,QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                             dbusPathName,
+                             CONNMAN_PROFILE_INTERFACE,
+                             QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanProfileInterface::~QConnmanProfileInterface()
+{
+}
+
+void QConnmanProfileInterface::connectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_PROFILE_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               this,SIGNAL(propertyChanged(QString,QDBusVariant)));
+    }
+}
+
+void QConnmanProfileInterface::disconnectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString, QVariant))) {
+
+    }
+}
+
+QVariantMap QConnmanProfileInterface::getProperties()
+{
+    QDBusReply<QVariantMap > reply =  this->call(QLatin1String("GetProperties"));
+    return reply.value();
+}
+
+QVariant QConnmanProfileInterface::getProperty(const QString &property)
+{
+    QVariant var;
+    QVariantMap map = getProperties();
+    if (map.contains(property)) {
+        var = map.value(property);
+    } else {
+        qDebug() <<__FUNCTION__<< "Could not find" << property;
+    }
+    return var;
+}
+
+// properties
+QString QConnmanProfileInterface::getName()
+{
+
+    QVariant var = getProperty("Name");
+    return qdbus_cast<QString>(var);
+}
+
+bool QConnmanProfileInterface::isOfflineMode()
+{
+    QVariant var = getProperty("OfflineMode");
+    return qdbus_cast<bool>(var);
+}
+
+QStringList QConnmanProfileInterface::getServices()
+{
+    QVariant var = getProperty("Services");
+    return qdbus_cast<QStringList>(var);
+}
+
+///////////////////////////
+QConnmanServiceInterface::QConnmanServiceInterface(const QString &dbusPathName,QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                             dbusPathName,
+                             CONNMAN_SERVICE_INTERFACE,
+                             QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanServiceInterface::~QConnmanServiceInterface()
+{
+}
+
+void QConnmanServiceInterface::connectNotify(const char *signal)
+{
+//    qWarning() << __FUNCTION__ << signal << this->path();
+
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_SERVICE_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               this,SIGNAL(propertyChanged(QString,QDBusVariant)));
+    }
+    if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+        QConnmanDBusHelper *helper;
+        helper = new QConnmanDBusHelper(this);
+
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_SERVICE_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+        QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+                this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+    }
+}
+
+void QConnmanServiceInterface::disconnectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+    }
+}
+
+QVariantMap QConnmanServiceInterface::getProperties()
+{
+    QDBusReply<QVariantMap> reply =  this->call(QLatin1String("GetProperties"));
+    return reply.value();
+}
+
+QVariant QConnmanServiceInterface::getProperty(const QString &property)
+{
+    QVariant var;
+    QVariantMap map = getProperties();
+    if (map.contains(property)) {
+        var = map.value(property);
+    } else {
+//        qDebug() <<__FUNCTION__<< "Could not find" << property;
+    }
+    return var;
+}
+
+// clearProperty
+void QConnmanServiceInterface::connect()
+{
+    QDBusReply<QVariantMap> reply = this->call(QLatin1String("Connect"));
+}
+
+void QConnmanServiceInterface::disconnect()
+{
+    QDBusReply<QVariantMap> reply = this->call(QLatin1String("Disconnect"));
+}
+
+void QConnmanServiceInterface::remove()
+{
+    QDBusReply<QVariantMap> reply = this->call(QLatin1String("Remove"));
+}
+
+// void moveBefore(QDBusObjectPath &service);
+// void moveAfter(QDBusObjectPath &service);
+
+// properties
+QString QConnmanServiceInterface::getState()
+{
+    QVariant var = getProperty("State");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getError()
+{
+    QVariant var = getProperty("Error");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getName()
+{
+    QVariant var = getProperty("Name");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getType()
+{
+    QVariant var = getProperty("Type");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getMode()
+{
+    QVariant var = getProperty("Mode");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getSecurity()
+{
+    QVariant var = getProperty("Security");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getPassphrase()
+{
+    QVariant var = getProperty("Passphrase");
+    return qdbus_cast<QString>(var);
+}
+
+bool QConnmanServiceInterface::isPassphraseRequired()
+{
+    QVariant var = getProperty("PassphraseRequired");
+    return qdbus_cast<bool>(var);
+}
+
+quint8 QConnmanServiceInterface::getSignalStrength()
+{
+    QVariant var = getProperty("Strength");
+    return qdbus_cast<quint8>(var);
+}
+
+bool QConnmanServiceInterface::isFavorite()
+{
+    QVariant var = getProperty("Favorite");
+    return qdbus_cast<bool>(var);
+}
+
+bool QConnmanServiceInterface::isImmutable()
+{
+    QVariant var = getProperty("Immutable");
+    return qdbus_cast<bool>(var);
+}
+
+bool QConnmanServiceInterface::isAutoConnect()
+{
+    QVariant var = getProperty("AutoConnect");
+    return qdbus_cast<bool>(var);
+}
+
+bool QConnmanServiceInterface::isSetupRequired()
+{
+    QVariant var = getProperty("SetupRequired");
+    return qdbus_cast<bool>(var);
+}
+
+QString QConnmanServiceInterface::getAPN()
+{
+    QVariant var = getProperty("APN");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getMCC()
+{
+    QVariant var = getProperty("MCC");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanServiceInterface::getMNC()
+{
+    QVariant var = getProperty("MNC");
+    return qdbus_cast<QString>(var);
+}
+
+bool QConnmanServiceInterface::isRoaming()
+{
+    QVariant var = getProperty("Roaming");
+    return qdbus_cast<bool>(var);
+}
+
+QStringList QConnmanServiceInterface::getNameservers()
+{
+    QVariant var = getProperty("NameServers");
+    return qdbus_cast<QStringList>(var);
+}
+
+QStringList QConnmanServiceInterface::getDomains()
+{
+    QVariant var = getProperty("Domains");
+    return qdbus_cast<QStringList>(var);
+}
+
+QVariantMap QConnmanServiceInterface::getIPv4()
+{
+    QVariant var = getProperty("IPv4");
+    return qdbus_cast<QVariantMap >(var);
+}
+
+QVariantMap QConnmanServiceInterface::getIPv4Configuration()
+{
+    QVariant var = getProperty("IPv4.Configuration");
+    return qdbus_cast<QVariantMap >(var);
+}
+
+QVariantMap QConnmanServiceInterface::getProxy()
+{
+    QVariant var = getProperty("Proxy");
+    return qdbus_cast<QVariantMap >(var);
+}
+
+QVariantMap QConnmanServiceInterface::getEthernet()
+{
+    QVariant var = getProperty("Ethernet");
+    return qdbus_cast<QVariantMap >(var);
+}
+
+bool QConnmanServiceInterface::isOfflineMode()
+{
+    QVariant var = getProperty("OfflineMode");
+    return qdbus_cast<bool>(var);
+}
+
+QStringList QConnmanServiceInterface::getServices()
+{
+    QVariant var = getProperty("Services");
+    return qdbus_cast<QStringList>(var);
+}
+
+
+//////////////////////////
+QConnmanTechnologyInterface::QConnmanTechnologyInterface(const QString &dbusPathName,QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                             dbusPathName,
+                             CONNMAN_TECHNOLOGY_INTERFACE,
+                             QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanTechnologyInterface::~QConnmanTechnologyInterface()
+{
+}
+
+void QConnmanTechnologyInterface::connectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_TECHNOLOGY_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               this,SIGNAL(propertyChanged(QString,QDBusVariant)));
+    }
+    if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+        QConnmanDBusHelper *helper;
+        helper = new QConnmanDBusHelper(this);
+
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_TECHNOLOGY_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+        QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+                this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+    }
+}
+
+void QConnmanTechnologyInterface::disconnectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+    }
+}
+
+QVariantMap QConnmanTechnologyInterface::getProperties()
+{
+    QDBusReply<QVariantMap> reply =  this->call(QLatin1String("GetProperties"));
+    return reply.value();
+}
+
+QVariant QConnmanTechnologyInterface::getProperty(const QString &property)
+{
+    QVariant var;
+    QVariantMap map = getProperties();
+    if (map.contains(property)) {
+        var = map.value(property);
+    }
+    return var;
+}
+
+// properties
+QString QConnmanTechnologyInterface::getState()
+{
+    QVariant var = getProperty("State");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanTechnologyInterface::getName()
+{
+    QVariant var = getProperty("Name");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanTechnologyInterface::getType()
+{
+    QVariant var = getProperty("Type");
+    return qdbus_cast<QString>(var);
+}
+
+
+QStringList QConnmanTechnologyInterface::getDevices()
+{
+    QVariant var = getProperty("Devices");
+    return qdbus_cast<QStringList>(var);
+}
+
+
+//////////////////////////////////
+QConnmanAgentInterface::QConnmanAgentInterface(const QString &dbusPathName, QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                             dbusPathName,
+                             CONNMAN_AGENT_INTERFACE,
+                             QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanAgentInterface::~QConnmanAgentInterface()
+{
+}
+
+void QConnmanAgentInterface::connectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+//        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+//                               this->path(),
+//                               QLatin1String(CONNMAN_NETWORK_INTERFACE),
+//                               QLatin1String("PropertyChanged"),
+//                               this,SIGNAL(propertyChanged(const QString &, QVariant &)));
+    }
+}
+
+void QConnmanAgentInterface::disconnectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString, QDBusVariant))) {
+
+    }
+}
+
+
+void QConnmanAgentInterface::release()
+{
+}
+
+void QConnmanAgentInterface::reportError(QDBusObjectPath &/*path*/, const QString &/*error*/)
+{
+}
+
+//dict QConnmanAgentInterface::requestInput(QDBusObjectPath &path, dict fields)
+//{
+//}
+
+void QConnmanAgentInterface::cancel()
+{
+}
+
+
+/////////////////////////////////////////
+QConnmanCounterInterface::QConnmanCounterInterface(const QString &dbusPathName,QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                             dbusPathName,
+                             CONNMAN_COUNTER_INTERFACE,
+                             QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanCounterInterface::~QConnmanCounterInterface()
+{
+}
+
+quint32 QConnmanCounterInterface::getReceivedByteCount()
+{
+return 0;
+}
+
+quint32 QConnmanCounterInterface::getTransmittedByteCount()
+{
+return 0;
+}
+
+/////////////////////////////////////////
+QConnmanDeviceInterface::QConnmanDeviceInterface(const QString &dbusPathName,QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(CONNMAN_SERVICE),
+                             dbusPathName,
+                             CONNMAN_DEVICE_INTERFACE,
+                             QDBusConnection::systemBus(), parent)
+{
+}
+
+QConnmanDeviceInterface::~QConnmanDeviceInterface()
+{
+}
+
+void QConnmanDeviceInterface::connectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_DEVICE_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               this,SIGNAL(propertyChanged(QString,QDBusVariant)));
+
+    }
+    if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+        QConnmanDBusHelper *helper;
+        helper = new QConnmanDBusHelper(this);
+
+        dbusConnection.connect(QLatin1String(CONNMAN_SERVICE),
+                               this->path(),
+                               QLatin1String(CONNMAN_DEVICE_INTERFACE),
+                               QLatin1String("PropertyChanged"),
+                               helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+        QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+                this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+    }
+}
+
+void QConnmanDeviceInterface::disconnectNotify(const char *signal)
+{
+    if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+    }
+}
+
+QVariantMap QConnmanDeviceInterface::getProperties()
+{
+    QDBusReply<QVariantMap> reply =  this->call(QLatin1String("GetProperties"));
+    return reply.value();
+}
+
+bool QConnmanDeviceInterface::setProperty(const QString &name, const QDBusVariant &value)
+{
+
+//    QList<QVariant> args;
+    qWarning() << __FUNCTION__ << name << value.variant();
+//    args << qVariantFromValue(name);
+//    args << qVariantFromValue(value);
+
+    QDBusMessage reply = this->call(QLatin1String("SetProperty"),name, qVariantFromValue(value));
+qWarning() << reply.errorMessage();
+
+    return true;
+}
+
+void QConnmanDeviceInterface::scan()
+{
+    QDBusReply<QVariantMap> reply = this->call(QLatin1String("ProposeScan"));
+    if(!reply.isValid()) {
+        qDebug() << reply.error().message();
+    }
+}
+
+QVariant QConnmanDeviceInterface::getProperty(const QString &property)
+{
+    QVariant var;
+    QVariantMap map = getProperties();
+    if (map.contains(property)) {
+        var = map.value(property);
+    }
+    return var;
+}
+
+//properties
+QString QConnmanDeviceInterface::getAddress()
+{
+    QVariant var = getProperty("Address");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanDeviceInterface::getName()
+{
+    QVariant var = getProperty("Name");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanDeviceInterface::getType()
+{
+    QVariant var = getProperty("Type");
+    return qdbus_cast<QString>(var);
+}
+
+QString QConnmanDeviceInterface::getInterface()
+{
+    QVariant var = getProperty("Interface");
+    return qdbus_cast<QString>(var);
+}
+
+bool QConnmanDeviceInterface::isPowered()
+{
+    QVariant var = getProperty("Powered");
+    return qdbus_cast<bool>(var);
+}
+
+quint16 QConnmanDeviceInterface::getScanInterval()
+{
+    QVariant var = getProperty("ScanInterval");
+    return qdbus_cast<quint16>(var);
+}
+
+bool QConnmanDeviceInterface::setScanInterval(const QString & interval)
+{
+//    QList<QVariant> args;
+//    args << qVariantFromValue(name)
+//    << value.variant();
+
+//    QDBusMessage reply = this->callWithArgumentList(QDBus::AutoDetect,QLatin1String("SetProperty"),args);
+
+    return setProperty("ScanInterval", QDBusVariant(interval));
+}
+
+bool QConnmanDeviceInterface::isScanning()
+{
+    QVariant var = getProperty("Scanning");
+     return qdbus_cast<bool>(var);
+}
+
+QStringList QConnmanDeviceInterface::getNetworks()
+{
+    QVariant var = getProperty("Networks");
+    return qdbus_cast<QStringList>(var);
+}
+
+bool QConnmanDeviceInterface::setEnabled(bool powered)
+{
+    QList<QVariant> args;
+    args << qVariantFromValue(QString("Powered"))
+    << qVariantFromValue(QDBusVariant(powered));
+
+    QDBusMessage reply = this->callWithArgumentList(QDBus::AutoDetect,QLatin1String("SetProperty"),args);
+    qWarning() << reply.errorMessage() << reply.errorName();
+    return true;
+}
+
+QConnmanDBusHelper::QConnmanDBusHelper(QObject * parent)
+        : QObject(parent)
+{
+}
+
+QConnmanDBusHelper::~QConnmanDBusHelper()
+{
+}
+
+void QConnmanDBusHelper::propertyChanged(const QString &item, const QDBusVariant &var)
+{
+    QDBusMessage msg = this->message();
+//    qWarning() << sender();
+ //   qWarning()  << msg.interface() << msg.path() << item << var.variant() <<"\n";
+    Q_EMIT propertyChangedContext(msg.path() ,item, var);
+}
+
+/////////////////
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/connman/qconnmanservice_linux_p.h b/src/plugins/bearer/connman/qconnmanservice_linux_p.h
new file mode 100644
index 0000000..35e3f3d
--- /dev/null
+++ b/src/plugins/bearer/connman/qconnmanservice_linux_p.h
@@ -0,0 +1,381 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCONNMANSERVICE_H
+#define QCONNMANSERVICE_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtDBus/QtDBus>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusError>
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusReply>
+
+#include <QtDBus/QDBusPendingCallWatcher>
+#include <QtDBus/QDBusObjectPath>
+#include <QtDBus/QDBusContext>
+#include <QMap>
+
+#ifndef __CONNMAN_DBUS_H
+
+#define	CONNMAN_SERVICE     "org.moblin.connman"
+#define	CONNMAN_PATH        "/org/moblin/connman"
+
+#define CONNMAN_DEBUG_INTERFACE		CONNMAN_SERVICE ".Debug"
+#define CONNMAN_ERROR_INTERFACE		CONNMAN_SERVICE ".Error"
+#define CONNMAN_AGENT_INTERFACE		CONNMAN_SERVICE ".Agent"
+#define CONNMAN_COUNTER_INTERFACE	CONNMAN_SERVICE ".Counter"
+
+#define CONNMAN_MANAGER_INTERFACE	CONNMAN_SERVICE ".Manager"
+#define CONNMAN_MANAGER_PATH		"/"
+
+#define CONNMAN_TASK_INTERFACE		CONNMAN_SERVICE ".Task"
+#define CONNMAN_PROFILE_INTERFACE	CONNMAN_SERVICE ".Profile"
+#define CONNMAN_SERVICE_INTERFACE	CONNMAN_SERVICE ".Service"
+#define CONNMAN_DEVICE_INTERFACE	CONNMAN_SERVICE ".Device"
+#define CONNMAN_NETWORK_INTERFACE	CONNMAN_SERVICE ".Network"
+#define CONNMAN_PROVIDER_INTERFACE	CONNMAN_SERVICE ".Provider"
+#define CONNMAN_TECHNOLOGY_INTERFACE	CONNMAN_SERVICE ".Technology"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QT_END_NAMESPACE
+
+
+QT_BEGIN_NAMESPACE
+
+class QConnmanManagerInterface : public  QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanManagerInterface( QObject *parent = 0);
+    ~QConnmanManagerInterface();
+
+     QDBusObjectPath path() const;
+
+    QVariantMap getProperties();
+    bool setProperty(const QString &name, const QDBusVariant &value);
+    QDBusObjectPath createProfile(const QString &name);
+    bool removeProfile(QDBusObjectPath path);
+    bool requestScan(const QString &type);
+    bool enableTechnology(const QString &type);
+    bool disableTechnology(const QString &type);
+    QDBusObjectPath connectService(QVariantMap &map);
+    void registerAgent(QDBusObjectPath &path);
+    void unregisterAgent(QDBusObjectPath path);
+    void registerCounter(const QString &path, quint32 interval);
+    void unregisterCounter(const QString &path);
+
+    QString requestSession(const QString &bearerName);
+    void releaseSession();
+    
+      // properties
+    QString getState();
+    QStringList getAvailableTechnologies();
+    QStringList getEnabledTechnologies();
+    QStringList getConnectedTechnologies();
+    QString getDefaultTechnology();
+    bool getOfflineMode();
+    QString getActiveProfile();
+    QStringList getProfiles();
+    QStringList  getTechnologies();
+    QStringList getServices();
+    QDBusObjectPath lookupService(const QString &);
+
+    QString getPathForTechnology(const QString &tech);
+
+
+Q_SIGNALS:
+    void propertyChanged(const QString &, const QDBusVariant &value);
+    void stateChanged(const QString &);
+    void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+
+protected:
+    void connectNotify(const char *signal);
+    void disconnectNotify(const char *signal);
+    QVariant getProperty(const QString &);
+};
+
+
+class QConnmanNetworkInterface : public QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanNetworkInterface(const QString &dbusPathName, QObject *parent = 0);
+    ~QConnmanNetworkInterface();
+
+    QVariantMap getProperties();
+
+    //properties
+    QString getAddress();
+    QString getName();
+    bool isConnected();
+    quint8 getSignalStrength();
+    QString getDevice();
+    QString getWifiSsid();
+    QString getWifiMode();
+    QString getWifiSecurity();
+    QString getWifiPassphrase();
+
+Q_SIGNALS:
+    void propertyChanged(const QString &, const QDBusVariant &value);
+    void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+protected:
+    void connectNotify(const char *signal);
+    void disconnectNotify(const char *signal);
+    QVariant getProperty(const QString &);
+};
+
+class QConnmanProfileInterfacePrivate;
+class QConnmanProfileInterface : public QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanProfileInterface(const QString &dbusPathName,QObject *parent = 0);
+    ~QConnmanProfileInterface();
+
+    QVariantMap getProperties();
+// properties
+    QString getName();
+    bool isOfflineMode();
+    QStringList getServices();
+
+Q_SIGNALS:
+    void propertyChanged(const QString &, const QDBusVariant &value);
+private:
+    QConnmanProfileInterfacePrivate *d;
+
+protected:
+    void connectNotify(const char *signal);
+    void disconnectNotify(const char *signal);
+    QVariant getProperty(const QString &);
+};
+
+class QConnmanServiceInterface : public QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanServiceInterface(const QString &dbusPathName,QObject *parent = 0);
+    ~QConnmanServiceInterface();
+
+    QVariantMap getProperties();
+      // clearProperty
+    void connect();
+    void disconnect();
+    void remove();
+      // void moveBefore(QDBusObjectPath &service);
+      // void moveAfter(QDBusObjectPath &service);
+
+// properties
+    QString getState();
+    QString getError();
+    QString getName();
+    QString getType();
+    QString getMode();
+    QString getSecurity();
+    QString getPassphrase();
+    bool isPassphraseRequired();
+    quint8 getSignalStrength();
+    bool isFavorite();
+    bool isImmutable();
+    bool isAutoConnect();
+    bool isSetupRequired();
+    QString getAPN();
+    QString getMCC();
+    QString getMNC();
+    bool isRoaming();
+    QStringList getNameservers();
+    QStringList getDomains();
+    QVariantMap getIPv4();
+    QVariantMap getIPv4Configuration();
+    QVariantMap getProxy();
+    QVariantMap getEthernet();
+
+    bool isOfflineMode();
+    QStringList getServices();
+
+Q_SIGNALS:
+    void propertyChanged(const QString &, const QDBusVariant &value);
+    void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+
+protected:
+    void connectNotify(const char *signal);
+    void disconnectNotify(const char *signal);
+    QVariant getProperty(const QString &);
+};
+
+class QConnmanTechnologyInterface : public QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanTechnologyInterface(const QString &dbusPathName,QObject *parent = 0);
+    ~QConnmanTechnologyInterface();
+
+    QVariantMap getProperties();
+// properties
+    QString getState();
+    QString getName();
+    QString getType();
+
+    QStringList getDevices();
+
+Q_SIGNALS:
+    void propertyChanged(const QString &, const QDBusVariant &value);
+    void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+protected:
+    void connectNotify(const char *signal);
+    void disconnectNotify(const char *signal);
+    QVariant getProperty(const QString &);
+
+};
+
+class QConnmanAgentInterface : public QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanAgentInterface(const QString &dbusPathName,QObject *parent = 0);
+    ~QConnmanAgentInterface();
+
+    void release();
+    void reportError(QDBusObjectPath &path, const QString &error);
+//    dict requestInput(QDBusObjectPath &path, dict fields);
+    void cancel();
+protected:
+    void connectNotify(const char *signal);
+    void disconnectNotify(const char *signal);
+};
+
+class QConnmanCounterInterfacePrivate;
+class QConnmanCounterInterface : public QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanCounterInterface(const QString &dbusPathName, QObject *parent = 0);
+    ~QConnmanCounterInterface();
+
+//    void release();
+    QString getInterface();
+    quint32 getReceivedByteCount();
+    quint32 getTransmittedByteCount();
+
+private:
+    QConnmanCounterInterfacePrivate *d;
+};
+
+class QConnmanDeviceInterface : public QDBusAbstractInterface
+{
+    Q_OBJECT
+
+public:
+
+    QConnmanDeviceInterface(const QString &dbusPathName,QObject *parent = 0);
+    ~QConnmanDeviceInterface();
+
+    QVariantMap getProperties();
+    void scan();
+
+//properties
+    QString getAddress();
+    QString getName();
+    QString getType();
+    QString getInterface();
+    bool isPowered();
+    quint16 getScanInterval();
+    bool setScanInterval(const QString &interval);
+
+    bool isScanning();
+    QStringList getNetworks();
+    bool setEnabled(bool powered);
+    bool setProperty(const QString &name, const QDBusVariant &value);
+
+Q_SIGNALS:
+    void propertyChanged(const QString &, const QDBusVariant &value);
+    void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+protected:
+    void connectNotify(const char *signal);
+    void disconnectNotify(const char *signal);
+    QVariant getProperty(const QString &);
+
+};
+
+class QConnmanDBusHelper: public QObject, protected QDBusContext
+ {
+     Q_OBJECT
+ public:
+    QConnmanDBusHelper(QObject *parent = 0);
+    ~QConnmanDBusHelper();
+
+ public slots:
+    void propertyChanged(const QString &, const QDBusVariant &);
+
+Q_SIGNALS:
+    void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+};
+
+QT_END_NAMESPACE
+
+#endif //QCONNMANSERVICE_H
diff --git a/src/plugins/bearer/icd/qnetworksession_impl.cpp b/src/plugins/bearer/icd/qnetworksession_impl.cpp
index e375b4f..aeac620 100644
--- a/src/plugins/bearer/icd/qnetworksession_impl.cpp
+++ b/src/plugins/bearer/icd/qnetworksession_impl.cpp
@@ -620,6 +620,9 @@ static QString get_network_interface()
 	return iface;
     }
 
+    if (addr_results.first().ip_info.isEmpty())
+	return QString();
+
     const char *address = addr_results.first().ip_info.first().address.toAscii().constData();
     struct in_addr addr;
     if (inet_aton(address, &addr) == 0) {
diff --git a/src/sql/drivers/oci/qsql_oci.cpp b/src/sql/drivers/oci/qsql_oci.cpp
index 2f0cfdc..c56b995 100644
--- a/src/sql/drivers/oci/qsql_oci.cpp
+++ b/src/sql/drivers/oci/qsql_oci.cpp
@@ -648,7 +648,7 @@ QByteArray qMakeOraDate(const QDateTime& dt)
 
 QDateTime qMakeDate(const char* oraDate)
 {
-    int century = oraDate[0];
+    int century = uchar(oraDate[0]);
     if(century >= 100){
         int year    = uchar(oraDate[1]);
         year = ((century-100)*100) + (year-100);