improve SnorePlugin::setEnabled

src/libsnore/plugins/plugins.cpp

@@ -35,7 +35,7 @@ SnorePlugin::SnorePlugin()
     if (thread() != qApp->thread()) {
         snoreDebug(SNORE_WARNING) << "Plugin initialized in wrong thread.";
     }
-    connect(this, &SnorePlugin::initialisationFinished, [this](bool b) {
+    connect(this, &SnorePlugin::initializeChanged, [this](bool b) {
         snoreDebug(SNORE_DEBUG) << "Plugin:" << name() << "initialized" << b;
         Q_ASSERT_X(!(b && m_initialized), Q_FUNC_INFO, "Plugin initialized multiple times.");
         if (!b) {
@@ -119,6 +119,10 @@ void SnorePlugin::setDefaultSettings()
 void SnorePlugin::setEnabled(bool enabled)
 {
     Q_ASSERT_X(!enabled || isInitialized(), Q_FUNC_INFO, "Plugin not initialized");
+
+    if (enabled != m_enabled) {
+        emit enabledChanged(enabled);
+    }
     m_enabled = enabled;
 }
 

src/libsnore/plugins/plugins.h

@@ -53,7 +53,7 @@ public:
     SnorePlugin();
     virtual ~SnorePlugin();
 
-    virtual void setEnabled(bool enabled);
+    void setEnabled(bool enabled);
 
     void enable();
     void disable();
@@ -84,7 +84,8 @@ public:
     virtual PluginSettingsWidget *settingsWidget();
 
 Q_SIGNALS:
-    void initialisationFinished(bool initialized);
+    void initializeChanged(bool initialized);
+    void enabledChanged(bool enabled);
 
 public Q_SLOTS:
     virtual void slotInitialize() = 0;

src/libsnore/plugins/snorebackend.cpp

@@ -29,40 +29,37 @@
 
 using namespace Snore;
 
+SnoreBackend::SnoreBackend()
+{
+    connect(this, &SnoreSecondaryBackend::enabledChanged, [this](bool enabled) {
+        if (enabled) {
+            connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationRegistered, this, &SnoreBackend::slotRegisterApplication, Qt::QueuedConnection);
+            connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationDeregistered, this, &SnoreBackend::slotDeregisterApplication, Qt::QueuedConnection);
+
+            connect(this, &SnoreBackend::notificationClosed, SnoreCorePrivate::instance(), &SnoreCorePrivate::slotNotificationClosed, Qt::QueuedConnection);
+            connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreBackend::slotNotify, Qt::QueuedConnection);
+
+            for (const Application &a : SnoreCore::instance().aplications()) {
+                slotRegisterApplication(a);
+            }
+        } else {
+            for (const Application &a : SnoreCore::instance().aplications()) {
+                slotDeregisterApplication(a);
+            }
+            disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationRegistered, this, &SnoreBackend::slotRegisterApplication);
+            disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationDeregistered, this, &SnoreBackend::slotDeregisterApplication);
+
+            disconnect(this, &SnoreBackend::notificationClosed, SnoreCorePrivate::instance(), &SnoreCorePrivate::slotNotificationClosed);
+            disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreBackend::slotNotify);
+        }
+    });
+}
+
 SnoreBackend::~SnoreBackend()
 {
     snoreDebug(SNORE_DEBUG) << "Deleting" << name();
 }
 
-void SnoreBackend::setEnabled(bool enabled)
-{
-    if (enabled == isEnabled()) {
-        return;
-    }
-    SnorePlugin::setEnabled(enabled);
-    if (enabled) {
-        connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationRegistered, this, &SnoreBackend::slotRegisterApplication, Qt::QueuedConnection);
-        connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationDeregistered, this, &SnoreBackend::slotDeregisterApplication, Qt::QueuedConnection);
-
-        connect(this, &SnoreBackend::notificationClosed, SnoreCorePrivate::instance(), &SnoreCorePrivate::slotNotificationClosed, Qt::QueuedConnection);
-        connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreBackend::slotNotify, Qt::QueuedConnection);
-
-        for (const Application &a : SnoreCore::instance().aplications()) {
-            slotRegisterApplication(a);
-        }
-    } else {
-        for (const Application &a : SnoreCore::instance().aplications()) {
-            slotDeregisterApplication(a);
-        }
-        disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationRegistered, this, &SnoreBackend::slotRegisterApplication);
-        disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::applicationDeregistered, this, &SnoreBackend::slotDeregisterApplication);
-
-        disconnect(this, &SnoreBackend::notificationClosed, SnoreCorePrivate::instance(), &SnoreCorePrivate::slotNotificationClosed);
-        disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreBackend::slotNotify);
-
-    }
-}
-
 void SnoreBackend::requestCloseNotification(Notification notification, Notification::CloseReasons reason)
 {
     if (canCloseNotification() && notification.isValid()) {
@@ -90,26 +87,24 @@ void SnoreBackend::slotCloseNotification(Notification notification)
     Q_UNUSED(notification)
 }
 
+SnoreSecondaryBackend::SnoreSecondaryBackend()
+{
+    connect(this, &SnoreSecondaryBackend::enabledChanged, [this](bool enabled) {
+        if (enabled) {
+            connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreSecondaryBackend::slotNotify, Qt::QueuedConnection);
+            connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notificationDisplayed, this, &SnoreSecondaryBackend::slotNotificationDisplayed, Qt::QueuedConnection);
+        } else {
+            disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreSecondaryBackend::slotNotify);
+            disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notificationDisplayed, this, &SnoreSecondaryBackend::slotNotificationDisplayed);
+        }
+    });
+}
+
 SnoreSecondaryBackend::~SnoreSecondaryBackend()
 {
     snoreDebug(SNORE_DEBUG) << "Deleting" << name();
 }
 
-void SnoreSecondaryBackend::setEnabled(bool enabled)
-{
-    if (enabled == isEnabled()) {
-        return;
-    }
-    SnorePlugin::setEnabled(enabled);
-    if (enabled) {
-        connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreSecondaryBackend::slotNotify, Qt::QueuedConnection);
-        connect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notificationDisplayed, this, &SnoreSecondaryBackend::slotNotificationDisplayed, Qt::QueuedConnection);
-    } else {
-        disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notify, this, &SnoreSecondaryBackend::slotNotify);
-        disconnect(SnoreCorePrivate::instance(), &SnoreCorePrivate::notificationDisplayed, this, &SnoreSecondaryBackend::slotNotificationDisplayed);
-    }
-}
-
 void SnoreSecondaryBackend::slotNotify(Notification)
 {
 

src/libsnore/plugins/snorebackend.h

@@ -31,11 +31,9 @@ class SNORE_EXPORT SnoreBackend : public SnorePlugin
     Q_OBJECT
     Q_INTERFACES(Snore::SnorePlugin)
 public:
-    SnoreBackend() = default;
+    SnoreBackend();
     virtual ~SnoreBackend();
 
-    virtual void setEnabled(bool enabled) override;
-
     void requestCloseNotification(Snore::Notification notification, Notification::CloseReasons reason);
 
     virtual bool canCloseNotification() const;
@@ -72,11 +70,9 @@ class SNORE_EXPORT SnoreSecondaryBackend : public SnorePlugin
     Q_OBJECT
     Q_INTERFACES(Snore::SnorePlugin Snore::SnorePlugin)
 public:
-    SnoreSecondaryBackend() = default;
+    SnoreSecondaryBackend();
     virtual ~SnoreSecondaryBackend();
 
-    virtual void setEnabled(bool enabled) override;
-
 public Q_SLOTS:
     virtual void slotNotify(Snore::Notification notification);
     virtual void slotNotificationDisplayed(Snore::Notification notification);

src/libsnore/plugins/snorefrontend.cpp

@@ -21,26 +21,24 @@
 
 using namespace Snore;
 
+SnoreFrontend::SnoreFrontend()
+{
+    connect(this, &SnoreFrontend::enabledChanged, [this](bool enabled) {
+        if (enabled) {
+            connect(&SnoreCore::instance(), &SnoreCore::notificationClosed, this, &SnoreFrontend::slotNotificationClosed, Qt::QueuedConnection);
+            connect(&SnoreCore::instance(), &SnoreCore::actionInvoked, this, &SnoreFrontend::slotActionInvoked, Qt::QueuedConnection);
+        } else {
+            disconnect(&SnoreCore::instance(), &SnoreCore::notificationClosed, this, &SnoreFrontend::slotNotificationClosed);
+            disconnect(&SnoreCore::instance(), &SnoreCore::actionInvoked, this, &SnoreFrontend::slotActionInvoked);
+        }
+    });
+}
+
 SnoreFrontend::~SnoreFrontend()
 {
     snoreDebug(SNORE_DEBUG) << "Deleting" << name();
 }
 
-void SnoreFrontend::setEnabled(bool enabled)
-{
-    if (enabled == isEnabled()) {
-        return;
-    }
-    SnorePlugin::setEnabled(enabled);
-    if (enabled) {
-        connect(&SnoreCore::instance(), &SnoreCore::notificationClosed, this, &SnoreFrontend::slotNotificationClosed, Qt::QueuedConnection);
-        connect(&SnoreCore::instance(), &SnoreCore::actionInvoked, this, &SnoreFrontend::slotActionInvoked, Qt::QueuedConnection);
-    } else {
-        disconnect(&SnoreCore::instance(), &SnoreCore::notificationClosed, this, &SnoreFrontend::slotNotificationClosed);
-        disconnect(&SnoreCore::instance(), &SnoreCore::actionInvoked, this, &SnoreFrontend::slotActionInvoked);
-    }
-}
-
 void SnoreFrontend::slotActionInvoked(Notification)
 {
 

src/libsnore/plugins/snorefrontend.h

@@ -31,11 +31,9 @@ class SNORE_EXPORT SnoreFrontend: public SnorePlugin
     Q_OBJECT
     Q_INTERFACES(Snore::SnorePlugin)
 public:
-    SnoreFrontend() = default;
+    SnoreFrontend();
     virtual ~SnoreFrontend();
 
-    virtual void setEnabled(bool enabled) override;
-
 public Q_SLOTS:
     virtual void slotActionInvoked(Snore::Notification notification);
     virtual void slotNotificationClosed(Snore::Notification notification);

src/libsnore/snore.cpp

@@ -84,7 +84,7 @@ void SnoreCore::loadPlugins(SnorePlugin::PluginTypes types)
                 case SnorePlugin::SECONDARY_BACKEND:
                 case SnorePlugin::FRONTEND:
                 case SnorePlugin::PLUGIN:
-                    connect(plugin, &SnorePlugin::initialisationFinished, [plugin](bool initialized) {
+                    connect(plugin, &SnorePlugin::initializeChanged, [plugin](bool initialized) {
                         if (initialized) {
                             plugin->setEnabled(plugin->settingsValue(QLatin1String("Enabled"), LOCAL_SETTING).toBool());
                         }
@@ -95,7 +95,7 @@ void SnoreCore::loadPlugins(SnorePlugin::PluginTypes types)
                     continue;
                 }
 
-                connect(plugin, &SnorePlugin::initialisationFinished, [d, plugin](bool initialized) {
+                connect(plugin, &SnorePlugin::initializeChanged, [d, plugin](bool initialized) {
                     if (!initialized) {
                         //TODO: improve
                         d->m_pluginNames[plugin->type()].removeAll(plugin->name());

src/libsnore/snore_p.cpp

@@ -93,7 +93,7 @@ bool SnoreCorePrivate::setBackendIfAvailible(const QString &backend)
         if (m_notificationBackend) {
             m_notificationBackend->disable();
         }
-        connect(b, &SnoreBackend::initialisationFinished, [this, b](bool initialized) {
+        connect(b, &SnoreBackend::initializeChanged, [this, b](bool initialized) {
             if (!initialized) {
                 slotInitPrimaryNotificationBackend();
             }

src/plugins/backends/freedesktop/freedesktopnotification_backend.cpp

@@ -10,6 +10,20 @@
 
 using namespace Snore;
 
+FreedesktopBackend::FreedesktopBackend()
+{
+    connect(this, &SnoreSecondaryBackend::enabledChanged, [this](bool enabled) {
+        if (enabled) {
+            connect(m_interface, &org::freedesktop::Notifications::ActionInvoked, this, &FreedesktopBackend::slotActionInvoked);
+            connect(m_interface, &org::freedesktop::Notifications::NotificationClosed, this , &FreedesktopBackend::slotNotificationClosed);
+        } else {
+            disconnect(m_interface, &org::freedesktop::Notifications::ActionInvoked, this, &FreedesktopBackend::slotActionInvoked);
+            disconnect(m_interface, &org::freedesktop::Notifications::NotificationClosed, this , &FreedesktopBackend::slotNotificationClosed);
+
+        }
+    });
+}
+
 void FreedesktopBackend::slotInitialize()
 {
     m_interface = new org::freedesktop::Notifications(QLatin1String("org.freedesktop.Notifications"),
@@ -19,23 +33,7 @@ void FreedesktopBackend::slotInitialize()
     reply.waitForFinished();
     QStringList caps  = reply.value();
     m_supportsRichtext = caps.contains(QLatin1String("body-markup"));
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
-}
-
-void FreedesktopBackend::setEnabled(bool enabled)
-{
-    if (enabled == isEnabled()) {
-        return;
-    }
-    SnoreBackend::setEnabled(enabled);
-    if (enabled) {
-        connect(m_interface, &org::freedesktop::Notifications::ActionInvoked, this, &FreedesktopBackend::slotActionInvoked);
-        connect(m_interface, &org::freedesktop::Notifications::NotificationClosed, this , &FreedesktopBackend::slotNotificationClosed);
-    } else {
-        disconnect(m_interface, &org::freedesktop::Notifications::ActionInvoked, this, &FreedesktopBackend::slotActionInvoked);
-        disconnect(m_interface, &org::freedesktop::Notifications::NotificationClosed, this , &FreedesktopBackend::slotNotificationClosed);
-
-    }
 }
 
 bool FreedesktopBackend::canCloseNotification() const

src/plugins/backends/freedesktop/freedesktopnotification_backend.h

@@ -9,11 +9,9 @@ class  FreedesktopBackend: public Snore::SnoreBackend
     Q_INTERFACES(Snore::SnoreBackend)
     Q_PLUGIN_METADATA(IID "org.Snore.NotificationBackend/1.0" FILE "plugin.json")
 public:
-    FreedesktopBackend() = default;
+    FreedesktopBackend();
     ~FreedesktopBackend() = default;
 
-    void setEnabled(bool enabled) override;
-
     bool canCloseNotification() const override;
     bool canUpdateNotification() const override;
 

src/plugins/backends/growl/growlbackend.cpp

@@ -65,7 +65,7 @@ GrowlBackend::~GrowlBackend()
 
 void GrowlBackend::slotInitialize()
 {
-    emit initialisationFinished(Growl::isRunning(GROWL_TCP, settingsValue(QLatin1String("Host")).toString().toUtf8().constData()));
+    emit initializeChanged(Growl::isRunning(GROWL_TCP, settingsValue(QLatin1String("Host")).toString().toUtf8().constData()));
 }
 
 void GrowlBackend::slotRegisterApplication(const Application &application)

src/plugins/backends/osxnotificationcenter/osxnotificationcenter.h

@@ -32,6 +32,7 @@ public:
     ~OSXNotificationCenter();
 
 public Q_SLOTS:
+    void slotInitialize() override;
     void slotNotify(Snore::Notification notification) override;
 };
 

src/plugins/backends/snarl/snarl.cpp

@@ -125,7 +125,7 @@ void SnarlBackend::slotInitialize()
 {
 
     SnarlInterface *snarlInterface = new SnarlInterface();
-    emit initialisationFinished(snarlInterface->IsSnarlRunning());
+    emit initializeChanged(snarlInterface->IsSnarlRunning());
     delete snarlInterface;
 }
 

src/plugins/backends/snore/snorenotifier.cpp

@@ -123,7 +123,7 @@ void SnoreNotifier::slotInitialize()
             slotCloseNotification(notification);
         });
     }
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
 }
 
 bool SnoreNotifier::canCloseNotification() const

src/plugins/backends/snoretoast/snoretoast.cpp

@@ -18,9 +18,9 @@ void SnoreToast::slotInitialize()
 {
     if (QSysInfo::windowsVersion() < QSysInfo::WV_WINDOWS8) {
         snoreDebug(SNORE_DEBUG) << "SnoreToast does not work on windows" << QSysInfo::windowsVersion();
-        emit initialisationFinished(false);
+        emit initializeChanged(false);
     }
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
 }
 
 bool SnoreToast::canCloseNotification() const
@@ -134,7 +134,7 @@ QProcess *SnoreToast::createProcess(Notification noti)
         if (noti.isValid()) {
             closeNotification(noti, Notification::NONE);
         }
-        emit initialisationFinished(false);
+        emit initializeChanged(false);
         p->deleteLater();
     });
     connect(qApp, &QApplication::aboutToQuit, p, &QProcess::kill);

src/plugins/backends/trayicon/trayiconnotifer.cpp

@@ -9,7 +9,7 @@ using namespace Snore;
 void TrayIconNotifer::slotInitialize()
 {
     m_currentlyDisplaying = false;
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
 }
 
 bool TrayIconNotifer::canCloseNotification() const

src/plugins/frontends/freedesktop/freedesktopnotificationfrontend.cpp

@@ -29,36 +29,34 @@
 
 using namespace Snore;
 
-void FreedesktopFrontend::slotInitialize()
+FreedesktopFrontend::FreedesktopFrontend()
 {
-    emit initialisationFinished(true);
+    connect(this, &FreedesktopFrontend::enabledChanged, [this](bool enabled) {
-}
+        if (enabled) {
-
+            m_adaptor = new  NotificationsAdaptor(this);
-void FreedesktopFrontend::setEnabled(bool enabled)
+            QDBusConnection dbus = QDBusConnection::sessionBus();
-{
+            if (dbus.registerService(QLatin1String("org.freedesktop.Notifications"))) {
-    if (enabled == isEnabled()) {
+                if (!dbus.registerObject(QLatin1String("/org/freedesktop/Notifications"), this)) {
-        return;
+                    snoreDebug(SNORE_WARNING) << "Failed to initialize" << name() << "failed to register object";
-    }
+                    emit initializeChanged(false);
-    SnoreFrontend::setEnabled(enabled);
+                }
-    if (enabled) {
+            } else {
-        m_adaptor = new  NotificationsAdaptor(this);
+                snoreDebug(SNORE_WARNING) << "Failed to initialize" << name() << "failed to register service";
-        QDBusConnection dbus = QDBusConnection::sessionBus();
+                emit initializeChanged(false);
-        if (dbus.registerService(QLatin1String("org.freedesktop.Notifications"))) {
-            if (!dbus.registerObject(QLatin1String("/org/freedesktop/Notifications"), this)) {
-                snoreDebug(SNORE_WARNING) << "Failed to initialize" << name() << "failed to register object";
-                emit initialisationFinished(false);
             }
         } else {
-            snoreDebug(SNORE_WARNING) << "Failed to initialize" << name() << "failed to register service";
+            QDBusConnection dbus = QDBusConnection::sessionBus();
-            emit initialisationFinished(false);
+            dbus.unregisterService(QLatin1String("org.freedesktop.Notifications"));
+            dbus.unregisterObject(QLatin1String("/org/freedesktop/Notifications"));
+            m_adaptor->deleteLater();
+            m_adaptor = nullptr;
         }
-    } else {
+    });
-        QDBusConnection dbus = QDBusConnection::sessionBus();
+}
-        dbus.unregisterService(QLatin1String("org.freedesktop.Notifications"));
+
-        dbus.unregisterObject(QLatin1String("/org/freedesktop/Notifications"));
+void FreedesktopFrontend::slotInitialize()
-        m_adaptor->deleteLater();
+{
-        m_adaptor = nullptr;
+    emit initializeChanged(true);
-    }
 }
 
 void FreedesktopFrontend::slotActionInvoked(Notification notification)

src/plugins/frontends/freedesktop/freedesktopnotificationfrontend.h

@@ -29,11 +29,9 @@ class FreedesktopFrontend : public Snore::SnoreFrontend
     Q_INTERFACES(Snore::SnoreFrontend)
     Q_PLUGIN_METADATA(IID "org.Snore.NotificationFrontend/1.0" FILE "plugin.json")
 public:
-    FreedesktopFrontend() = default;
+    FreedesktopFrontend();
     ~FreedesktopFrontend() = default;
 
-    void setEnabled(bool enabled) override;
-
     uint Notify(const QString &app_name, uint replaces_id, const QString &app_icon, const QString &summary, const QString &body, const QStringList &actions, const QVariantMap &hints, int timeout);
     void CloseNotification(uint id);
 

src/plugins/frontends/pushover/pushover_frontend.cpp

@@ -42,24 +42,18 @@ PushoverFrontend::PushoverFrontend()
     connect(this, &PushoverFrontend::error, [this](QString error) {
         m_errorMessage = error;
     });
+    connect(this, &PushoverFrontend::enabledChanged, [this](bool enabled) {
+        if (enabled) {
+            connectToService();
+        } else {
+            disconnectService();
+        }
+    });
 }
 
 void PushoverFrontend::slotInitialize()
 {
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
-}
-
-void PushoverFrontend::setEnabled(bool enabled)
-{
-    if (enabled == isEnabled()) {
-        return;
-    }
-    SnoreFrontend::setEnabled(enabled);
-    if (enabled) {
-        connectToService();
-    } else {
-        disconnectService();
-    }
 }
 
 PluginSettingsWidget *PushoverFrontend::settingsWidget()

src/plugins/frontends/pushover/pushover_frontend.h

@@ -35,8 +35,6 @@ public:
     PushoverFrontend();
     ~PushoverFrontend() = default;
 
-    void setEnabled(bool enabled) override;
-
     Snore::PluginSettingsWidget *settingsWidget() override;
 
     void login(const QString &email, const QString &password, const QString &deviceName);

src/plugins/frontends/snarlnetwork/snarlnetwork.cpp

@@ -30,7 +30,13 @@ using namespace Snore;
 SnarlNetworkFrontend::SnarlNetworkFrontend():
     parser(new Parser(this))
 {
-
+    connect(this, &SnarlNetworkFrontend::enabledChanged, [this](bool enabled) {
+        if (enabled) {
+            connect(tcpServer, &QTcpServer::newConnection, this, SnarlNetworkFrontend::handleConnection);
+        } else {
+            disconnect(tcpServer, &QTcpServer::newConnection, this, SnarlNetworkFrontend::handleConnection);
+        }
+    });
 }
 
 SnarlNetworkFrontend::~SnarlNetworkFrontend()
@@ -43,25 +49,11 @@ void SnarlNetworkFrontend::slotInitialize()
     tcpServer = new QTcpServer(this);
     if (!tcpServer->listen(QHostAddress::Any, port)) {
         snoreDebug(SNORE_DEBUG) << "The port is already used";
-        emit initialisationFinished(false);
+        emit initializeChanged(false);
     } else {
         std::cout << "The Snarl Network Protokoll is developed for Snarl <http://www.fullphat.net/>" << std::endl;
     }
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
-}
-
-void SnarlNetworkFrontend::setEnabled(bool enabled)
-{
-    if (enabled == isEnabled()) {
-        return;
-    }
-    SnoreFrontend::setEnabled(enabled);
-    if (enabled) {
-        connect(tcpServer, &QTcpServer::newConnection, this, SnarlNetworkFrontend::handleConnection);
-    } else {
-        disconnect(tcpServer, &QTcpServer::newConnection, this, SnarlNetworkFrontend::handleConnection);
-    }
-
 }
 
 void SnarlNetworkFrontend::slotActionInvoked(Snore::Notification notification)

src/plugins/frontends/snarlnetwork/snarlnetwork.h

@@ -38,8 +38,6 @@ public:
     SnarlNetworkFrontend();
     ~SnarlNetworkFrontend();
 
-    void setEnabled(bool enabled) override;
-
 public Q_SLOTS:
     void slotInitialize() override;
     void slotActionInvoked(Snore::Notification notification) override;

src/plugins/secondary_backends/nma/nma.cpp

@@ -61,7 +61,7 @@ void NotifyMyAndroid::slotNotify(Notification notification)
 
 void NotifyMyAndroid::slotInitialize()
 {
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
 }
 
 PluginSettingsWidget *NotifyMyAndroid::settingsWidget()

src/plugins/secondary_backends/pushover/pushover.cpp

@@ -122,7 +122,7 @@ void Pushover::slotNotify(Notification notification)
 
 void Pushover::slotInitialize()
 {
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
 }
 
 PluginSettingsWidget *Pushover::settingsWidget()

src/plugins/secondary_backends/sound/sound.cpp

@@ -37,7 +37,7 @@ Sound::Sound():
 void Sound::slotInitialize()
 {
     m_player->setVolume(settingsValue(QLatin1String("Volume")).toInt());
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
 }
 
 PluginSettingsWidget *Sound::settingsWidget()

src/plugins/secondary_backends/toasty/toasty.cpp

@@ -79,7 +79,7 @@ void Toasty::slotNotify(Notification notification)
 
 void Toasty::slotInitialize()
 {
-    emit initialisationFinished(true);
+    emit initializeChanged(true);
 }
 
 PluginSettingsWidget *Toasty::settingsWidget()