Knowledge Base (Posts about notifications)

Send desktop notification to other user

bgstack15 — Tue, 19 Aug 2025 12:49:00 GMT

Main workflow

Here are some notes about sending desktop notifications to a different user, perhaps even on a different system.

ssh destinationhostname

Find something with the dbus session bus address.

eval $( /bin/grep -sozZe '^DBUS_SESSION_BUS_ADDRESS=[a-zA-Z0-9:=,/-]*$' /proc/*/environ | tr '\0' '\n' | sort -u | grep -i dbus_session_ )

On my desktops, I know the session is using fluxbox (except for that one XFCE system).

eval $( sudo /bin/grep -sozZe '^DBUS_SESSION_BUS_ADDRESS=[a-zA-Z0-9:=,/-]*$' /proc/$( pidof fluxbox )/environ )
export DISPLAY=:0

Find the user running fluxbox, and merge in to current user the xauth.

sudo su - "$( stat -c '%U' "/proc/$( pidof fluxbox )" )" -c "xauth extract - :0" | xauth merge -

Technically this next command makes a new notification-daemon process, but that is acceptable to me.

notify-send "Hello world"

References

Weblinks

Additional reading

I cannot remember for sure if I used any commands from here, but this is fantastic reading, as always: Desktop notifications - ArchWiki

notification-daemon start from dbus

bgstack15 — Wed, 15 Nov 2023 14:29:02 GMT

I use Fluxbox as my graphical desktop environment, and a hodgepodge of various applications to accomplish all the small pieces of using a desktop computer. I use notification-daemon, a small, generic utility for displaying notifications that one might send with:

notify-send "Hello world" --hint "STRING:action-icons:" acction "numlock-on=Yes" --action "numlock-off=No" --icon "battery-low" --expire-time 0

Yes, that is nonsensical. But it shows a few of the features. But if you run that when notification-daemon is not running, you get this error:

(notify-send:19364): libnotify-WARNING **: 17:33:59.890: Failed to connect to proxy
Actions are not supported by this notifications server. Displaying non-interactively.
GDBus.Error:org.freedesktop.DBus.Error.ServiceUnknown: The name org.freedesktop.Notifications was not provided by any .service files

You can always just run /usr/lib/notification-daemon/notification-daemon & in ~/.fluxbox/startup like most people. I learned though, after examining the xfce4-notifyd package, that you really just need this file installed:

# File /usr/share/dbus-1/services/com.example.Notifications.service
[D-BUS Service]
Name=org.freedesktop.Notifications
Exec=/usr/lib/notification-daemon/notification-daemon

And then dbus, which is always running because I've had to embrace the darkness, always keeps notification-daemon running. I'm surprised this file wasn't included in the notification-daemon package, but I'm guessing it's a systemd/GNOME thing to always have that running and us edge case users are not considered a valid use case.

Sample colorized icon in desktop notification from browser

bgstack15 — Sat, 11 Nov 2023 14:28:50 GMT

I am considering adding desktop notifications to my fork of InfCloud, and to do that I had to learn how to send desktop notifications. MDN did not disappoint!

You'll see that I do some very basic find-button logic to add the click function. Of course this is boilerplate and won't look exactly the same whenever I get around to adding it to InfCloud/CalDAVZap.

files/2023/11/listings/notifications.html (Source)

	`<html>`
	`<header>`
	`<title>Example page</title>`
	`<script src="notifications.js">`
	`</script>`
	`</header>`
	`<body>`
	`<h1>example</h1>`
	`Lorem ipsum, etc.`
	`<button>Notify me!</button>`
	`</body>`
	`<footer>`
	`</footer>`
	`</html>`

files/2023/11/listings/notifications.js (Source)

	`// vim: set et ts=3 sw=3 sts=3:`
	`// Startdate: 2023-11-09 18:36`
	`// Purpose: Reference implementation for sending a notification with a colorized image from this server`
	`// Reference:`
	`// https://developer.mozilla.org/en-US/docs/Web/API/Notifications_API/Using_the_Notifications_API`
	`// https://www.w3docs.com/snippets/html/how-to-display-base64-images-in-html.html`
	`// https://stackoverflow.com/questions/28450471/convert-inline-svg-to-base64-string`

	`const img = "/calendar/images/banner_calendar.svg";`
	`const notification_attempts = 10;`
	`const notification_ms = 200;`
	`// Due to how browsers/css work with colors, you can pass #000000 or web safe color names.`
	`var colors = Array("red","orange","yellow","green","blue","purple","black","white","brown");`

	`function colorizeSvg(inSvg, oldColor, newColor) {`
	// In case we have to do more than `s//g` in the future.
	`return inSvg.replaceAll(oldColor, newColor);`
	`}`

	`function SendColorizedNotification(_title, _body, _icon, _tag, _color) {`
	`// given _icon as path on server, get contents and adjust the main color in it to desired color.`
	`// The 585858 is the specific color of the calendar.svg we intend to replace.`
	`const xhr = new XMLHttpRequest();`
	`xhr.open("GET",_icon);`
	`xhr.onload = () => {`
	`newSvg = colorizeSvg(xhr.responseText,"#585858",_color);`
	`encodedData = window.btoa(newSvg); // turn it into the base64 stream`
	`encodedData = "data:image/svg+xml;base64," + encodedData; // prepend the type of stream`
	`SendNotification(_title, _body, encodedData, _tag, _color);`
	`}`
	`xhr.send();`
	`}`

	`function SendNotification(_title, _body, _icon, _tag) {`
	`// From: https://developer.mozilla.org/en-US/docs/Web/API/notification`
	`if (!("Notification" in window)) {`
	`// Check if the browser supports notifications`
	`alert("This browser does not support desktop notification");`
	`} else if (Notification.permission === "granted") {`
	`// Check whether notification permissions have already been granted;`
	`// if so, create a notification`
	`const notification = new Notification(String(_title), { tag: _tag, body: _body, icon: _icon });`
	`// …`
	`} else if (Notification.permission !== "denied") {`
	`// We need to ask the user for permission`
	`Notification.requestPermission().then((permission) => {`
	`// If the user accepts, let's create a notification`
	`if (permission === "granted") {`
	`const notification = new Notification(String(_title), { tag: _tag, body: _body, icon: _icon });`
	`// …`
	`}`
	`});`
	`}`
	`// At last, if the user has denied notifications, and you`
	`// want to be respectful there is no need to bother them anymore.`
	`}`

	`function SendNotificationManyTimes(_title, _body, _icon, _tag) {`
	`// From: https://developer.mozilla.org/en-US/docs/Web/API/Notifications_API/Using_the_Notifications_API`
	`if (Notification?.permission === "granted") {`
	`// If the user agreed to get notified`
	`// Let's try to send ten notifications`
	`let i = 0;`
	`// Using an interval cause some browsers (including Firefox) are blocking notifications if there are too much in a certain time.`
	`const interval = setInterval(() => {`
	`// Thanks to the tag, we should only see the "Hi! 9" notification`
	`const n = new Notification(String(_title), { tag: _tag, body: _body, icon: _icon });`
	//const n = new Notification(`Hi! breakfast ${i}`, { tag: "soManyNotification", body: "this is body?", icon: img });
	`if (i === (notification_attempts-1)) {`
	`clearInterval(interval);`
	`}`
	`i++;`
	`}, notification_ms);`
	`} else if (Notification && Notification.permission !== "denied") {`
	`// If the user hasn't told if they want to be notified or not`
	`// Note: because of Chrome, we are not sure the permission property`
	`// is set, therefore it's unsafe to check for the "default" value.`
	`Notification.requestPermission().then((status) => {`
	`// If the user said okay`
	`if (status === "granted") {`
	`let i = 0;`
	`// Using an interval cause some browsers (including Firefox) are blocking notifications if there are too much in a certain time.`
	`const interval = setInterval(() => {`
	`// Thanks to the tag, we should only see the "Hi! 9" notification`
	`const n = new Notification(String(_title), { tag: _tag, body: _body, icon: _icon });`
	`if (i === (notification_attempts-1)) {`
	`clearInterval(interval);`
	`}`
	`i++;`
	`}, notification_ms);`
	`} else {`
	`// Otherwise, we can fallback to a regular modal alert`
	`alert(String(_title)+": "+String(_body));`
	`}`
	`});`
	`} else {`
	`// If the user refuses to get notified, we can fallback to a regular modal alert`
	`alert(String(_title)+": "+String(_body));`
	`}`
	`}`

	`function getRandomColor() {`
	`return colors[Math.floor(Math.random()*colors.length)];`
	`}`

	`window.addEventListener("load", () => {`
	`const button = document.querySelector("button");`
	`button.addEventListener("click", () => {`
	`SendColorizedNotification("sample calendar appointment","in 10 minutes",img,"",getRandomColor());`
	`});`
	`});`

Helper script: pulsemixer-notification

bgstack15 — Fri, 06 Oct 2023 13:18:32 GMT

Story

Due to a minor hardware problem where my sound card keeps jumping from aplay -l position 0 to position 1, my wine malfunctioned with audio. I set the specific card to use in the winecfg tab for Audio. After a reboot (and the alsa card position switched again), winecfg would crash on the Audio tab and I was unable to figure how to wipe the settings back to all defaults. This wine audio problem meant everything in wine that uses audio (every game) crashes. It was frustrating.

So I bit the bullet and installed pulseaudio on my Devuan GNU+Linux desktop. It was a matter of adding start-pulseaudio-x11 & to ~/.fluxbox/startup. I learned you need to keep alsa-utils and alsamixergui installed. Pulseaudio sits on top of alsa instead of replacing it.

There is a great program named pulsemixer that is a very powerful TUI and CLI tool for controlling your inputs and outputs. But I still needed alsamixer to disable the "auto-mute" when I plug in headphones, because I accidentally discovered a few years ago that if sound comes out of both speakers and headphones, it makes my life easier. I'm probably weird for that reason (and dozens of others), but I like it and I'm going to keep it that way, and it takes alsamixer to control that. (Take that, ... atheists? pulseaudio peeps anyways.)

So, pulsemixer does provide a great, simple way to toggle mute, and change volume up and down. I was only missing notifications about changing the volume.

Configuring other apps

volumeicon

I still use volumeicon but now I have configured middle-click to "open mixer," with mixer defined as pulsemixer --togle-mute. I found that while the volumeicon can still use its built-in "Mute Volume" setting, it mutes it on the alsa level, which mutes the master volume in pulseaudio, but it cannot unmute that pulseaudio master volume. So it is now always muted until I use pulsemixer.

I also had to disable volumeicon from handling the XF86AudioRaiseVolume keypresses. For that, I modified my fluxbox config.

fluxbox

For bare pulsemixer control you can just run:

122 :Exec pulsemixer --change-volume -5
123 :Exec pulsemixer --change-volume +5
121 :Exec pulsemixer --toggle-mute

Which worked well but it doesn't have a cute little popup telling me what the current volume level is. So I had to write the following script, and configure fluxbox to use it.

121 :Exec pulsemixer-notification toggle
122 :Exec pulsemixer-notification down
123 :Exec pulsemixer-notification up

The script

Explanation

This script displays a relative volume level (0/33/66/100) and muted symbol. It will always unmute if you change volume, which is the behavior I expect because that's how alsa handled volume. A neat little feature is that it uses a notification ID, so it can replace it if you're scrolling up on the volume; it will just replace the current notification instead of slowly (1.25s per step) trickling through them.

Listing

files/2023/10/listings/pulsemixer-notification (Source)

#!/bin/sh
# File: pulsemixer-notification
# Location: /usr/bin
# Author: bgstack15
# Startdate: 2023-10-04-4 09:06
# SPDX-License-Identifier: GPL-3.0
# Title: pulsemixer wrapper script that includes notifications
# Package: bgscripts
# Purpose: wrap around pulsemixer hotkey invocations to include status notifications
# History:
# Usage:
#    In ~/.fluxbox/keys:
#       121 :Exec pulsemixer-notification toggle
#       122 :Exec pulsemixer-notification down
#       123 :Exec pulsemixer-notification up
# Reference:
# Improve:
# Dependencies:
#    devuan-dep: pulsemixer, pulseaudio, notify-send
# Documentation:

# Load configuration
test -z "${devtty}" && devtty=/dev/null
test -z "${PN_TEMPFILE}" && PN_TEMPFILE=~/.cache/audio.temp
test -z "${PN_STEP}" && PN_STEP=3
test -z "${PN_EXPIRE_MS}" && PN_EXPIRE_MS=1250
test -f "${HOME}/.config/pulsemixer-notification" && . "${HOME}/.config/pulsemixer-notification"
test -f "/etc/pulsemixer-notification.conf" && . "/etc/pulsemixer-notification.conf"

# runtime
exec 1>>"${devtty}"
action="${1}"
unset icon vol relative_level message replacestring

case "${action}" in
   toggle)
      pulsemixer --toggle-mute
      case "$( pulsemixer --get-mute )" in
         0)
            action="unmute"
            ;;
         1)
            icon="audio-volume-muted"
            message="muted"
            ;;
      esac
      ;;
   up) pulsemixer --unmute ; pulsemixer --change-volume +"${PN_STEP}" ;;
   down) pulsemixer --unmute ; pulsemixer --change-volume -"${PN_STEP}" ;;
   *)
      echo "unknown: ${action}"
      ;;
esac

get_vol_level() {
   vol="$( pulsemixer --get-volume | awk '{print $1}' )"
   is_low="$( printf '%s\n' "${vol}<=33" | bc )"
   is_med="$( printf '%s\n' "(${vol}<=66)*(${vol}>33)" | bc )"
   is_hih="$( printf '%s\n' "${vol}>66" | bc )"
   is_off="$( printf '%s\n' "${vol}==0" | bc )"
   test "${is_low}" = "1" && printf '%s' "low" && return 0
   test "${is_med}" = "1" && printf '%s' "medium" && return 0
   test "${is_hih}" = "1" && printf '%s' "high" && return 0
   test "${is_off}" = "1" && printf '%s' "muted" && return 0
}

# awk: cheat and just use left-side volume of stereo volume.
vol="$( pulsemixer --get-volume | awk '{print $1}' )"
relative_level="$( get_vol_level )"

case "${action}" in
   up|down)
      icon="audio-volume-${relative_level}"
      message="${vol}"
      ;;
   unmute)
      icon="audio-volume-${relative_level}"
      message="unmuted"
      ;;
esac

test -f "${PN_TEMPFILE}" && replacestring="--replace-id=$( cat "${PN_TEMPFILE}" 2>/dev/null )"
# leave replacestring unquoted in case it is empty
notify-send ${replacestring} --icon "${icon}" --transient "${message}" --urgency low --expire-time "${PN_EXPIRE_MS}" --print-id > "${PN_TEMPFILE}"

Compile FreeFileSync with desktop notification support

bgstack15 — Thu, 27 May 2021 12:35:25 GMT

FreeFileSync is a great graphical file sync tool. I talk about it a lot. Today, I'm sharing a small patch I hacked after stealing from the fabulous arch wiki.

diff -aur 11.9-1/FreeFileSync/Source/Makefile 11.9-2/FreeFileSync/Source/Makefile
--- 11.9-1/FreeFileSync/Source/Makefile 2021-05-06 16:24:53.987902373 -0400
+++ 11.9-2/FreeFileSync/Source/Makefile 2021-05-06 17:09:31.512474440 -0400
@@ -21,6 +22,13 @@
 #treat as system headers so that warnings are hidden:
 cxxFlags  += -isystem/usr/include/gtk-3.0

+with_notifications ?= NO
+ifeq ($(with_notifications),YES)
+# package libglibmm-2.4-dev or glibmm24-devel
+cxxFlags  += `pkg-config --cflags giomm-2.4` -Dwith_notifications
+linkFlags += `pkg-config --libs   giomm-2.4`
+endif
+
 #support for SELinux (optional)
 SELINUX_EXISTING=$(shell pkg-config --exists libselinux && echo YES)
 ifeq ($(SELINUX_EXISTING),YES)
diff -aur 11.9-1/FreeFileSync/Source/ui/progress_indicator.cpp 11.9-2/FreeFileSync/Source/ui/progress_indicator.cpp
--- 11.9-1/FreeFileSync/Source/ui/progress_indicator.cpp    2021-05-06 15:20:34.286831934 -0400
+++ 11.9-2/FreeFileSync/Source/ui/progress_indicator.cpp    2021-05-06 17:11:45.486004158 -0400
@@ -32,6 +32,9 @@
 #include "../perf_check.h"
 #include "../icon_buffer.h"

+#ifdef with_notifications
+#include<giomm-2.4/giomm.h>
+#endif

 using namespace zen;
 using namespace fff;
@@ -1359,6 +1362,22 @@
     pnl_.m_staticTextPhase->SetLabel(getSyncResultLabel(syncResult));
     //pnl_.m_bitmapStatus->SetToolTip(); -> redundant

+#ifdef with_notifications
+    // Desktop notification for Linux
+    char title[] = "FreeFileSync";
+    // from https://stackoverflow.com/a/12097772
+    std::wstring ssR {getSyncResultLabel(syncResult)};
+    std::string body;
+    std::transform(ssR.begin(), ssR.end(), std::back_inserter(body), [] (wchar_t c){ return (char)c;});
+    char icon[] = "freefilesync";
+    auto Application = Gio::Application::create("org.zenju.freefilesync", Gio::APPLICATION_FLAGS_NONE);
+    Application->register_application();
+    auto Notification = Gio::Notification::create(title);
+    Notification->set_body(body);
+    auto Icon = Gio::ThemedIcon::create(icon);
+    Notification->set_icon (Icon);
+    Application->send_notification(Notification);
+#endif
     //show status on Windows 7 taskbar
     if (taskbar_.get())
         switch (syncResult)

The gist of the patch is that it uses the glibmm 2.4 library to make the bare minimum connection to the notification daemon. That's pretty much it. It took me more time to compile this than hack the logic (particularly with the surely weak type conversion) required. So for the niche crowd who tolerates the notification daemon on dbus, and use the same software as me, here you go. On Fedora, the dependency package is pkgconfig(giomm-2.4) (glibmm24-devel) and on Devuan it's libglibmm-2.4-dev.

References

Weblinks

The patch upstream location
Desktop notifications#C++ on the Arch wiki

Send desktop notifications through ssh X forwarding

bgstack15 — Sun, 28 Mar 2021 12:37:14 GMT

last updated: 2023-12-05

Thanks directly to a user at StackExchange! If you have desktop notifications on your ssh server that you wish to display on your local X server, you can accomplish that with a few steps. In the session you intend to forward desktop notifications, you need to make sure the DBUS_* environment variables are set. From Unix.SE:

START="dbus-launch --exit-with-session"
# set dbus for remote SSH connections
if [ -n "$SSH_CLIENT" -a -n "$DISPLAY" ]; then
   machine_id=$(LANGUAGE=C hostnamectl|grep 'Machine ID:'| sed 's/^.*: //')
   x_display=$(echo $DISPLAY|sed 's/^.*:\([0-9]\+\)\(\.[0-9]\+\)*$/\1/')
   dbus_session_file="$HOME/.dbus/session-bus/${machine_id}-${x_display}"
   if [ -r "$dbus_session_file" ]; then
      export $(grep '^DBUS.*=' "$dbus_session_file")
      # check if PID still running, if not launch dbus
      ps $DBUS_SESSION_BUS_PID | tail -1 | grep dbus-daemon 1> /dev/null 2>&1
      [ "$?" != "0" ] && export $(${START}) 1> /dev/null 2>&1
   else
      export $(${START}) 1> /dev/null 2>&1
   fi
fi

I set this ~/bin/forward-notifications.sh, but the author places it directly in his ~/.bashrc. If this snippet is in a separate script the way I use it, you need to dot-source it.

. forward-notifications.sh

But you still also need at least one .service file that handles org.freedesktop.Notifications. I use Xfce on my X server system, so I just installed its notification library.

$ apt-file search .service | grep -i notif
xfce4-notifyd: /usr/lib/systemd/user/xfce4-notifyd.service
$ sudo apt-get install xfce4-notifyd

And then your notify-send or zenity --notification commands will work!