Rename classes

Those classes are not restricted to QML, but provide general inter-
process communication via DBus. They can be used from native
applications, as well:
- QmlApplicationInterface to DBusApplicationInterface
- QmlApplicationInterfaceExtension to DBusApplicationInterfaceExtension
- QmlNotification to DBusNotification

Task-number: AUTOSUITE-1260
Change-Id: Iaff6251e61d62b7173e0e17a81863b4f653e8b5d
Reviewed-by: Robert Griebl <robert.griebl@qt.io>

18 files changed, 164 insertions, 113 deletions

diff --git a/examples/applicationmanager/application-features/apps/widgets/info.yaml b/examples/applicationmanager/application-features/apps/widgets/info.yaml
index 9d9cfce5..7e90e2ab 100644
--- a/examples/applicationmanager/application-features/apps/widgets/info.yaml
+++ b/examples/applicationmanager/application-features/apps/widgets/info.yaml
@@ -2,11 +2,12 @@ formatVersion: 1
 formatType: am-application
 ---
 id:      'widgets'
+name:
+  en: 'Native Widgets'
 icon:    'icon.png'
 code:    'widgets'
 runtime: 'native'
 runtimeParameters:
   environmentVariables:
     QT_WAYLAND_DISABLE_WINDOWDECORATION: "1"
-name:
-  en: 'Native Widgets'
+supportsApplicationInterface: yes
diff --git a/examples/applicationmanager/application-features/native/widgets/main.cpp b/examples/applicationmanager/application-features/native/widgets/main.cpp
index 3403065f..4c1c0914 100644
--- a/examples/applicationmanager/application-features/native/widgets/main.cpp
+++ b/examples/applicationmanager/application-features/native/widgets/main.cpp
@@ -29,14 +29,18 @@
 #include <QApplication>
 #include <QPushButton>
 #include <QDialog>
+#include <QVBoxLayout>
 
 #include "launchermain.h"
 #include "logging.h"
+#include "dbusapplicationinterface.h"
+#include "dbusnotification.h"
 
 
 int main(int argc, char *argv[])
 {
     QtAM::Logging::initialize(argc, argv);
+    QtAM::Logging::setApplicationId("widgets");
 
     QtAM::LauncherMain::initialize();
     QApplication app(argc, argv);
@@ -44,19 +48,39 @@ int main(int argc, char *argv[])
 
     launcher.registerWaylandExtensions();
     launcher.loadConfiguration();
-    launcher.setupDBusConnections();
     launcher.setupLogging(false, launcher.loggingRules(), QString(), launcher.useAMConsoleLogger());
+    launcher.setupDBusConnections();
+
+    QWidget window;
+    QVBoxLayout layout(&window);
+
+    // Popup using application manager window property
+    QPushButton button1(QStringLiteral("Click to open/close a popup"));
+    button1.setStyleSheet(QStringLiteral("QPushButton { background-color : limegreen; font-size: 36px; }"));
+    layout.addWidget(&button1);
+
+    QDialog *popup1 = new QDialog(&window);
+    (new QPushButton(QStringLiteral("I'm a popup!"), popup1))->resize(340, 140);
+    popup1->setStyleSheet(QStringLiteral("QPushButton { background-color : limegreen; color : white; font-size: 24px; }"));
+    QObject::connect(&button1, &QPushButton::clicked, [&popup1, &launcher] () {
+        popup1->setVisible(!popup1->isVisible());
+        launcher.setWindowProperty(popup1->windowHandle(), "type", QStringLiteral("pop-up"));
+    });
 
-    QPushButton window("I'm a top-level window!\nClick to open/close a popup.");
-    QDialog *popup = new QDialog(&window);
-    (new QPushButton("I'm a popup!", popup))->resize(300, 100);
+    // Notification
+    QPushButton button2(QStringLiteral("Click to open a notification"));
+    button2.setStyleSheet(QStringLiteral("QPushButton { background-color : darkgrey; font-size: 36px; }"));
+    layout.addWidget(&button2);
 
-    window.setStyleSheet("QPushButton { background-color : lightgrey; font-size: 36px; }");
-    popup->setStyleSheet("QPushButton { background-color : green; color : white; font-size: 24px; }");
+    QtAM::DBusNotification *notification = QtAM::DBusNotification::create(&app);
+    notification->setSummary(QStringLiteral("I'm a notification"));
+    QObject::connect(&button2, &QPushButton::clicked, notification, &QtAM::DBusNotification::show);
 
-    QObject::connect(&window, &QPushButton::clicked, [&popup, &launcher] () {
-        popup->setVisible(!popup->isVisible());
-        launcher.setWindowProperty(popup->windowHandle(), "type", QVariant::fromValue(QStringLiteral("pop-up")));
+    // Application interface for handling quit
+    QtAM::DBusApplicationInterface iface(launcher.p2pDBusName(), launcher.notificationDBusName());
+    iface.initialize();
+    QObject::connect(&iface, &QtAM::DBusApplicationInterface::quit, [&iface] () {
+        iface.acknowledgeQuit();
     });
 
     app.processEvents();
diff --git a/examples/applicationmanager/application-features/system-ui/main.qml b/examples/applicationmanager/application-features/system-ui/main.qml
index e6e00880..83c1c408 100644
--- a/examples/applicationmanager/application-features/system-ui/main.qml
+++ b/examples/applicationmanager/application-features/system-ui/main.qml
@@ -188,6 +188,14 @@ Window {
         }
     }
 
+    Text {
+        z: 9999
+        font.pixelSize: 46
+        anchors.bottom: parent.bottom
+        anchors.horizontalCenter: parent.horizontalCenter
+        text: NotificationManager.count > 0 ? NotificationManager.get(0).summary : ""
+    }
+
     Connections {
         target: WindowManager
         onWindowAdded:  {
diff --git a/src/common-lib/logging.cpp b/src/common-lib/logging.cpp
index 4845b82a..bce03e6d 100644
--- a/src/common-lib/logging.cpp
+++ b/src/common-lib/logging.cpp
@@ -106,6 +106,10 @@ static const char *s_defaultSystemUiDltDescription = "Qt Application Manager";
     \li \c QML
     \li General QML related messages
 \row
+    \li \c am.runtime
+    \li \c RT
+    \li Runtime messages
+\row
     \li \c am.runtime.qml
     \li \c QMRT
     \li QML runtime messages
@@ -144,6 +148,7 @@ QDLT_LOGGING_CATEGORY(LogInstaller, "am.installer", "INST", "Installer sub-syste
 QDLT_LOGGING_CATEGORY(LogGraphics, "am.graphics", "GRPH", "OpenGL/UI related messages")
 QDLT_LOGGING_CATEGORY(LogWaylandDebug, "am.wayland.debug", "WAYL", "Wayland related messages")
 QDLT_LOGGING_CATEGORY(LogQml, "am.qml", "QML", "General QML related messages")
+QDLT_LOGGING_CATEGORY(LogRuntime, "am.runtime", "RT", "Runtime messages")
 QDLT_LOGGING_CATEGORY(LogQmlRuntime, "am.runtime.qml", "QMRT", "QML runtime messages")
 QDLT_LOGGING_CATEGORY(LogQmlIpc, "am.qml.ipc", "QMIP", "QML IPC messages")
 QDLT_LOGGING_CATEGORY(LogNotifications, "am.notify", "NTFY", "Notifications sub-system messages")
@@ -398,10 +403,10 @@ QVariant Logging::useAMConsoleLogger()
 void Logging::useAMConsoleLogger(const QVariant &config)
 {
     s_useAMConsoleLoggerConfig = config;
-    if (!s_useAMConsoleLoggerConfig.isValid())
-        s_useAMConsoleLogger = !s_messagePatternDefined;
-    else
+    if (s_useAMConsoleLoggerConfig.userType() == QMetaType::Bool)
         s_useAMConsoleLogger = s_useAMConsoleLoggerConfig.toBool();
+    else
+        s_useAMConsoleLogger = !s_messagePatternDefined;
 }
 
 QByteArray Logging::applicationId()
diff --git a/src/common-lib/logging.h b/src/common-lib/logging.h
index cd73a428..054d8cdb 100644
--- a/src/common-lib/logging.h
+++ b/src/common-lib/logging.h
@@ -54,6 +54,7 @@ Q_DECLARE_LOGGING_CATEGORY(LogGraphics)
 Q_DECLARE_LOGGING_CATEGORY(LogWaylandDebug)
 Q_DECLARE_LOGGING_CATEGORY(LogQml)
 Q_DECLARE_LOGGING_CATEGORY(LogNotifications)
+Q_DECLARE_LOGGING_CATEGORY(LogRuntime)
 Q_DECLARE_LOGGING_CATEGORY(LogQmlRuntime)
 Q_DECLARE_LOGGING_CATEGORY(LogQmlIpc)
 Q_DECLARE_LOGGING_CATEGORY(LogDeployment)
diff --git a/src/launcher-lib/qmlapplicationinterface.cpp b/src/launcher-lib/dbusapplicationinterface.cpp
index c5741fd9..ab505f81 100644
--- a/src/launcher-lib/qmlapplicationinterface.cpp
+++ b/src/launcher-lib/dbusapplicationinterface.cpp
@@ -51,9 +51,9 @@
 #include <QThread>
 
 #include "global.h"
-#include "qmlapplicationinterface.h"
-#include "qmlapplicationinterfaceextension.h"
-#include "qmlnotification.h"
+#include "dbusapplicationinterface.h"
+#include "dbusapplicationinterfaceextension.h"
+#include "dbusnotification.h"
 #include "notification.h"
 #include "ipcwrapperobject.h"
 #include "utilities.h"
@@ -63,19 +63,20 @@
 
 QT_BEGIN_NAMESPACE_AM
 
-QmlApplicationInterface *QmlApplicationInterface::s_instance = nullptr;
+DBusApplicationInterface *DBusApplicationInterface::s_instance = nullptr;
 
-QmlApplicationInterface::QmlApplicationInterface(const QString &dbusConnectionName, const QString &dbusNotificationBusName, QObject *parent)
+DBusApplicationInterface::DBusApplicationInterface(const QString &dbusConnectionName,
+                                                   const QString &dbusNotificationBusName, QObject *parent)
     : ApplicationInterface(parent)
     , m_connection(dbusConnectionName)
     , m_notificationConnection(dbusNotificationBusName)
 {
-    if (QmlApplicationInterface::s_instance)
-        qCritical("ERROR: only one instance of QmlApplicationInterface is allowed");
+    if (DBusApplicationInterface::s_instance)
+        qCritical("ERROR: only one instance of DBusApplicationInterface is allowed");
     s_instance = this;
 }
 
-bool QmlApplicationInterface::initialize(bool hasRuntime)
+bool DBusApplicationInterface::initialize(bool hasRuntime)
 {
     // we are working with very small delays in the milli-second range here, so a linear factor
     // to support valgrind would have to be very large and probably conflict with usage elsewhere
@@ -158,7 +159,7 @@ bool QmlApplicationInterface::initialize(bool hasRuntime)
         }
     }
 
-    QmlApplicationInterfaceExtension::initialize(m_connection);
+    DBusApplicationInterfaceExtension::initialize(m_connection);
 
     auto intentClientDBusInterface = new IntentClientDBusImplementation(m_connection.name());
     if (!IntentClient::createInstance(intentClientDBusInterface)) {
@@ -171,56 +172,56 @@ bool QmlApplicationInterface::initialize(bool hasRuntime)
     return ok;
 }
 
-QString QmlApplicationInterface::applicationId() const
+QString DBusApplicationInterface::applicationId() const
 {
     if (m_appId.isEmpty() && m_applicationIf->isValid())
         m_appId = m_applicationIf->property("applicationId").toString();
     return m_appId;
 }
 
-QVariantMap QmlApplicationInterface::name() const
+QVariantMap DBusApplicationInterface::name() const
 {
     return m_name;
 }
 
-QUrl QmlApplicationInterface::icon() const
+QUrl DBusApplicationInterface::icon() const
 {
     return QUrl::fromLocalFile(m_icon);
 }
 
-QString QmlApplicationInterface::version() const
+QString DBusApplicationInterface::version() const
 {
     return m_version;
 }
 
-Notification *QmlApplicationInterface::createNotification()
+Notification *DBusApplicationInterface::createNotification()
 {
-    QmlNotification *n = new QmlNotification(this, Notification::Dynamic);
+    DBusNotification *n = new DBusNotification(this, Notification::Dynamic);
     return n;
 }
 
-void QmlApplicationInterface::acknowledgeQuit() const
+void DBusApplicationInterface::acknowledgeQuit() const
 {
     QCoreApplication::instance()->quit();
 }
 
-void QmlApplicationInterface::finishedInitialization()
+void DBusApplicationInterface::finishedInitialization()
 {
     if (m_applicationIf->isValid())
         m_applicationIf->asyncCall(qSL("finishedInitialization"));
 }
 
-QVariantMap QmlApplicationInterface::systemProperties() const
+QVariantMap DBusApplicationInterface::systemProperties() const
 {
     return m_systemProperties;
 }
 
-QVariantMap QmlApplicationInterface::applicationProperties() const
+QVariantMap DBusApplicationInterface::applicationProperties() const
 {
     return m_applicationProperties;
 }
 
-uint QmlApplicationInterface::notificationShow(QmlNotification *n)
+uint DBusApplicationInterface::notificationShow(DBusNotification *n)
 {
     if (n && m_notifyIf && m_notifyIf->isValid()) {
         QDBusReply<uint> newId = m_notifyIf->call(qSL("Notify"), applicationId(), n->notificationId(),
@@ -236,16 +237,16 @@ uint QmlApplicationInterface::notificationShow(QmlNotification *n)
 }
 
 
-void QmlApplicationInterface::notificationClose(QmlNotification *n)
+void DBusApplicationInterface::notificationClose(DBusNotification *n)
 {
     if (n && m_notifyIf && m_notifyIf->isValid())
         m_notifyIf->asyncCall(qSL("CloseNotification"), n->notificationId());
 }
 
-void QmlApplicationInterface::notificationClosed(uint notificationId, uint reason)
+void DBusApplicationInterface::notificationClosed(uint notificationId, uint reason)
 {
     qDebug("Notification was closed signal: %u", notificationId);
-    for (const QPointer<QmlNotification> &n : m_allNotifications) {
+    for (const QPointer<DBusNotification> &n : m_allNotifications) {
         if (n->notificationId() == notificationId) {
             n->libnotifyNotificationClosed(reason);
             m_allNotifications.removeAll(n);
@@ -254,10 +255,10 @@ void QmlApplicationInterface::notificationClosed(uint notificationId, uint reaso
     }
 }
 
-void QmlApplicationInterface::notificationActionTriggered(uint notificationId, const QString &actionId)
+void DBusApplicationInterface::notificationActionTriggered(uint notificationId, const QString &actionId)
 {
     qDebug("Notification action triggered signal: %u %s", notificationId, qPrintable(actionId));
-    for (const QPointer<QmlNotification> &n : m_allNotifications) {
+    for (const QPointer<DBusNotification> &n : m_allNotifications) {
         if (n->notificationId() == notificationId) {
             n->libnotifyActionInvoked(actionId);
             break;
diff --git a/src/launcher-lib/qmlapplicationinterface.h b/src/launcher-lib/dbusapplicationinterface.h
index 74cf7389..ed70058d 100644
--- a/src/launcher-lib/qmlapplicationinterface.h
+++ b/src/launcher-lib/dbusapplicationinterface.h
@@ -54,20 +54,20 @@ QT_FORWARD_DECLARE_CLASS(QDBusInterface)
 
 QT_BEGIN_NAMESPACE_AM
 
-class QmlNotification;
+class DBusNotification;
 class Notification;
 class IntentClientRequest;
 class Controller;
-class QmlApplicationInterfaceExtension;
+class DBusApplicationInterfaceExtension;
 
 
-class QmlApplicationInterface : public ApplicationInterface
+class DBusApplicationInterface : public ApplicationInterface
 {
     Q_OBJECT
     Q_CLASSINFO("AM-QmlType", "QtApplicationManager.Application/ApplicationInterface 2.0 UNCREATABLE")
 
 public:
-    explicit QmlApplicationInterface(const QString &dbusConnectionName,
+    explicit DBusApplicationInterface(const QString &dbusConnectionName,
                                      const QString &dbusNotificationBusName, QObject *parent = nullptr);
     bool initialize(bool hasRuntime = false);
 
@@ -89,8 +89,8 @@ private:
                                    const QString &mimeType, const QVariantMap &runtimeParams,
                                    const QVariantMap systemProperties);
 
-    uint notificationShow(QmlNotification *n);
-    void notificationClose(QmlNotification *n);
+    uint notificationShow(DBusNotification *n);
+    void notificationClose(DBusNotification *n);
 
     QDBusConnection m_connection;
     QDBusConnection m_notificationConnection;
@@ -103,13 +103,13 @@ private:
     QString m_version;
     QVariantMap m_systemProperties;
     QVariantMap m_applicationProperties;
-    QVector<QPointer<QmlNotification> > m_allNotifications;
+    QVector<QPointer<DBusNotification> > m_allNotifications;
 
-    static QmlApplicationInterface *s_instance;
+    static DBusApplicationInterface *s_instance;
 
-    friend class QmlNotification;
+    friend class DBusNotification;
     friend class Controller;
-    friend class QmlApplicationInterfaceExtension;
+    friend class DBusApplicationInterfaceExtension;
 };
 
 QT_END_NAMESPACE_AM
diff --git a/src/launcher-lib/qmlapplicationinterfaceextension.cpp b/src/launcher-lib/dbusapplicationinterfaceextension.cpp
index 3b5067c0..080156ba 100644
--- a/src/launcher-lib/qmlapplicationinterfaceextension.cpp
+++ b/src/launcher-lib/dbusapplicationinterfaceextension.cpp
@@ -43,16 +43,16 @@
 #include <QDBusInterface>
 
 #include "logging.h"
-#include "qmlapplicationinterfaceextension.h"
-#include "qmlapplicationinterface.h"
+#include "dbusapplicationinterfaceextension.h"
+#include "dbusapplicationinterface.h"
 #include "ipcwrapperobject.h"
 
 QT_BEGIN_NAMESPACE_AM
 
-class QmlApplicationInterfaceExtensionPrivate
+class DBusApplicationInterfaceExtensionPrivate
 {
 public:
-    QmlApplicationInterfaceExtensionPrivate(const QDBusConnection &connection)
+    DBusApplicationInterfaceExtensionPrivate(const QDBusConnection &connection)
         : m_connection(connection)
     { }
 
@@ -60,58 +60,58 @@ public:
     QDBusConnection m_connection;
 };
 
-QmlApplicationInterfaceExtensionPrivate *QmlApplicationInterfaceExtension::d = nullptr;
+DBusApplicationInterfaceExtensionPrivate *DBusApplicationInterfaceExtension::d = nullptr;
 
-void QmlApplicationInterfaceExtension::initialize(const QDBusConnection &connection)
+void DBusApplicationInterfaceExtension::initialize(const QDBusConnection &connection)
 {
     if (!d)
-        d = new QmlApplicationInterfaceExtensionPrivate(connection);
+        d = new DBusApplicationInterfaceExtensionPrivate(connection);
 }
 
-QmlApplicationInterfaceExtension::QmlApplicationInterfaceExtension(QObject *parent)
+DBusApplicationInterfaceExtension::DBusApplicationInterfaceExtension(QObject *parent)
     : QObject(parent)
 {
     Q_ASSERT(d);
 
-    if (QmlApplicationInterface::s_instance->m_applicationIf) {
-        connect(QmlApplicationInterface::s_instance->m_applicationIf, SIGNAL(interfaceCreated(QString)),
+    if (DBusApplicationInterface::s_instance->m_applicationIf) {
+        connect(DBusApplicationInterface::s_instance->m_applicationIf, SIGNAL(interfaceCreated(QString)),
                      this, SLOT(onInterfaceCreated(QString)));
     } else {
         qCritical("ERROR: ApplicationInterface not initialized!");
     }
 }
 
-QmlApplicationInterfaceExtension::~QmlApplicationInterfaceExtension()
+DBusApplicationInterfaceExtension::~DBusApplicationInterfaceExtension()
 {
     d->m_interfaces.remove(m_name);
 
 }
 
-QString QmlApplicationInterfaceExtension::name() const
+QString DBusApplicationInterfaceExtension::name() const
 {
     return m_name;
 }
 
-bool QmlApplicationInterfaceExtension::isReady() const
+bool DBusApplicationInterfaceExtension::isReady() const
 {
     return m_object;
 }
 
-QObject *QmlApplicationInterfaceExtension::object() const
+QObject *DBusApplicationInterfaceExtension::object() const
 {
     return m_object;
 }
 
-void QmlApplicationInterfaceExtension::classBegin()
+void DBusApplicationInterfaceExtension::classBegin()
 {
 }
 
-void QmlApplicationInterfaceExtension::componentComplete()
+void DBusApplicationInterfaceExtension::componentComplete()
 {
     tryInit();
 }
 
-void QmlApplicationInterfaceExtension::tryInit()
+void DBusApplicationInterfaceExtension::tryInit()
 {
     if (m_name.isEmpty())
         return;
@@ -154,7 +154,7 @@ void QmlApplicationInterfaceExtension::tryInit()
     emit readyChanged();
 }
 
-void QmlApplicationInterfaceExtension::setName(const QString &name)
+void DBusApplicationInterfaceExtension::setName(const QString &name)
 {
     if (!m_complete) {
         m_name = name;
@@ -164,7 +164,7 @@ void QmlApplicationInterfaceExtension::setName(const QString &name)
     }
 }
 
-void QmlApplicationInterfaceExtension::onInterfaceCreated(const QString &interfaceName)
+void DBusApplicationInterfaceExtension::onInterfaceCreated(const QString &interfaceName)
 {
     if (m_name == interfaceName)
         tryInit();
diff --git a/src/launcher-lib/qmlapplicationinterfaceextension.h b/src/launcher-lib/dbusapplicationinterfaceextension.h
index 627f6899..0e18fa79 100644
--- a/src/launcher-lib/qmlapplicationinterfaceextension.h
+++ b/src/launcher-lib/dbusapplicationinterfaceextension.h
@@ -50,9 +50,9 @@ QT_FORWARD_DECLARE_CLASS(QDBusConnection)
 
 QT_BEGIN_NAMESPACE_AM
 
-class QmlApplicationInterfaceExtensionPrivate;
+class DBusApplicationInterfaceExtensionPrivate;
 
-class QmlApplicationInterfaceExtension : public QObject, public QQmlParserStatus
+class DBusApplicationInterfaceExtension : public QObject, public QQmlParserStatus
 {
     Q_OBJECT
     Q_CLASSINFO("AM-QmlType", "QtApplicationManager.SystemUI/ApplicationInterfaceExtension 2.0")
@@ -65,8 +65,8 @@ class QmlApplicationInterfaceExtension : public QObject, public QQmlParserStatus
 public:
     static void initialize(const QDBusConnection &connection);
 
-    explicit QmlApplicationInterfaceExtension(QObject *parent = nullptr);
-    ~QmlApplicationInterfaceExtension() override;
+    explicit DBusApplicationInterfaceExtension(QObject *parent = nullptr);
+    ~DBusApplicationInterfaceExtension() override;
 
     QString name() const;
     bool isReady() const;
@@ -89,7 +89,7 @@ signals:
 private:
     void tryInit();
 
-    static QmlApplicationInterfaceExtensionPrivate *d;
+    static DBusApplicationInterfaceExtensionPrivate *d;
     QString m_name;
     QObject *m_object = nullptr;
     bool m_complete = false;
diff --git a/src/launcher-lib/qmlnotification.cpp b/src/launcher-lib/dbusnotification.cpp
index 869f7bd2..2042c765 100644
--- a/src/launcher-lib/qmlnotification.cpp
+++ b/src/launcher-lib/dbusnotification.cpp
@@ -40,25 +40,30 @@
 **
 ****************************************************************************/
 
-#include "qmlnotification.h"
-#include "qmlapplicationinterface.h"
+#include "dbusnotification.h"
+#include "dbusapplicationinterface.h"
 
 QT_BEGIN_NAMESPACE_AM
 
-QmlNotification::QmlNotification(QObject *parent, ConstructionMode mode)
+DBusNotification::DBusNotification(QObject *parent, ConstructionMode mode)
     : Notification(parent, mode)
 { }
 
-void QmlNotification::libnotifyClose()
+DBusNotification *DBusNotification::create(QObject *parent)
 {
-    if (QmlApplicationInterface::s_instance)
-        QmlApplicationInterface::s_instance->notificationClose(this);
+    return new DBusNotification(parent, QtAM::Notification::Dynamic);
 }
 
-uint QmlNotification::libnotifyShow()
+void DBusNotification::libnotifyClose()
 {
-    if (QmlApplicationInterface::s_instance)
-        return QmlApplicationInterface::s_instance->notificationShow(this);
+    if (DBusApplicationInterface::s_instance)
+        DBusApplicationInterface::s_instance->notificationClose(this);
+}
+
+uint DBusNotification::libnotifyShow()
+{
+    if (DBusApplicationInterface::s_instance)
+        return DBusApplicationInterface::s_instance->notificationShow(this);
     return 0;
 }
 
diff --git a/src/launcher-lib/qmlnotification.h b/src/launcher-lib/dbusnotification.h
index a358dd52..18d03d39 100644
--- a/src/launcher-lib/qmlnotification.h
+++ b/src/launcher-lib/dbusnotification.h
@@ -47,18 +47,20 @@
 
 QT_BEGIN_NAMESPACE_AM
 
-class QmlApplicationInterface;
+class DBusApplicationInterface;
 
-class QmlNotification : public Notification // clazy:exclude=missing-qobject-macro
+class DBusNotification : public Notification // clazy:exclude=missing-qobject-macro
 {
 public:
-    QmlNotification(QObject *parent = nullptr, Notification::ConstructionMode mode = Notification::Declarative);
+    DBusNotification(QObject *parent = nullptr, Notification::ConstructionMode mode = Notification::Declarative);
+
+    static DBusNotification *create(QObject *parent = nullptr);
 
 protected:
     uint libnotifyShow() override;
     void libnotifyClose() override;
 
-    friend class QmlApplicationInterface;
+    friend class DBusApplicationInterface;
 };
 
 QT_END_NAMESPACE_AM
diff --git a/src/launcher-lib/launcher-lib.pro b/src/launcher-lib/launcher-lib.pro
index df00d155..80c70d53 100644
--- a/src/launcher-lib/launcher-lib.pro
+++ b/src/launcher-lib/launcher-lib.pro
@@ -20,10 +20,10 @@ CONFIG -= create_cmake
 DBUS_INTERFACES += ../dbus-lib/io.qt.applicationmanager.intentinterface.xml
 
 SOURCES += \
-    qmlapplicationinterface.cpp \
+    dbusapplicationinterface.cpp \
     ipcwrapperobject.cpp \
-    qmlapplicationinterfaceextension.cpp \
-    qmlnotification.cpp \
+    dbusapplicationinterfaceextension.cpp \
+    dbusnotification.cpp \
     launchermain.cpp \
     intentclientdbusimplementation.cpp
 
@@ -40,11 +40,11 @@ SOURCES += \
 }
 
 HEADERS += \
-    qmlapplicationinterface.h \
+    dbusapplicationinterface.h \
     ipcwrapperobject.h \
     ipcwrapperobject_p.h \
-    qmlapplicationinterfaceextension.h \
-    qmlnotification.h \
+    dbusapplicationinterfaceextension.h \
+    dbusnotification.h \
     launchermain.h \
     intentclientdbusimplementation.h
 
diff --git a/src/launcher-lib/launchermain.cpp b/src/launcher-lib/launchermain.cpp
index 9febd4bd..a5417916 100644
--- a/src/launcher-lib/launchermain.cpp
+++ b/src/launcher-lib/launchermain.cpp
@@ -254,7 +254,7 @@ void LauncherMain::setupDBusConnections() Q_DECL_NOEXCEPT_EXPR(false)
     if (!dbusConnection.isConnected())
         throw Exception("could not connect to the P2P D-Bus via: %1").arg(m_dbusAddressP2P);
 
-    qCDebug(LogQmlRuntime) << "Connected to the P2P D-Bus via:" << m_dbusAddressP2P;
+    qCDebug(LogRuntime) << "Connected to the P2P D-Bus via:" << m_dbusAddressP2P;
 
     if (!m_dbusAddressNotifications.isEmpty()) {
         if (m_dbusAddressNotifications == qL1S("system"))
@@ -267,7 +267,7 @@ void LauncherMain::setupDBusConnections() Q_DECL_NOEXCEPT_EXPR(false)
         if (!dbusConnection.isConnected())
             throw Exception("could not connect to the Notification D-Bus via: %1").arg(m_dbusAddressNotifications);
 
-        qCDebug(LogQmlRuntime) << "Connected to the Notification D-Bus via:" << m_dbusAddressNotifications;
+        qCDebug(LogRuntime) << "Connected to the Notification D-Bus via:" << m_dbusAddressNotifications;
     } else {
         qCWarning(LogDeployment) << "Notifications are not supported by this configuration";
     }
diff --git a/src/manager-lib/applicationmanager.cpp b/src/manager-lib/applicationmanager.cpp
index 35eb1c65..5a391185 100644
--- a/src/manager-lib/applicationmanager.cpp
+++ b/src/manager-lib/applicationmanager.cpp
@@ -721,7 +721,7 @@ bool ApplicationManager::startApplicationInternal(const QString &appId, const QS
             else if (hasStdioRedirections)
                 cannotUseQuickLaunch = "standard I/O is redirected";
             else if (!app->runtimeParameters().value(qSL("environmentVariables")).toMap().isEmpty())
-                cannotUseQuickLaunch = "the app requests customs environment variables";
+                cannotUseQuickLaunch = "the app requests custom environment variables";
             else if (app->info()->openGLConfiguration() != runtimeManager->systemOpenGLConfiguration())
                 cannotUseQuickLaunch = "the app requests a custom OpenGL configuration";
 
diff --git a/src/shared-main-lib/sharedmain.cpp b/src/shared-main-lib/sharedmain.cpp
index c23b25c6..f34fcdea 100644
--- a/src/shared-main-lib/sharedmain.cpp
+++ b/src/shared-main-lib/sharedmain.cpp
@@ -154,23 +154,26 @@ void SharedMain::setupIconTheme(const QStringList &themeSearchPaths, const QStri
 
 void SharedMain::setupQmlDebugging(bool qmlDebugging)
 {
-    bool hasJSDebugArg = !static_cast<QCoreApplicationPrivate *>(QObjectPrivate::get(qApp))->qmljsDebugArgumentsString().isEmpty();
+    bool hasJSDebugArg = !static_cast<QCoreApplicationPrivate *>
+                         (QObjectPrivate::get(qApp))->qmljsDebugArgumentsString().isEmpty();
 
     if (hasJSDebugArg || qmlDebugging) {
 #if !defined(QT_NO_QML_DEBUGGER)
         m_debuggingEnabler = new QQmlDebuggingEnabler(true);
         if (!QLoggingCategory::defaultCategory()->isDebugEnabled()) {
-            qCCritical(LogQmlRuntime) << "The default 'debug' logging category was disabled. "
-                                         "Re-enabling it for the QML Debugger interface to work correctly.";
+            qCCritical(LogRuntime) << "The default 'debug' logging category was disabled. "
+                                      "Re-enabling it for the QML Debugger interface to work correctly.";
             QLoggingCategory::defaultCategory()->setEnabled(QtDebugMsg, true);
         }
 #else
-        qCWarning(LogSystem) << "The --qml-debug/-qmljsdebugger options are ignored, because Qt was built without support for QML Debugging!";
+        qCWarning(LogSystem) << "The --qml-debug/-qmljsdebugger options are ignored, "
+                                "because Qt was built without support for QML Debugging!";
 #endif
     }
 }
 
-void SharedMain::setupLogging(bool verbose, const QStringList &loggingRules, const QString &messagePattern, const QVariant &useAMConsoleLogger)
+void SharedMain::setupLogging(bool verbose, const QStringList &loggingRules,
+                              const QString &messagePattern, const QVariant &useAMConsoleLogger)
 {
     const QStringList rules = verbose ? QStringList() << qSL("*=true") << qSL("qt.*.debug=false")
                                       : loggingRules.isEmpty() ? QStringList(qSL("*.debug=false"))
diff --git a/src/tools/dumpqmltypes/dumpqmltypes.cpp b/src/tools/dumpqmltypes/dumpqmltypes.cpp
index 01ec748f..ddc52326 100644
--- a/src/tools/dumpqmltypes/dumpqmltypes.cpp
+++ b/src/tools/dumpqmltypes/dumpqmltypes.cpp
@@ -45,8 +45,8 @@
 #include <QtAppManWindow/windowmanager.h>
 #include <QtAppManWindow/window.h>
 #include <QtAppManWindow/windowitem.h>
-#include <QtAppManLauncher/qmlapplicationinterface.h>
-#include <QtAppManLauncher/qmlapplicationinterfaceextension.h>
+#include <QtAppManLauncher/dbusapplicationinterface.h>
+#include <QtAppManLauncher/dbusapplicationinterfaceextension.h>
 #include <QtAppManLauncher/private/applicationmanagerwindow_p.h>
 #include <QtAppManIntentServer/intent.h>
 #include <QtAppManIntentServer/intentserver.h>
@@ -82,8 +82,8 @@ static const QVector<const QMetaObject *> all = {
     &AbstractRuntime::staticMetaObject,
     &AbstractContainer::staticMetaObject,
     &Notification::staticMetaObject,
-    &QmlApplicationInterface::staticMetaObject,
-    &QmlApplicationInterfaceExtension::staticMetaObject,
+    &DBusApplicationInterface::staticMetaObject,
+    &DBusApplicationInterfaceExtension::staticMetaObject,
     &ApplicationManagerWindow::staticMetaObject,
     &ApplicationModel::staticMetaObject,
     &Am::staticMetaObject,
diff --git a/src/tools/launcher-qml/launcher-qml.cpp b/src/tools/launcher-qml/launcher-qml.cpp
index fdb9776d..b34d8af0 100644
--- a/src/tools/launcher-qml/launcher-qml.cpp
+++ b/src/tools/launcher-qml/launcher-qml.cpp
@@ -74,9 +74,9 @@
 #  include <QCoreApplication>
 #endif
 
-#include "qmlapplicationinterface.h"
-#include "qmlapplicationinterfaceextension.h"
-#include "qmlnotification.h"
+#include "dbusapplicationinterface.h"
+#include "dbusapplicationinterfaceextension.h"
+#include "dbusnotification.h"
 #include "notification.h"
 #include "qtyaml.h"
 #include "global.h"
@@ -210,8 +210,9 @@ Controller::Controller(LauncherMain *launcher, bool quickLaunched, const QPair<Q
 #if !defined(AM_HEADLESS)
     qmlRegisterType<ApplicationManagerWindow>("QtApplicationManager.Application", 2, 0, "ApplicationManagerWindow");
 #endif
-    qmlRegisterType<QmlNotification>("QtApplicationManager", 2, 0, "Notification");
-    qmlRegisterType<QmlApplicationInterfaceExtension>("QtApplicationManager.Application", 2, 0, "ApplicationInterfaceExtension");
+    qmlRegisterType<DBusNotification>("QtApplicationManager", 2, 0, "Notification");
+    qmlRegisterType<DBusApplicationInterfaceExtension>("QtApplicationManager.Application", 2, 0,
+                                                       "ApplicationInterfaceExtension");
 
     // monitor-lib
     qmlRegisterType<CpuStatus>("QtApplicationManager", 2, 0, "CpuStatus");
@@ -300,9 +301,9 @@ Controller::Controller(LauncherMain *launcher, bool quickLaunched, const QPair<Q
     }
 
     if (directLoad.first.isEmpty()) {
-        m_applicationInterface = new QmlApplicationInterface(launcher->p2pDBusName(),
+        m_applicationInterface = new DBusApplicationInterface(launcher->p2pDBusName(),
                                                              launcher->notificationDBusName(), this);
-        connect(m_applicationInterface, &QmlApplicationInterface::startApplication,
+        connect(m_applicationInterface, &DBusApplicationInterface::startApplication,
                 this, &Controller::startApplication);
         if (!m_applicationInterface->initialize(true))
             throw Exception("Could not connect to the application manager's ApplicationInterface on the peer D-Bus");
diff --git a/src/tools/launcher-qml/launcher-qml_p.h b/src/tools/launcher-qml/launcher-qml_p.h
index abacfa57..10bed12a 100644
--- a/src/tools/launcher-qml/launcher-qml_p.h
+++ b/src/tools/launcher-qml/launcher-qml_p.h
@@ -68,7 +68,7 @@ protected:
 
 
 class LauncherMain;
-class QmlApplicationInterface;
+class DBusApplicationInterface;
 
 class Controller : public QObject
 {
@@ -85,7 +85,7 @@ public slots:
 
 private:
     QQmlApplicationEngine m_engine;
-    QmlApplicationInterface *m_applicationInterface = nullptr;
+    DBusApplicationInterface *m_applicationInterface = nullptr;
     QVariantMap m_configuration;
     bool m_launched = false;
     bool m_quickLaunched;