diff options
Diffstat (limited to 'QtDBus-Notifications-Implementation.patch')
| -rw-r--r-- | QtDBus-Notifications-Implementation.patch | 1172 |
1 files changed, 1172 insertions, 0 deletions
diff --git a/QtDBus-Notifications-Implementation.patch b/QtDBus-Notifications-Implementation.patch new file mode 100644 index 000000000000..559adc3d49ea --- /dev/null +++ b/QtDBus-Notifications-Implementation.patch @@ -0,0 +1,1172 @@ +diff --git a/Telegram/SourceFiles/platform/linux/linux_libnotify.cpp b/Telegram/SourceFiles/platform/linux/linux_libnotify.cpp +deleted file mode 100644 +index 657c46075..000000000 +--- a/Telegram/SourceFiles/platform/linux/linux_libnotify.cpp ++++ /dev/null +@@ -1,110 +0,0 @@ +-/* +-This file is part of Telegram Desktop, +-the official desktop application for the Telegram messaging service. +- +-For license and copyright information please follow this link: +-https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL +-*/ +-#include "platform/linux/linux_libnotify.h" +- +-#include "platform/linux/linux_libs.h" +- +-namespace Platform { +-namespace Libs { +-namespace { +- +-bool loadLibrary(QLibrary &lib, const char *name, int version) { +- DEBUG_LOG(("Loading '%1' with version %2...").arg(QLatin1String(name)).arg(version)); +- lib.setFileNameAndVersion(QLatin1String(name), version); +- if (lib.load()) { +- DEBUG_LOG(("Loaded '%1' with version %2!").arg(QLatin1String(name)).arg(version)); +- return true; +- } +- lib.setFileNameAndVersion(QLatin1String(name), QString()); +- if (lib.load()) { +- DEBUG_LOG(("Loaded '%1' without version!").arg(QLatin1String(name))); +- return true; +- } +- LOG(("Could not load '%1' with version %2 :(").arg(QLatin1String(name)).arg(version)); +- return false; +-} +- +-} // namespace +- +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +-f_notify_init notify_init = nullptr; +-f_notify_uninit notify_uninit = nullptr; +-f_notify_is_initted notify_is_initted = nullptr; +-//f_notify_get_app_name notify_get_app_name = nullptr; +-//f_notify_set_app_name notify_set_app_name = nullptr; +-f_notify_get_server_caps notify_get_server_caps = nullptr; +-f_notify_get_server_info notify_get_server_info = nullptr; +- +-f_notify_notification_new notify_notification_new = nullptr; +-//f_notify_notification_update notify_notification_update = nullptr; +-f_notify_notification_show notify_notification_show = nullptr; +-//f_notify_notification_set_app_name notify_notification_set_app_name = nullptr; +-f_notify_notification_set_timeout notify_notification_set_timeout = nullptr; +-//f_notify_notification_set_category notify_notification_set_category = nullptr; +-//f_notify_notification_set_urgency notify_notification_set_urgency = nullptr; +-//f_notify_notification_set_icon_from_pixbuf notify_notification_set_icon_from_pixbuf = nullptr; +-f_notify_notification_set_image_from_pixbuf notify_notification_set_image_from_pixbuf = nullptr; +-//f_notify_notification_set_hint notify_notification_set_hint = nullptr; +-//f_notify_notification_set_hint_int32 notify_notification_set_hint_int32 = nullptr; +-//f_notify_notification_set_hint_uint32 notify_notification_set_hint_uint32 = nullptr; +-//f_notify_notification_set_hint_double notify_notification_set_hint_double = nullptr; +-f_notify_notification_set_hint_string notify_notification_set_hint_string = nullptr; +-//f_notify_notification_set_hint_byte notify_notification_set_hint_byte = nullptr; +-//f_notify_notification_set_hint_byte_array notify_notification_set_hint_byte_array = nullptr; +-//f_notify_notification_clear_hints notify_notification_clear_hints = nullptr; +-f_notify_notification_add_action notify_notification_add_action = nullptr; +-f_notify_notification_clear_actions notify_notification_clear_actions = nullptr; +-f_notify_notification_close notify_notification_close = nullptr; +-f_notify_notification_get_closed_reason notify_notification_get_closed_reason = nullptr; +- +-void startLibNotify() { +- DEBUG_LOG(("Loading libnotify")); +- +- QLibrary lib_notify; +- if (!loadLibrary(lib_notify, "notify", 4)) { +- if (!loadLibrary(lib_notify, "notify", 5)) { +- if (!loadLibrary(lib_notify, "notify", 1)) { +- return; +- } +- } +- } +- +- load(lib_notify, "notify_init", notify_init); +- load(lib_notify, "notify_uninit", notify_uninit); +- load(lib_notify, "notify_is_initted", notify_is_initted); +-// load(lib_notify, "notify_get_app_name", notify_get_app_name); +-// load(lib_notify, "notify_set_app_name", notify_set_app_name); +- load(lib_notify, "notify_get_server_caps", notify_get_server_caps); +- load(lib_notify, "notify_get_server_info", notify_get_server_info); +- +- load(lib_notify, "notify_notification_new", notify_notification_new); +-// load(lib_notify, "notify_notification_update", notify_notification_update); +- load(lib_notify, "notify_notification_show", notify_notification_show); +-// load(lib_notify, "notify_notification_set_app_name", notify_notification_set_app_name); +- load(lib_notify, "notify_notification_set_timeout", notify_notification_set_timeout); +-// load(lib_notify, "notify_notification_set_category", notify_notification_set_category); +-// load(lib_notify, "notify_notification_set_urgency", notify_notification_set_urgency); +-// load(lib_notify, "notify_notification_set_icon_from_pixbuf", notify_notification_set_icon_from_pixbuf); +- load(lib_notify, "notify_notification_set_image_from_pixbuf", notify_notification_set_image_from_pixbuf); +-// load(lib_notify, "notify_notification_set_hint", notify_notification_set_hint); +-// load(lib_notify, "notify_notification_set_hint_int32", notify_notification_set_hint_int32); +-// load(lib_notify, "notify_notification_set_hint_uint32", notify_notification_set_hint_uint32); +-// load(lib_notify, "notify_notification_set_hint_double", notify_notification_set_hint_double); +- load(lib_notify, "notify_notification_set_hint_string", notify_notification_set_hint_string); +-// load(lib_notify, "notify_notification_set_hint_byte", notify_notification_set_hint_byte); +-// load(lib_notify, "notify_notification_set_hint_byte_array", notify_notification_set_hint_byte_array); +-// load(lib_notify, "notify_notification_clear_hints", notify_notification_clear_hints); +- load(lib_notify, "notify_notification_add_action", notify_notification_add_action); +- load(lib_notify, "notify_notification_clear_actions", notify_notification_clear_actions); +- load(lib_notify, "notify_notification_close", notify_notification_close); +- load(lib_notify, "notify_notification_get_closed_reason", notify_notification_get_closed_reason); +-} +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION +- +-} // namespace Libs +-} // namespace Platform +diff --git a/Telegram/SourceFiles/platform/linux/linux_libnotify.h b/Telegram/SourceFiles/platform/linux/linux_libnotify.h +deleted file mode 100644 +index 6dcfd676a..000000000 +--- a/Telegram/SourceFiles/platform/linux/linux_libnotify.h ++++ /dev/null +@@ -1,120 +0,0 @@ +-/* +-This file is part of Telegram Desktop, +-the official desktop application for the Telegram messaging service. +- +-For license and copyright information please follow this link: +-https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL +-*/ +-#pragma once +- +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +-extern "C" { +-#undef signals +-#include <gtk/gtk.h> +-#define signals public +-} // extern "C" +- +-namespace Platform { +-namespace Libs { +- +-void startLibNotify(); +- +-constexpr gint NOTIFY_EXPIRES_DEFAULT = -1; +-constexpr gint NOTIFY_EXPIRES_NEVER = 0; +- +-struct NotifyNotification; +-typedef enum { +- NOTIFY_URGENCY_LOW, +- NOTIFY_URGENCY_NORMAL, +- NOTIFY_URGENCY_CRITICAL, +-} NotifyUrgency; +- +-using NotifyActionCallback = void (*)(NotifyNotification *notification, char *action, gpointer user_data); +- +-using f_notify_init = gboolean (*)(const char *app_name); +-extern f_notify_init notify_init; +- +-using f_notify_uninit = void (*)(void); +-extern f_notify_uninit notify_uninit; +- +-using f_notify_is_initted = gboolean (*)(void); +-extern f_notify_is_initted notify_is_initted; +- +-//using f_notify_get_app_name = const char* (*)(void); +-//extern f_notify_get_app_name notify_get_app_name; +- +-//using f_notify_set_app_name = void (*)(const char *app_name); +-//extern f_notify_set_app_name notify_set_app_name; +- +-using f_notify_get_server_caps = GList* (*)(void); +-extern f_notify_get_server_caps notify_get_server_caps; +- +-using f_notify_get_server_info = gboolean (*)(char **ret_name, char **ret_vendor, char **ret_version, char **ret_spec_version); +-extern f_notify_get_server_info notify_get_server_info; +- +-using f_notify_notification_new = NotifyNotification* (*)(const char *summary, const char *body, const char *icon); +-extern f_notify_notification_new notify_notification_new; +- +-//using f_notify_notification_update = gboolean (*)(NotifyNotification *notification, const char *summary, const char *body, const char *icon); +-//extern f_notify_notification_update notify_notification_update; +- +-using f_notify_notification_show = gboolean (*)(NotifyNotification *notification, GError **error); +-extern f_notify_notification_show notify_notification_show; +- +-//using f_notify_notification_set_app_name = void (*)(NotifyNotification *notification, const char *app_name); +-//extern f_notify_notification_set_app_name notify_notification_set_app_name; +- +-using f_notify_notification_set_timeout = void (*)(NotifyNotification *notification, gint timeout); +-extern f_notify_notification_set_timeout notify_notification_set_timeout; +- +-//using f_notify_notification_set_category = void (*)(NotifyNotification *notification, const char *category); +-//extern f_notify_notification_set_category notify_notification_set_category; +- +-//using f_notify_notification_set_urgency = void (*)(NotifyNotification *notification, NotifyUrgency urgency); +-//extern f_notify_notification_set_urgency notify_notification_set_urgency; +- +-//using f_notify_notification_set_icon_from_pixbuf = void (*)(NotifyNotification *notification, GdkPixbuf *icon); +-//extern f_notify_notification_set_icon_from_pixbuf notify_notification_set_icon_from_pixbuf; +- +-using f_notify_notification_set_image_from_pixbuf = void (*)(NotifyNotification *notification, GdkPixbuf *pixbuf); +-extern f_notify_notification_set_image_from_pixbuf notify_notification_set_image_from_pixbuf; +- +-//using f_notify_notification_set_hint = void (*)(NotifyNotification *notification, const char *key, GVariant *value); +-//extern f_notify_notification_set_hint notify_notification_set_hint; +- +-//using f_notify_notification_set_hint_int32 = void (*)(NotifyNotification *notification, const char *key, gint value); +-//extern f_notify_notification_set_hint_int32 notify_notification_set_hint_int32; +- +-//using f_notify_notification_set_hint_uint32 = void (*)(NotifyNotification *notification, const char *key, guint value); +-//extern f_notify_notification_set_hint_uint32 notify_notification_set_hint_uint32; +- +-//using f_notify_notification_set_hint_double = void (*)(NotifyNotification *notification, const char *key, gdouble value); +-//extern f_notify_notification_set_hint_double notify_notification_set_hint_double; +- +-using f_notify_notification_set_hint_string = void (*)(NotifyNotification *notification, const char *key, const char *value); +-extern f_notify_notification_set_hint_string notify_notification_set_hint_string; +- +-//using f_notify_notification_set_hint_byte = void (*)(NotifyNotification *notification, const char *key, guchar value); +-//extern f_notify_notification_set_hint_byte notify_notification_set_hint_byte; +- +-//using f_notify_notification_set_hint_byte_array = void (*)(NotifyNotification *notification, const char *key, const guchar *value, gsize len); +-//extern f_notify_notification_set_hint_byte_array notify_notification_set_hint_byte_array; +- +-//using f_notify_notification_clear_hints = void (*)(NotifyNotification *notification); +-//extern f_notify_notification_clear_hints notify_notification_clear_hints; +- +-using f_notify_notification_add_action = void (*)(NotifyNotification *notification, const char *action, const char *label, NotifyActionCallback callback, gpointer user_data, GFreeFunc free_func); +-extern f_notify_notification_add_action notify_notification_add_action; +- +-using f_notify_notification_clear_actions = void (*)(NotifyNotification *notification); +-extern f_notify_notification_clear_actions notify_notification_clear_actions; +- +-using f_notify_notification_close = gboolean (*)(NotifyNotification *notification, GError **error); +-extern f_notify_notification_close notify_notification_close; +- +-using f_notify_notification_get_closed_reason = gint (*)(const NotifyNotification *notification); +-extern f_notify_notification_get_closed_reason notify_notification_get_closed_reason; +- +-} // namespace Libs +-} // namespace Platform +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION +diff --git a/Telegram/SourceFiles/platform/linux/linux_libs.cpp b/Telegram/SourceFiles/platform/linux/linux_libs.cpp +index 5071d63d1..d60734e7c 100644 +--- a/Telegram/SourceFiles/platform/linux/linux_libs.cpp ++++ b/Telegram/SourceFiles/platform/linux/linux_libs.cpp +@@ -8,7 +8,6 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL + #include "platform/linux/linux_libs.h" + + #include "platform/linux/linux_gdk_helper.h" +-#include "platform/linux/linux_libnotify.h" + #include "platform/linux/linux_desktop_environment.h" + + #include <QtGui/QGuiApplication> +@@ -290,10 +289,6 @@ void start() { + } else { + LOG(("Could not load gtk-x11-2.0!")); + } +- +- if (gtkLoaded) { +- startLibNotify(); +- } + #endif // !TDESKTOP_DISABLE_GTK_INTEGRATION + } + +diff --git a/Telegram/SourceFiles/platform/linux/main_window_linux.cpp b/Telegram/SourceFiles/platform/linux/main_window_linux.cpp +index d076b90f3..13c9d20aa 100644 +--- a/Telegram/SourceFiles/platform/linux/main_window_linux.cpp ++++ b/Telegram/SourceFiles/platform/linux/main_window_linux.cpp +@@ -264,13 +264,6 @@ void MainWindow::psSetupTrayIcon() { + } + trayIcon->setIcon(icon); + +- // This is very important for native notifications via libnotify! +- // Some notification servers compose several notifications with a "Reply" +- // action into one and after that a click on "Reply" button does not call +- // the specified callback from any of the sent notification - libnotify +- // just ignores ibus messages, but Qt tray icon at least emits this signal. +- connect(trayIcon, SIGNAL(messageClicked()), this, SLOT(showFromTray())); +- + attachToTrayIcon(trayIcon); + } + updateIconCounters(); +diff --git a/Telegram/SourceFiles/platform/linux/notifications_manager_linux.cpp b/Telegram/SourceFiles/platform/linux/notifications_manager_linux.cpp +index 9b0dc1d65..211abf9fc 100644 +--- a/Telegram/SourceFiles/platform/linux/notifications_manager_linux.cpp ++++ b/Telegram/SourceFiles/platform/linux/notifications_manager_linux.cpp +@@ -7,389 +7,244 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL + */ + #include "platform/linux/notifications_manager_linux.h" + +-#include "window/notifications_utilities.h" +-#include "platform/linux/linux_libnotify.h" +-#include "platform/linux/linux_libs.h" + #include "history/history.h" + #include "lang/lang_keys.h" + #include "facades.h" + ++#include <QtCore/QBuffer> ++#include <QtDBus/QDBusConnection> ++#include <QtDBus/QDBusReply> ++ + namespace Platform { + namespace Notifications { +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +-namespace { +- +-bool LibNotifyLoaded() { +- return (Libs::notify_init != nullptr) +- && (Libs::notify_uninit != nullptr) +- && (Libs::notify_is_initted != nullptr) +-// && (Libs::notify_get_app_name != nullptr) +-// && (Libs::notify_set_app_name != nullptr) +- && (Libs::notify_get_server_caps != nullptr) +- && (Libs::notify_get_server_info != nullptr) +- && (Libs::notify_notification_new != nullptr) +-// && (Libs::notify_notification_update != nullptr) +- && (Libs::notify_notification_show != nullptr) +-// && (Libs::notify_notification_set_app_name != nullptr) +- && (Libs::notify_notification_set_timeout != nullptr) +-// && (Libs::notify_notification_set_category != nullptr) +-// && (Libs::notify_notification_set_urgency != nullptr) +-// && (Libs::notify_notification_set_icon_from_pixbuf != nullptr) +- && (Libs::notify_notification_set_image_from_pixbuf != nullptr) +-// && (Libs::notify_notification_set_hint != nullptr) +-// && (Libs::notify_notification_set_hint_int32 != nullptr) +-// && (Libs::notify_notification_set_hint_uint32 != nullptr) +-// && (Libs::notify_notification_set_hint_double != nullptr) +- && (Libs::notify_notification_set_hint_string != nullptr) +-// && (Libs::notify_notification_set_hint_byte != nullptr) +-// && (Libs::notify_notification_set_hint_byte_array != nullptr) +-// && (Libs::notify_notification_clear_hints != nullptr) +- && (Libs::notify_notification_add_action != nullptr) +- && (Libs::notify_notification_clear_actions != nullptr) +- && (Libs::notify_notification_close != nullptr) +- && (Libs::notify_notification_get_closed_reason != nullptr) +- && (Libs::g_object_ref_sink != nullptr) +- && (Libs::g_object_unref != nullptr) +- && (Libs::g_list_free_full != nullptr) +- && (Libs::g_error_free != nullptr) +- && (Libs::g_signal_connect_data != nullptr) +- && (Libs::g_signal_handler_disconnect != nullptr) +-// && (Libs::gdk_pixbuf_new_from_data != nullptr) +- && (Libs::gdk_pixbuf_new_from_file != nullptr); +-} +- +-QString escapeHtml(const QString &text) { +- auto result = QString(); +- auto copyFrom = 0, textSize = text.size(); +- auto data = text.constData(); +- for (auto i = 0; i != textSize; ++i) { +- auto ch = data[i]; +- if (ch == '<' || ch == '>' || ch == '&') { +- if (!copyFrom) { +- result.reserve(textSize * 5); +- } +- if (i > copyFrom) { +- result.append(data + copyFrom, i - copyFrom); +- } +- switch (ch.unicode()) { +- case '<': result.append(qstr("<")); break; +- case '>': result.append(qstr(">")); break; +- case '&': result.append(qstr("&")); break; +- } +- copyFrom = i + 1; +- } +- } +- if (copyFrom > 0) { +- result.append(data + copyFrom, textSize - copyFrom); +- return result; +- } +- return text; +-} + +-class NotificationData { +-public: +- NotificationData(const std::shared_ptr<Manager*> &guarded, const QString &title, const QString &body, const QStringList &capabilities, PeerId peerId, MsgId msgId) +- : _data(Libs::notify_notification_new(title.toUtf8().constData(), body.toUtf8().constData(), nullptr)) { +- if (valid()) { +- init(guarded, capabilities, peerId, msgId); +- } +- } +- bool valid() const { +- return (_data != nullptr); +- } +- NotificationData(const NotificationData &other) = delete; +- NotificationData &operator=(const NotificationData &other) = delete; +- NotificationData(NotificationData &&other) = delete; +- NotificationData &operator=(NotificationData &&other) = delete; +- +- void setImage(const QString &imagePath) { +- auto imagePathNative = QFile::encodeName(imagePath); +- if (auto pixbuf = Libs::gdk_pixbuf_new_from_file(imagePathNative.constData(), nullptr)) { +- Libs::notify_notification_set_image_from_pixbuf(_data, pixbuf); +- Libs::g_object_unref(Libs::g_object_cast(pixbuf)); +- } +- } +- bool show() { +- if (valid()) { +- GError *error = nullptr; ++constexpr auto kService = str_const("org.freedesktop.Notifications"); ++constexpr auto kObjectPath = str_const("/org/freedesktop/Notifications"); ++constexpr auto kInterface = kService; + +- Libs::notify_notification_show(_data, &error); +- if (!error) { +- return true; +- } ++NotificationData::NotificationData(const std::shared_ptr<Manager*> &guarded, const QString &title, const QString &subtitle, const QString &msg, PeerId peerId, MsgId msgId) ++: _notificationInterface(str_const_toString(kService), str_const_toString(kObjectPath), str_const_toString(kInterface)) ++, _specificationVersion(parseSpecificationVersion(getServerInformation())) ++, _weak(guarded) ++, _title(title) ++, _peerId(peerId) ++, _msgId(msgId) { ++ auto capabilities = getCapabilities(); ++ auto capabilitiesEnd = capabilities.end(); + +- logError(error); +- } +- return false; ++ if (!_specificationVersion.isNull()) { ++ DEBUG_LOG(("Notification daemon specification version: %1").arg(_specificationVersion.toString())); + } + +- bool close() { +- if (valid()) { +- GError *error = nullptr; +- Libs::notify_notification_close(_data, &error); +- if (!error) { +- return true; ++ if (!capabilities.empty()) { ++ QString capabilitiesString; ++ ++ for (const auto &capability : capabilities) { ++ if (!capabilitiesString.isEmpty()) { ++ capabilitiesString += qstr(", "); + } + +- logError(error); ++ capabilitiesString += capability; + } +- return false; +- } + +- ~NotificationData() { +- if (valid()) { +-// if (_handlerId > 0) { +-// Libs::g_signal_handler_disconnect(Libs::g_object_cast(_data), _handlerId); +-// } +-// Libs::notify_notification_clear_actions(_data); +- Libs::g_object_unref(Libs::g_object_cast(_data)); +- } ++ DEBUG_LOG(("Notification daemon capabilities: %1").arg(capabilitiesString)); + } + +-private: +- void init(const std::shared_ptr<Manager*> &guarded, const QStringList &capabilities, PeerId peerId, MsgId msgId) { +- if (capabilities.contains(qsl("append"))) { +- Libs::notify_notification_set_hint_string(_data, "append", "true"); +- } else if (capabilities.contains(qsl("x-canonical-append"))) { +- Libs::notify_notification_set_hint_string(_data, "x-canonical-append", "true"); +- } ++ if (ranges::find(capabilities, qsl("body-markup")) != capabilitiesEnd) { ++ _body = subtitle.isEmpty() ++ ? msg.toHtmlEscaped() ++ : qsl("<b>%1</b>\n%2").arg(subtitle.toHtmlEscaped()).arg(msg.toHtmlEscaped()); ++ } else { ++ _body = subtitle.isEmpty() ++ ? msg ++ : qsl("%1\n%2").arg(subtitle).arg(msg); ++ } + +- Libs::notify_notification_set_hint_string(_data, "desktop-entry", "kotatogramdesktop"); +- +- auto signalReceiver = Libs::g_object_cast(_data); +- auto signalHandler = G_CALLBACK(NotificationData::notificationClosed); +- auto signalName = "closed"; +- auto signalDataFreeMethod = &NotificationData::notificationDataFreeClosure; +- auto signalData = new NotificationDataStruct(guarded, peerId, msgId); +- _handlerId = Libs::g_signal_connect_helper(signalReceiver, signalName, signalHandler, signalData, signalDataFreeMethod); +- +- Libs::notify_notification_set_timeout(_data, Libs::NOTIFY_EXPIRES_DEFAULT); +- +- if ((*guarded)->hasActionsSupport()) { +- auto label = tr::lng_notification_reply(tr::now).toUtf8(); +- auto actionReceiver = _data; +- auto actionHandler = &NotificationData::notificationClicked; +- auto actionLabel = label.constData(); +- auto actionName = "default"; +- auto actionDataFreeMethod = &NotificationData::notificationDataFree; +- auto actionData = new NotificationDataStruct(guarded, peerId, msgId); +- Libs::notify_notification_add_action(actionReceiver, actionName, actionLabel, actionHandler, actionData, actionDataFreeMethod); +- } ++ if (ranges::find(capabilities, qsl("actions")) != capabilitiesEnd) { ++ // icon name according to https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html ++ _actions << "mail-reply-sender" << tr::lng_notification_reply(tr::now); ++ connect(&_notificationInterface, SIGNAL(ActionInvoked(uint, QString)), this, SLOT(notificationClicked(uint))); + } + +- void logError(GError *error) { +- LOG(("LibNotify Error: domain %1, code %2, message '%3'").arg(error->domain).arg(error->code).arg(QString::fromUtf8(error->message))); +- Libs::g_error_free(error); ++ if (ranges::find(capabilities, qsl("action-icons")) != capabilitiesEnd) { ++ _hints["action-icons"] = true; + } + +- struct NotificationDataStruct { +- NotificationDataStruct(const std::shared_ptr<Manager*> &guarded, PeerId peerId, MsgId msgId) +- : weak(guarded) +- , peerId(peerId) +- , msgId(msgId) { ++ // suppress system sound if telegram sound activated, otherwise use system sound ++ if (ranges::find(capabilities, qsl("sound")) != capabilitiesEnd) { ++ if (Global::SoundNotify()) { ++ _hints["suppress-sound"] = true; ++ } else { ++ // sound name according to http://0pointer.de/public/sound-naming-spec.html ++ _hints["sound-name"] = "message-new-instant"; + } +- +- std::weak_ptr<Manager*> weak; +- PeerId peerId = 0; +- MsgId msgId = 0; +- }; +- static void performOnMainQueue(NotificationDataStruct *data, FnMut<void(Manager *manager)> task) { +- const auto weak = data->weak; +- crl::on_main(weak, [=, task = std::move(task)]() mutable { +- task(*weak.lock()); +- }); +- } +- static void notificationDataFree(gpointer data) { +- auto notificationData = static_cast<NotificationDataStruct*>(data); +- delete notificationData; +- } +- static void notificationDataFreeClosure(gpointer data, GClosure *closure) { +- auto notificationData = static_cast<NotificationDataStruct*>(data); +- delete notificationData; +- } +- static void notificationClosed(Libs::NotifyNotification *notification, gpointer data) { +- auto closedReason = Libs::notify_notification_get_closed_reason(notification); +- auto notificationData = static_cast<NotificationDataStruct*>(data); +- performOnMainQueue(notificationData, [peerId = notificationData->peerId, msgId = notificationData->msgId](Manager *manager) { +- manager->clearNotification(peerId, msgId); +- }); +- } +- static void notificationClicked(Libs::NotifyNotification *notification, char *action, gpointer data) { +- auto notificationData = static_cast<NotificationDataStruct*>(data); +- performOnMainQueue(notificationData, [peerId = notificationData->peerId, msgId = notificationData->msgId](Manager *manager) { +- manager->notificationActivated(peerId, msgId); +- }); + } + +- Libs::NotifyNotification *_data = nullptr; +- gulong _handlerId = 0; ++ if (ranges::find(capabilities, qsl("x-canonical-append")) != capabilitiesEnd) { ++ _hints["x-canonical-append"] = "true"; ++ } + +-}; ++ _hints["category"] = "im.received"; ++ _hints["desktop-entry"] = "kotatogramdesktop"; + +-using Notification = std::shared_ptr<NotificationData>; ++ connect(&_notificationInterface, SIGNAL(NotificationClosed(uint, uint)), this, SLOT(notificationClosed(uint))); ++} + +-QString GetServerName() { +- if (!LibNotifyLoaded()) { +- return QString(); +- } +- if (!Libs::notify_is_initted() && !Libs::notify_init("Kotatogram Desktop")) { +- LOG(("LibNotify Error: failed to init!")); +- return QString(); +- } ++bool NotificationData::show() { ++ QDBusReply<uint> notifyReply = _notificationInterface.call("Notify", str_const_toString(AppName), uint(0), "kotatogram", _title, _body, _actions, _hints, -1); + +- gchar *name = nullptr; +- auto guard = gsl::finally([&name] { +- if (name) Libs::g_free(name); +- }); +- +- if (!Libs::notify_get_server_info(&name, nullptr, nullptr, nullptr)) { +- LOG(("LibNotify Error: could not get server name!")); +- return QString(); +- } +- if (!name) { +- LOG(("LibNotify Error: successfully got empty server name!")); +- return QString(); ++ if (notifyReply.isValid()) { ++ _notificationId = notifyReply.value(); ++ } else { ++ LOG(("Native notification error: %1").arg(notifyReply.error().message())); + } + +- auto result = QString::fromUtf8(static_cast<const char*>(name)); +- LOG(("Notifications Server: %1").arg(result)); +- +- return result; ++ return notifyReply.isValid(); + } + +-auto LibNotifyServerName = QString(); ++bool NotificationData::close() { ++ QDBusReply<void> closeReply = _notificationInterface.call("CloseNotification", _notificationId); + +-} // namespace +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION +- +-bool Supported() { +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +- static auto Checked = false; +- if (!Checked) { +- Checked = true; +- LibNotifyServerName = GetServerName(); ++ if (!closeReply.isValid()) { ++ LOG(("Native notification error: %1").arg(closeReply.error().message())); + } + +- return !LibNotifyServerName.isEmpty(); +-#else +- return false; +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION ++ return closeReply.isValid(); + } + +-std::unique_ptr<Window::Notifications::Manager> Create(Window::Notifications::System *system) { +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +- if (Global::NativeNotifications() && Supported()) { +- return std::make_unique<Manager>(system); +- } +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION +- return nullptr; +-} ++void NotificationData::setImage(const QString &imagePath) { ++ QString imageKey; + +-void Finish() { +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +- if (Libs::notify_is_initted && Libs::notify_uninit) { +- if (Libs::notify_is_initted()) { +- Libs::notify_uninit(); ++ if (!_specificationVersion.isNull()) { ++ const auto majorVersion = _specificationVersion.majorVersion(); ++ const auto minorVersion = _specificationVersion.majorVersion(); ++ ++ if ((majorVersion == 1 && minorVersion >= 2) || majorVersion > 1) { ++ imageKey = "image-data"; ++ } else if (majorVersion == 1 && minorVersion) { ++ imageKey = "image_data"; ++ } else if ((majorVersion == 1 && minorVersion < 1) || majorVersion < 1) { ++ imageKey = "icon_data"; ++ } else { ++ LOG(("Native notification error: unknown specification version")); ++ return; + } ++ } else { ++ LOG(("Native notification error: specification version is null")); ++ return; + } +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION +-} + +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +-class Manager::Private { +-public: +- using Type = Window::Notifications::CachedUserpics::Type; +- explicit Private(Type type) +- : _cachedUserpics(type) { +- } ++ auto image = QImage(imagePath).convertToFormat(QImage::Format_RGBA8888); ++ QByteArray imageBytes((const char*)image.constBits(), image.sizeInBytes()); + +- void init(Manager *manager); ++ ImageData imageData; ++ imageData.width = image.width(); ++ imageData.height = image.height(); ++ imageData.rowStride = image.bytesPerLine(); ++ imageData.hasAlpha = true; ++ imageData.bitsPerSample = 8; ++ imageData.channels = 4; ++ imageData.data = imageBytes; + +- void showNotification( +- not_null<PeerData*> peer, +- MsgId msgId, +- const QString &title, +- const QString &subtitle, +- const QString &msg, +- bool hideNameAndPhoto, +- bool hideReplyButton); +- void clearAll(); +- void clearFromHistory(not_null<History*> history); +- void clearNotification(PeerId peerId, MsgId msgId); ++ _hints[imageKey] = QVariant::fromValue(imageData); ++} + +- bool hasPoorSupport() const { +- return _poorSupported; +- } +- bool hasActionsSupport() const { +- return _actionsSupported; ++std::vector<QString> NotificationData::getServerInformation() { ++ std::vector<QString> serverInformation; ++ auto serverInformationReply = _notificationInterface.call("GetServerInformation"); ++ ++ if (serverInformationReply.type() == QDBusMessage::ReplyMessage) { ++ for (const auto &arg : serverInformationReply.arguments()) { ++ if (static_cast<QMetaType::Type>(arg.type()) == QMetaType::QString) { ++ serverInformation.push_back(arg.toString()); ++ } else { ++ LOG(("Native notification error: all elements in GetServerInformation should be strings")); ++ } ++ } ++ } else if (serverInformationReply.type() == QDBusMessage::ErrorMessage) { ++ LOG(("Native notification error: %1").arg(QDBusError(serverInformationReply).message())); ++ } else { ++ LOG(("Native notification error: error while getting information about notification daemon")); + } + +- ~Private(); ++ return serverInformation; ++} + +-private: +- QString escapeNotificationText(const QString &text) const; +- void showNextNotification(); ++std::vector<QString> NotificationData::getCapabilities() { ++ QDBusReply<QStringList> capabilitiesReply = _notificationInterface.call("GetCapabilities"); + +- struct QueuedNotification { +- PeerData *peer = nullptr; +- MsgId msgId = 0; +- QString title; +- QString body; +- bool hideNameAndPhoto = false; +- }; ++ if (capabilitiesReply.isValid()) { ++ return capabilitiesReply.value().toVector().toStdVector(); ++ } else { ++ LOG(("Native notification error: %1").arg(capabilitiesReply.error().message())); ++ } + +- QString _serverName; +- QStringList _capabilities; ++ return std::vector<QString>(); ++} + +- using QueuedNotifications = QList<QueuedNotification>; +- QueuedNotifications _queuedNotifications; ++QVersionNumber NotificationData::parseSpecificationVersion(const std::vector<QString> &serverInformation) { ++ if (serverInformation.size() >= 4) { ++ return QVersionNumber::fromString(serverInformation[3]); ++ } else { ++ LOG(("Native notification error: server information should have 4 elements")); ++ } + +- using Notifications = QMap<PeerId, QMap<MsgId, Notification>>; +- Notifications _notifications; ++ return QVersionNumber(); ++} + +- Window::Notifications::CachedUserpics _cachedUserpics; +- bool _actionsSupported = false; +- bool _markupSupported = false; +- bool _poorSupported = false; ++void NotificationData::performOnMainQueue(FnMut<void(Manager *manager)> task) { ++ const auto weak = _weak; ++ crl::on_main(weak, [=, task = std::move(task)]() mutable { ++ task(*weak.lock()); ++ }); ++} + +- std::shared_ptr<Manager*> _guarded; ++void NotificationData::notificationClosed(uint id) { ++ if (id == _notificationId) { ++ performOnMainQueue([peerId = _peerId, msgId = _msgId](Manager *manager) { ++ manager->clearNotification(peerId, msgId); ++ }); ++ } ++} + +-}; +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION ++void NotificationData::notificationClicked(uint id) { ++ if (id == _notificationId) { ++ performOnMainQueue([peerId = _peerId, msgId = _msgId](Manager *manager) { ++ manager->notificationActivated(peerId, msgId); ++ }); ++ } ++} + +-#ifndef TDESKTOP_DISABLE_GTK_INTEGRATION +-void Manager::Private::init(Manager *manager) { +- _guarded = std::make_shared<Manager*>(manager); ++QDBusArgument &operator<<(QDBusArgument &argument, const NotificationData::ImageData &imageData) { ++ argument.beginStructure(); ++ argument << imageData.width << imageData.height << imageData.rowStride << imageData.hasAlpha << imageData.bitsPerSample << imageData.channels << imageData.data; ++ argument.endStructure(); ++ return argument; ++} + +- if (auto capabilities = Libs::notify_get_server_caps()) { +- for (auto capability = capabilities; capability; capability = capability->next) { +- auto capabilityText = QString::fromUtf8(static_cast<const char*>(capability->data)); +- _capabilities.push_back(capabilityText); +- } +- Libs::g_list_free_full(capabilities, g_free); ++const QDBusArgument &operator>>(const QDBusArgument &argument, NotificationData::ImageData &imageData) { ++ argument.beginStructure(); ++ argument >> imageData.width >> imageData.height >> imageData.rowStride >> imageData.hasAlpha >> imageData.bitsPerSample >> imageData.channels >> imageData.data;; ++ argument.endStructure(); ++ return argument; ++} + +- LOG(("LibNotify capabilities: %1").arg(_capabilities.join(qstr(", ")))); +- if (_capabilities.contains(qsl("actions"))) { +- _actionsSupported = true; +- } else if (_capabilities.contains(qsl("body-markup"))) { +- _markupSupported = true; +- } +- } else { +- LOG(("LibNotify Error: could not get capabilities!")); ++auto NotificationDaemonRunning = false; ++bool Supported() { ++ static auto Checked = false; ++ if (!Checked) { ++ Checked = true; ++ NotificationDaemonRunning = QDBusInterface(str_const_toString(kService), str_const_toString(kObjectPath), str_const_toString(kInterface)).isValid(); + } + +- // Unity and other Notify OSD users handle desktop notifications +- // extremely poor, even without the ability to close() them. +- _serverName = LibNotifyServerName; +- Assert(!_serverName.isEmpty()); +- if (_serverName == qstr("notify-osd")) { +-// _poorSupported = true; +- _actionsSupported = false; +- } ++ return NotificationDaemonRunning; + } + +-QString Manager::Private::escapeNotificationText(const QString &text) const { +- return _markupSupported ? escapeHtml(text) : text; ++std::unique_ptr<Window::Notifications::Manager> Create(Window::Notifications::System *system) { ++ if (Global::NativeNotifications() && Supported()) { ++ return std::make_unique<Manager>(system); ++ } ++ return nullptr; + } + + void Manager::Private::showNotification( +@@ -400,93 +255,43 @@ void Manager::Private::showNotification( + const QString &msg, + bool hideNameAndPhoto, + bool hideReplyButton) { +- auto titleText = escapeNotificationText(title); +- auto subtitleText = escapeNotificationText(subtitle); +- auto msgText = escapeNotificationText(msg); +- if (_markupSupported && !subtitleText.isEmpty()) { +- subtitleText = qstr("<b>") + subtitleText + qstr("</b>"); +- } +- auto bodyText = subtitleText.isEmpty() ? msgText : (subtitleText + '\n' + msgText); +- +- QueuedNotification notification; +- notification.peer = peer; +- notification.msgId = msgId; +- notification.title = titleText; +- notification.body = bodyText; +- notification.hideNameAndPhoto = hideNameAndPhoto; +- _queuedNotifications.push_back(notification); +- +- showNextNotification(); +-} +- +-void Manager::Private::showNextNotification() { +- // Show only one notification at a time in Unity / Notify OSD. +- if (_poorSupported) { +- for (auto b = _notifications.begin(); !_notifications.isEmpty() && b->isEmpty();) { +- _notifications.erase(b); +- } +- if (!_notifications.isEmpty()) { +- return; +- } +- } +- +- QueuedNotification data; +- while (!_queuedNotifications.isEmpty()) { +- data = _queuedNotifications.front(); +- _queuedNotifications.pop_front(); +- if (data.peer) { +- break; +- } +- } +- if (!data.peer) { +- return; +- } +- +- auto peerId = data.peer->id; +- auto msgId = data.msgId; + auto notification = std::make_shared<NotificationData>( + _guarded, +- data.title, +- data.body, +- _capabilities, +- peerId, ++ title, ++ subtitle, ++ msg, ++ peer->id, + msgId); +- if (!notification->valid()) { +- return; +- } + +- const auto key = data.hideNameAndPhoto ++ const auto key = hideNameAndPhoto + ? InMemoryKey() +- : data.peer->userpicUniqueKey(); +- notification->setImage(_cachedUserpics.get(key, data.peer)); ++ :peer->userpicUniqueKey(); ++ notification->setImage(_cachedUserpics.get(key, peer)); + +- auto i = _notifications.find(peerId); ++ auto i = _notifications.find(peer->id); + if (i != _notifications.cend()) { + auto j = i->find(msgId); + if (j != i->cend()) { + auto oldNotification = j.value(); + i->erase(j); + oldNotification->close(); +- i = _notifications.find(peerId); ++ i = _notifications.find(peer->id); + } + } + if (i == _notifications.cend()) { +- i = _notifications.insert(peerId, QMap<MsgId, Notification>()); ++ i = _notifications.insert(peer->id, QMap<MsgId, Notification>()); + } +- _notifications[peerId].insert(msgId, notification); ++ _notifications[peer->id].insert(msgId, notification); + if (!notification->show()) { +- i = _notifications.find(peerId); ++ i = _notifications.find(peer->id); + if (i != _notifications.cend()) { + i->remove(msgId); + if (i->isEmpty()) _notifications.erase(i); + } +- showNextNotification(); + } + } + + void Manager::Private::clearAll() { +- _queuedNotifications.clear(); +- + auto temp = base::take(_notifications); + for_const (auto ¬ifications, temp) { + for_const (auto notification, notifications) { +@@ -496,14 +301,6 @@ void Manager::Private::clearAll() { + } + + void Manager::Private::clearFromHistory(not_null<History*> history) { +- for (auto i = _queuedNotifications.begin(); i != _queuedNotifications.end();) { +- if (i->peer == history->peer) { +- i = _queuedNotifications.erase(i); +- } else { +- ++i; +- } +- } +- + auto i = _notifications.find(history->peer->id); + if (i != _notifications.cend()) { + auto temp = base::take(i.value()); +@@ -513,8 +310,6 @@ void Manager::Private::clearFromHistory(not_null<History*> history) { + notification->close(); + } + } +- +- showNextNotification(); + } + + void Manager::Private::clearNotification(PeerId peerId, MsgId msgId) { +@@ -525,8 +320,6 @@ void Manager::Private::clearNotification(PeerId peerId, MsgId msgId) { + _notifications.erase(i); + } + } +- +- showNextNotification(); + } + + Manager::Private::~Private() { +@@ -534,22 +327,13 @@ Manager::Private::~Private() { + } + + Manager::Manager(Window::Notifications::System *system) : NativeManager(system) +-, _private(std::make_unique<Private>(Private::Type::Rounded)) { +- _private->init(this); ++, _private(std::make_unique<Private>(this, Private::Type::Rounded)) { + } + + void Manager::clearNotification(PeerId peerId, MsgId msgId) { + _private->clearNotification(peerId, msgId); + } + +-bool Manager::hasPoorSupport() const { +- return _private->hasPoorSupport(); +-} +- +-bool Manager::hasActionsSupport() const { +- return _private->hasActionsSupport(); +-} +- + Manager::~Manager() = default; + + void Manager::doShowNativeNotification( +@@ -577,7 +361,6 @@ void Manager::doClearAllFast() { + void Manager::doClearFromHistory(not_null<History*> history) { + _private->clearFromHistory(history); + } +-#endif // !TDESKTOP_DISABLE_GTK_INTEGRATION + + } // namespace Notifications + } // namespace Platform +diff --git a/Telegram/SourceFiles/platform/linux/notifications_manager_linux.h b/Telegram/SourceFiles/platform/linux/notifications_manager_linux.h +index f40204a56..1f87dbe28 100644 +--- a/Telegram/SourceFiles/platform/linux/notifications_manager_linux.h ++++ b/Telegram/SourceFiles/platform/linux/notifications_manager_linux.h +@@ -8,6 +8,11 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL + #pragma once + + #include "platform/platform_notifications_manager.h" ++#include "window/notifications_utilities.h" ++ ++#include <QtDBus/QDBusInterface> ++#include <QtDBus/QDBusArgument> ++#include <QtDBus/QDBusMetaType> + + namespace Platform { + namespace Notifications { +@@ -23,16 +28,62 @@ inline bool SkipToast() { + inline void FlashBounce() { + } + +-void Finish(); ++class NotificationData : public QObject { ++ Q_OBJECT ++ ++public: ++ NotificationData(const std::shared_ptr<Manager*> &guarded, const QString &title, const QString &subtitle, const QString &msg, PeerId peerId, MsgId msgId); ++ ++ NotificationData(const NotificationData &other) = delete; ++ NotificationData &operator=(const NotificationData &other) = delete; ++ NotificationData(NotificationData &&other) = delete; ++ NotificationData &operator=(NotificationData &&other) = delete; ++ ++ bool show(); ++ bool close(); ++ void setImage(const QString &imagePath); ++ ++ struct ImageData { ++ int width, height, rowStride; ++ bool hasAlpha; ++ int bitsPerSample, channels; ++ QByteArray data; ++ }; ++ ++private: ++ QDBusInterface _notificationInterface; ++ QVersionNumber _specificationVersion; ++ std::weak_ptr<Manager*> _weak; ++ ++ QString _title; ++ QString _body; ++ QStringList _actions; ++ QVariantMap _hints; ++ ++ uint _notificationId; ++ PeerId _peerId; ++ MsgId _msgId; ++ ++ std::vector<QString> getServerInformation(); ++ std::vector<QString> getCapabilities(); ++ QVersionNumber parseSpecificationVersion(const std::vector<QString> &serverInformation); ++ ++ void performOnMainQueue(FnMut<void(Manager *manager)> task); ++ ++private slots: ++ void notificationClosed(uint id); ++ void notificationClicked(uint id); ++}; ++ ++using Notification = std::shared_ptr<NotificationData>; ++ ++QDBusArgument &operator<<(QDBusArgument &argument, const NotificationData::ImageData &imageData); ++const QDBusArgument &operator>>(const QDBusArgument &argument, NotificationData::ImageData &imageData); + + class Manager : public Window::Notifications::NativeManager { + public: + Manager(Window::Notifications::System *system); +- + void clearNotification(PeerId peerId, MsgId msgId); +- bool hasPoorSupport() const; +- bool hasActionsSupport() const; +- + ~Manager(); + + protected: +@@ -53,5 +104,38 @@ private: + + }; + ++class Manager::Private { ++public: ++ using Type = Window::Notifications::CachedUserpics::Type; ++ explicit Private(Manager *manager, Type type) ++ : _cachedUserpics(type) ++ , _guarded(std::make_shared<Manager*>(manager)) { ++ qDBusRegisterMetaType<NotificationData::ImageData>(); ++ } ++ ++ void showNotification( ++ not_null<PeerData*> peer, ++ MsgId msgId, ++ const QString &title, ++ const QString &subtitle, ++ const QString &msg, ++ bool hideNameAndPhoto, ++ bool hideReplyButton); ++ void clearAll(); ++ void clearFromHistory(not_null<History*> history); ++ void clearNotification(PeerId peerId, MsgId msgId); ++ ++ ~Private(); ++ ++private: ++ using Notifications = QMap<PeerId, QMap<MsgId, Notification>>; ++ Notifications _notifications; ++ ++ Window::Notifications::CachedUserpics _cachedUserpics; ++ std::shared_ptr<Manager*> _guarded; ++}; ++ + } // namespace Notifications + } // namespace Platform ++ ++Q_DECLARE_METATYPE(Platform::Notifications::NotificationData::ImageData) +diff --git a/Telegram/SourceFiles/platform/linux/specific_linux.cpp b/Telegram/SourceFiles/platform/linux/specific_linux.cpp +index 68d07a55b..cc70426a1 100644 +--- a/Telegram/SourceFiles/platform/linux/specific_linux.cpp ++++ b/Telegram/SourceFiles/platform/linux/specific_linux.cpp +@@ -229,7 +229,6 @@ void start() { + } + + void finish() { +- Notifications::Finish(); + } + + void RegisterCustomScheme() { +diff --git a/Telegram/gyp/telegram/sources.txt b/Telegram/gyp/telegram/sources.txt +index e3ccb66db..1977e6f2f 100644 +--- a/Telegram/gyp/telegram/sources.txt ++++ b/Telegram/gyp/telegram/sources.txt +@@ -605,8 +605,6 @@ + <(src_loc)/platform/linux/linux_desktop_environment.h + <(src_loc)/platform/linux/linux_gdk_helper.cpp + <(src_loc)/platform/linux/linux_gdk_helper.h +-<(src_loc)/platform/linux/linux_libnotify.cpp +-<(src_loc)/platform/linux/linux_libnotify.h + <(src_loc)/platform/linux/linux_libs.cpp + <(src_loc)/platform/linux/linux_libs.h + <(src_loc)/platform/linux/file_utilities_linux.cpp |