DBus PropertiesChanged signal not being emitted for *Length PropertiesChanged

bim9262 · bim9262 · commit ac691ef8c908 · 2022-12-23T14:34:53.000-06:00
Similarly to what @ammgws noted in dunst-project#765, for `paused`, the various Length PropertiesChanged were not emitting PropertiesChanged when notifications were opened/closed. This change makes sure that these values are always kept up to date.
diff --git a/src/dbus.c b/src/dbus.c
@@ -694,6 +694,73 @@ static struct notification *dbus_message_to_notification(const gchar *sender, GV
         return n;
 }
 
+void signal_length_propertieschanged()
+{
+
+        static unsigned int last_displayed = 0;
+        static unsigned int last_history = 0;
+        static unsigned int last_waiting = 0;
+
+        if (!dbus_conn)
+                return;
+
+        GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT);
+        GVariantBuilder *invalidated_builder = g_variant_builder_new(G_VARIANT_TYPE_STRING_ARRAY);
+
+        unsigned int displayed = queues_length_displayed();
+        unsigned int history = queues_length_history();
+        unsigned int waiting = queues_length_waiting();
+        bool properties_changed = false;
+
+        if (last_displayed != displayed) {
+                g_variant_builder_add(builder,
+                                      "{sv}",
+                                      "displayedLength", g_variant_new_uint32(displayed));
+                last_displayed = displayed;
+                properties_changed = true;
+        }
+
+        if (last_history != history) {
+                g_variant_builder_add(builder,
+                                      "{sv}",
+                                      "historyLength", g_variant_new_uint32(history));
+                last_history = history;
+                properties_changed = true;
+        }
+        if (last_waiting != waiting) {
+                g_variant_builder_add(builder,
+                                      "{sv}",
+                                      "waitingLength", g_variant_new_uint32(waiting));
+                last_waiting = waiting;
+                properties_changed = true;
+        }
+
+        if (properties_changed) {
+                GVariant *body = g_variant_new("(sa{sv}as)",
+                                               DUNST_IFAC,
+                                               builder,
+                                               invalidated_builder);
+
+                GError *err = NULL;
+
+                g_dbus_connection_emit_signal(dbus_conn,
+                                              NULL,
+                                              FDN_PATH,
+                                              PROPERTIES_IFAC,
+                                              "PropertiesChanged",
+                                              body,
+                                              &err);
+                                
+                if (err) {
+                        LOG_W("Unable to emit signal: %s", err->message);
+                        g_error_free(err);
+                }
+        }
+
+        g_clear_pointer(&builder, g_variant_builder_unref);
+        g_clear_pointer(&invalidated_builder, g_variant_builder_unref);
+}
+
 static void dbus_cb_Notify(
                 GDBusConnection *connection,
                 const gchar *sender,
@@ -886,21 +953,24 @@ gboolean dbus_cb_dunst_Properties_Set(GDBusConnection *connection,
                 dunst_status(S_RUNNING, !g_variant_get_boolean(value));
                 wake_up();
 
-                GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
-                GVariantBuilder *invalidated_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
+                GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT);
+                GVariantBuilder *invalidated_builder = g_variant_builder_new(G_VARIANT_TYPE_STRING_ARRAY);
                 g_variant_builder_add(builder,
                                       "{sv}",
                                       "paused", g_variant_new_boolean(g_variant_get_boolean(value)));
                 g_dbus_connection_emit_signal(connection,
                                               NULL,
                                               object_path,
-                                              "org.freedesktop.DBus.Properties",
+                                              PROPERTIES_IFAC,
                                               "PropertiesChanged",
                                               g_variant_new("(sa{sv}as)",
                                                             interface_name,
                                                             builder,
                                                             invalidated_builder),
                                               NULL);
+
+                g_clear_pointer(&builder, g_variant_builder_unref);
+                g_clear_pointer(&invalidated_builder, g_variant_builder_unref);
                 return true;
         }
 
diff --git a/src/dbus.h b/src/dbus.h
@@ -20,6 +20,7 @@ int dbus_init(void);
 void dbus_teardown(int id);
 void signal_notification_closed(struct notification *n, enum reason reason);
 void signal_action_invoked(const struct notification *n, const char *identifier);
+void signal_length_propertieschanged();
 
 #endif
 /* vim: set ft=c tabstop=8 shiftwidth=8 expandtab textwidth=0: */
diff --git a/src/queues.c b/src/queues.c
@@ -547,6 +547,7 @@ void queues_update(struct dunst_status status, gint64 time)
                         }
                 }
         }
+        signal_length_propertieschanged();
 }
 
 /* see queues.h */
diff --git a/test/dbus.c b/test/dbus.c
@@ -21,6 +21,14 @@ struct signal_actioninvoked {
         GDBusConnection *conn;
 };
 
+struct signal_propertieschanged {
+        gchar *interface;
+        GVariant *array_dict_sv_data;
+        GVariant *array_s_data;
+        guint subscription_id;
+        GDBusConnection *conn;
+};
+
 struct signal_closed {
         guint32 id;
         guint32 reason;
@@ -81,6 +89,73 @@ void dbus_signal_unsubscribe_actioninvoked(struct signal_actioninvoked *actionin
         actioninvoked->subscription_id = -1;
 }
 
+void dbus_signal_cb_propertieschanged(GDBusConnection *connection,
+                                  const gchar *sender_name,
+                                  const gchar *object_path,
+                                  const gchar *interface_name,
+                                  const gchar *signal_name,
+                                  GVariant *parameters,
+                                  gpointer user_data)
+{
+        g_return_if_fail(user_data);
+
+        gchar *interface;
+        GVariant *array_dict_sv_data;
+        GVariant *array_s_data;
+
+        struct signal_propertieschanged *sig = (struct signal_propertieschanged*) user_data;
+
+        g_variant_get(parameters, "(s@a{sv}@as)", &interface, &array_dict_sv_data, &array_s_data);
+
+        if (g_strcmp0(interface, DUNST_IFAC) == 0) {
+                sig->interface = interface;
+                sig->array_dict_sv_data = array_dict_sv_data;
+                sig->array_s_data = array_s_data;
+        }
+
+}
+
+void dbus_signal_subscribe_propertieschanged(struct signal_propertieschanged *propertieschanged)
+{
+        assert(propertieschanged);
+
+        propertieschanged->conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+        propertieschanged->subscription_id =
+                g_dbus_connection_signal_subscribe(
+                        // GDBusConnection *connection,
+                        propertieschanged->conn,
+                        // const gchar *sender,
+                        FDN_NAME,
+                        // const gchar *interface_name,
+                        PROPERTIES_IFAC,
+                        // const gchar *member,
+                        "PropertiesChanged",
+                        // const gchar *object_path,
+                        FDN_PATH,
+                        // const gchar *arg0,
+                        NULL,
+                        // GDBusSignalFlags flags,
+                        G_DBUS_SIGNAL_FLAGS_NONE,
+                        // GDBusSignalCallback callback,
+                        dbus_signal_cb_propertieschanged,
+                        // gpointer user_data,
+                        propertieschanged,
+                        // GDestroyNotify user_data_free_func
+                        NULL);
+
+}
+
+void dbus_signal_unsubscribe_propertieschanged(struct signal_propertieschanged *propertieschanged)
+{
+        assert(propertieschanged);
+
+        g_dbus_connection_signal_unsubscribe(propertieschanged->conn, propertieschanged->subscription_id);
+        g_object_unref(propertieschanged->conn);
+
+        propertieschanged->conn = NULL;
+        propertieschanged->subscription_id = -1;
+}
+
 void dbus_signal_cb_closed(GDBusConnection *connection,
                  const gchar *sender_name,
                  const gchar *object_path,
@@ -740,6 +815,47 @@ TEST test_signal_actioninvoked(void)
         PASS();
 }
 
+TEST test_signal_length_propertieschanged(void)
+{
+        struct dbus_notification *n_dbus;
+        struct signal_propertieschanged sig = {NULL, NULL, NULL, -1};
+
+        dbus_signal_subscribe_propertieschanged(&sig);
+
+        n_dbus = dbus_notification_new();
+        n_dbus->app_name = "dunstteststack";
+        n_dbus->app_icon = "NONE2";
+        n_dbus->summary = "Headline for New";
+        n_dbus->body = "Text";
+        g_hash_table_insert(n_dbus->actions, g_strdup("actionkey"), g_strdup("Print this text"));
+
+        guint id;
+        ASSERT(dbus_notification_fire(n_dbus, &id));
+        ASSERT(id != 0);
+
+        queues_update(STATUS_NORMAL, time_monotonic_now());
+
+        uint waiting = 0;
+        while (!sig.interface && waiting < 2000) {
+                usleep(500);
+                waiting++;
+        }
+
+        ASSERT_STR_EQ(sig.interface, DUNST_IFAC);
+
+        guint32 displayed_length;
+        g_variant_lookup(sig.array_dict_sv_data, "displayedLength", "u", &displayed_length);
+
+        ASSERT_EQ(displayed_length, queues_length_displayed());
+
+        g_free(sig.interface);
+        g_variant_unref(sig.array_dict_sv_data);
+        g_variant_unref(sig.array_s_data);
+        dbus_notification_free(n_dbus);
+        dbus_signal_unsubscribe_propertieschanged(&sig);
+        PASS();
+}
+
 TEST test_close_and_signal(void)
 {
         GVariant *data, *ret;
@@ -928,6 +1044,7 @@ gpointer run_threaded_tests(gpointer data)
         RUN_TESTp(test_server_caps, MARKUP_NO);
         RUN_TEST(test_close_and_signal);
         RUN_TEST(test_signal_actioninvoked);
+        RUN_TEST(test_signal_length_propertieschanged);
         RUN_TEST(test_timeout_overflow);
         RUN_TEST(test_override_dbus_timeout);
         RUN_TEST(test_match_dbus_timeout);

Original file line number	Diff line number	Diff line change
`@@ -547,6 +547,7 @@ void queues_update(struct dunst_status status, gint64 time)`
`547`	`547`	`}`
`548`	`548`	`}`
`549`	`549`	`}`
	`550`	`+ signal_length_propertieschanged();`
`550`	`551`	`}`
`551`	`552`
`552`	`553`	`/* see queues.h */`