Merge lp:~aacid/unity-2d/unity-2d-shell_abstractdbusmonitor_improvements into lp:~unity-2d-team/unity-2d/unity-2d-shell

[Albert Astals Cid]

Remove the enabled and add the serviceState properties to AbstractDBusServiceMonitor

[Albert Astals Cid (aacid)]

Tested with the Spread already up and the QueuedConnection does the trick nicely

[lp:~aacid/unity-2d/unity-2d-shell_abstractdbusmonitor_improvements]

989. By Albert Astals Cid on 2012-02-08

serviceState -> serviceAvailable

990. By Albert Astals Cid on 2012-02-08

The team did not like the QueuedConnection solution

991. By Albert Astals Cid on 2012-02-08

Florian prefers it in this order

=== modified file 'libunity-2d-private/src/abstractdbusservicemonitor.cpp'
--- libunity-2d-private/src/abstractdbusservicemonitor.cpp	2011-11-17 21:40:33 +0000
+++ libunity-2d-private/src/abstractdbusservicemonitor.cpp	2012-02-08 15:38:26 +0000
@@ -26,13 +26,21 @@
 AbstractDBusServiceMonitor::AbstractDBusServiceMonitor(QString service, QString path,
                                                        QString interface, QObject *parent)
     : QObject(parent)
-    , m_enabled(false)
     , m_service(service)
     , m_path(path)
     , m_interface(interface)
     , m_watcher(new QDBusServiceWatcher(service, QDBusConnection::sessionBus()))
     , m_dbusInterface(0)
 {
+    connect(m_watcher, SIGNAL(serviceRegistered(QString)), SLOT(createInterface()));
+    connect(m_watcher, SIGNAL(serviceUnregistered(QString)), SLOT(destroyInterface()));
+
+    // Connect to the service if it's up already
+    QDBusConnectionInterface* sessionBus = QDBusConnection::sessionBus().interface();
+    QDBusReply<bool> reply = sessionBus->isServiceRegistered(m_service);
+    if (reply.isValid() && reply.value()) {
+        createInterface();
+    }
 }
 
 AbstractDBusServiceMonitor::~AbstractDBusServiceMonitor()
@@ -43,62 +51,26 @@
     }
 }
 
-bool AbstractDBusServiceMonitor::enabled() const
-{
-    return m_enabled;
-}
-
-/* We don't do this in the constructor because if the service is already up we emit the
-   serviceStateChanged() signal during the constructor and we lose it since we can't have any slot
-   connected to it already */
-
-void AbstractDBusServiceMonitor::setEnabled(bool enabled)
-{
-    if (m_enabled != enabled) {
-        if (enabled) {
-            connect(m_watcher, SIGNAL(serviceRegistered(QString)), SLOT(createInterface(QString)));
-            connect(m_watcher, SIGNAL(serviceUnregistered(QString)), SLOT(destroyInterface(QString)));
-
-            // Connect to the service if it's up already
-            QDBusConnectionInterface* sessionBus = QDBusConnection::sessionBus().interface();
-            QDBusReply<bool> reply = sessionBus->isServiceRegistered(m_service);
-            if (reply.isValid() && reply.value()) {
-                createInterface(m_service);
-            }
-        } else {
-            if (m_dbusInterface != 0) {
-                delete m_dbusInterface;
-                m_dbusInterface = 0;
-            }
-            m_watcher->disconnect(this);
-        }
-
-        m_enabled = enabled;
-    }
-}
-
-void AbstractDBusServiceMonitor::createInterface(QString service)
+void AbstractDBusServiceMonitor::createInterface()
 {
     if (m_dbusInterface != 0) {
         delete m_dbusInterface;
         m_dbusInterface = 0;
     }
 
-    m_dbusInterface = new QDBusInterface(service, m_path, m_interface,
+    m_dbusInterface = new QDBusInterface(m_service, m_path, m_interface,
                                          QDBusConnection::sessionBus());
-    Q_EMIT serviceStateChanged(true);
+    Q_EMIT serviceAvailableChanged(true);
 }
 
-void AbstractDBusServiceMonitor::destroyInterface(QString service)
+void AbstractDBusServiceMonitor::destroyInterface()
 {
-    Q_UNUSED(service);
-
     if (m_dbusInterface != 0) {
         delete m_dbusInterface;
         m_dbusInterface = 0;
     }
 
-    Q_EMIT serviceStateChanged(false);
+    Q_EMIT serviceAvailableChanged(false);
 }
 
 QDBusInterface* AbstractDBusServiceMonitor::dbusInterface() const
@@ -106,4 +78,9 @@
     return m_dbusInterface;
 }
 
+bool AbstractDBusServiceMonitor::serviceAvailable() const
+{
+    return m_dbusInterface != 0;
+}
+
 #include "abstractdbusservicemonitor.moc"

=== modified file 'libunity-2d-private/src/abstractdbusservicemonitor.h'
--- libunity-2d-private/src/abstractdbusservicemonitor.h	2011-11-17 21:40:33 +0000
+++ libunity-2d-private/src/abstractdbusservicemonitor.h	2012-02-08 15:38:26 +0000
@@ -30,28 +30,25 @@
 class AbstractDBusServiceMonitor : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(bool serviceAvailable READ serviceAvailable NOTIFY serviceAvailableChanged)
 
 public:
     explicit AbstractDBusServiceMonitor(QString service, QString path, QString interface,
                                         QObject *parent = 0);
     ~AbstractDBusServiceMonitor();
 
-    void setEnabled(bool enabled);
-    bool enabled() const;
-
     QDBusInterface* dbusInterface() const;
 
+    bool serviceAvailable() const;
+
 Q_SIGNALS:
-    void enabledChanged(bool enabled);
-    void serviceStateChanged(bool available);
+    void serviceAvailableChanged(bool available);
 
 private Q_SLOTS:
-    void createInterface(QString);
-    void destroyInterface(QString);
+    void createInterface();
+    void destroyInterface();
 
 protected:
-    bool m_enabled;
     QString m_service;
     QString m_path;
     QString m_interface;

=== modified file 'libunity-2d-private/src/spreadmonitor.cpp'
--- libunity-2d-private/src/spreadmonitor.cpp	2011-11-17 21:40:33 +0000
+++ libunity-2d-private/src/spreadmonitor.cpp	2012-02-08 15:38:26 +0000
@@ -30,10 +30,14 @@
     : AbstractDBusServiceMonitor("com.canonical.Unity2d.Spread", "/Spread",
                                 "com.canonical.Unity2d.Spread", parent)
 {
-    connect(this, SIGNAL(serviceStateChanged(bool)), SLOT(onServiceStateChanged(bool)));
+    connect(this, SIGNAL(serviceAvailableChanged(bool)), SLOT(onServiceAvailableChanged(bool)));
+
+    if (serviceAvailable()) {
+        onServiceAvailableChanged(true);
+    }
 }
 
-void SpreadMonitor::onServiceStateChanged(bool available)
+void SpreadMonitor::onServiceAvailableChanged(bool available)
 {
     if (available) {
         connect(dbusInterface(), SIGNAL(IsShownChanged(bool)), SIGNAL(shownChanged(bool)));

=== modified file 'libunity-2d-private/src/spreadmonitor.h'
--- libunity-2d-private/src/spreadmonitor.h	2011-11-17 21:40:33 +0000
+++ libunity-2d-private/src/spreadmonitor.h	2012-02-08 15:38:26 +0000
@@ -37,7 +37,7 @@
     bool shown() const;
 
 protected Q_SLOTS:
-    void onServiceStateChanged(bool available);
+    void onServiceAvailableChanged(bool available);
 
 Q_SIGNALS:
     void shownChanged(bool visible);

=== modified file 'shell/Shell.qml'
--- shell/Shell.qml	2012-02-08 11:45:09 +0000
+++ shell/Shell.qml	2012-02-08 15:38:26 +0000
@@ -67,7 +67,6 @@
 
         SpreadMonitor {
             id: spread
-            enabled: true
             onShownChanged: if (shown) {
                                 /* The the spread grabs input and Qt can't properly
                                    detect we've lost input, so explicitly hide the menus */