Six ways to make a notification pop-up

UPDATED MAY 2013 to add Go and GObject methods to the existing Command Line and Python methods.
Originally published Feb 27, 2009.

There are several ways to create notifications in Ubuntu. The notify-OSD daemon draws the boxes and creates the notifications, so all these ways simply contact it and tell it what to do.

1. On the command line, use the notify-send command. This command is part of the libnotify-bin package. It's easy:

   $ notify-send -i /usr/share/icons/Tango/32x32/status/sunny.png \
                      "Notification Title" \
                      "This is the body"



2. More command line: dbus-send command does NOT work for notification. It does not support nested message variables. If it did, it should be something really close to this:

   dbus-send --session --dest=org.freedesktop.Notifications \
                            --type=method_call --reply-timeout=10000 \
                            /org/freedesktop/Notifications org.freedesktop.Notifications \
                            string:'Test Application' uint32:0 \
                            string: string:'Notification Title' \
                            string:'This is the body' \
                            array:string: dict:string: int32:10000



3. Using the Python2 or Python3 pynotify module:
   

   #!/usr/bin/env python
   """Python 2.5 script. Creates a Notification pop-up bubble"""
   import pynotify
   title = "Notification Title"
   text  = "This is the body"
   icon  = "/usr/share/icons/Tango/32x32/status/sunny.png"
   pynotify.init("Test Application")
   notification = pynotify.Notification(title, text, icon) 
   notification.set_urgency(pynotify.URGENCY_NORMAL)
   notification.show() 



4. Using the Python2 or Python3 dbus module:
   

   #!/usr/bin/env python
   """Python 2.5 script. Creates a Notification pop-up bubble"""
   import dbus
   item              = "org.freedesktop.Notifications"
   path              = "/org/freedesktop/Notifications"
   interface         = "org.freedesktop.Notifications"
   app_name          = "Test Application"
   id_num_to_replace = 0
   icon              = "/usr/share/icons/Tango/32x32/status/sunny.png"
   title             = "Notification Title"
   text              = "This is the body"
   actions_list      = ''
   hint              = ''
   time              = 5000   # Use seconds x 1000
   
   bus = dbus.SessionBus()
   notif = bus.get_object(item, path)
   notify = dbus.Interface(notif, interface)
   notify.Notify(app_name, id_num_to_replace, icon, title, text, actions_list, hint, time)



5. Using the Python3 GObject Introspection (gi) module:
   

   #!/usr/bin/env python3
   import gi.repository
   from gi.repository import Gio, GLib
   
   session_bus                = Gio.BusType.SESSION
   cancellable                = None
   proxy_property             = 0
   interface_properties_array = None
   destination                = "org.freedesktop.Notifications"
   path                       = "/org/freedesktop/Notifications"
   interface                  = destination
   method                     = "Notify"
   application_name           = "Test Application"
   title                      = "Notification Title"
   text                       = "This is the body"
   id_num_to_replace          = 0
   icon                       = "/usr/share/icons/Tango/32x32/status/sunny.png"
   actions_list               = []
   hints_dict                 = {}
   display_milliseconds       = 5000
   timeout                    = -1
   
   connection = Gio.bus_get_sync(session_bus, cancellable)
   notify = Gio.DBusProxy.new_sync( connection, proxy_property, interface_properties_array,
                                    destination, path, interface, cancellable)
   args = GLib.Variant('(susssasa{sv}i)', ( application_name, id_num_to_replace, icon, 
                       title, text, actions_list, hints_dict, display_milliseconds))
   result = notify.call_sync(method, args, proxy_property, timeout, cancellable)
   id = result.unpack()[0]
   print(id)



6. Using the go programming language (golang):

   package main
   
   import "launchpad.net/~jamesh/go-dbus/trunk"
   import "fmt"
   
   func main() {
       // Set the variables
       var (
           err              error
           conn             *dbus.Connection
           destination      string = "org.freedesktop.Notifications"
           path             string = "/org/freedesktop/Notifications"
           dbus_interface   string = "org.freedesktop.Notifications"
           dbus_method      string = "Notify"
           application_name string = "dbus-test"
           id_num_to_repl   uint32
           icon_path        string = "/usr/share/icons/Tango/32x32/status/sunny.png"
           title            string = "Notification Title"
           text             string = "This is the body"
           actions_list     []string
           hint             map[string]dbus.Variant
           timeout          int32  = -1
       )
   
       // Connect to Session or System buses.
       if conn, err = dbus.Connect(dbus.SessionBus); err != nil {
           fmt.Println("Connection error:", err)
       }
   
       // Create an object proxy
       obj := conn.Object(destination, dbus.ObjectPath(path))
   
       // Call object methods.
       reply, err := obj.Call(
           dbus_interface,             dbus_method,
           application_name,           id_num_to_repl,
           icon_path,                  notif_box_title,
           notif_box_body,             actions_list,
           hint,                       timeout)
       if err != nil {
           fmt.Println("Notification error:", err)
       }
   
       // Parse the reply message
       var notification_id uint32
       if err := reply.Args(&notification_id); err != nil {
           fmt.Println(err)
       }
       fmt.Println("Notification id:", notification_id)
   

Zenity is an application, not a daemon. It creates a regular window that can be abused for notifications.

zenity --info --title "Big Title" --text "This is the\\nbody text"