1 \input texinfo @c -*-texinfo-*-
2 @setfilename ../../info/dbus
4 @settitle Using of D-Bus
5 @c @setchapternewpage odd
9 Copyright @copyright{} 2007, 2008 Free Software Foundation, Inc.
12 Permission is granted to copy, distribute and/or modify this document
13 under the terms of the GNU Free Documentation License, Version 1.2 or
14 any later version published by the Free Software Foundation; with no
15 Invariant Sections, with the Front-Cover texts being ``A GNU
16 Manual'', and with the Back-Cover Texts as in (a) below. A copy of the
17 license is included in the section entitled ``GNU Free Documentation
18 License'' in the Emacs manual.
20 (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
21 this GNU Manual, like GNU software. Copies published by the Free
22 Software Foundation raise funds for GNU development.''
24 This document is part of a collection distributed under the GNU Free
25 Documentation License. If you want to distribute this document
26 separately from the collection, you can do so by adding a copy of the
27 license to the document, as described in section 6 of the license.
33 * D-Bus: (dbus). Using D-Bus in Emacs.
36 @node Top, Overview, (dir), (dir)
37 @top D-Bus integration in Emacs
39 This manual documents an API for usage of D-Bus in
40 Emacs.@footnote{D-Bus is not enabled by default. You must run
41 @command{./configure --with-dbus} in Emacs' top level directory,
42 before you compile Emacs.} D-Bus is a message bus system, a simple
43 way for applications to talk to one another. An overview of D-Bus can
44 be found at @uref{http://dbus.freedesktop.org/}.
49 * Overview:: An overview of D-Bus.
50 * Inspection:: Inspection of the bus names.
51 * Type Conversion:: Mapping Lisp types and D-Bus types.
52 * Synchronous Methods:: Calling methods in a blocking way.
53 * Receiving Method Calls:: Offering own methods.
54 * Signals:: Sending and receiving signals.
55 * Errors and Events:: Errors and events.
56 * GNU Free Documentation License:: The license for this documentation.
60 @chapter An overview of D-Bus
63 D-Bus is an inter-process communication mechanism for applications
64 residing on the same host. The communication is based on
65 @dfn{messages}. Data in the messages is carried in a structured way,
66 it is not just a byte stream.
68 The communication is connection oriented to two kinds of message
69 buses: a so called @dfn{system bus}, and a @dfn{session bus}. On a
70 given machine, there is always one single system bus for miscellaneous
71 system-wide communication, like changing of hardware configuration.
72 On the other hand, the session bus is always related to a single
75 Every client application, which is connected to a bus, registers under
76 a @dfn{unique name} at the bus. This name is used for identifying the
77 client application. Such a unique name starts always with a colon,
78 and looks like @samp{:1.42}.
80 Additionally, a client application can register itself to a so called
81 @dfn{known name}, which is a series of identifiers separated by dots,
82 as in @samp{org.gnu.Emacs}. If several applications register to the
83 same known name, these registrations are queued, and only the first
84 application which has registered for the known name is reachable via
85 this name. If this application disconnects from the bus, the next
86 queued unique name becomes the owner of this known name.
88 An application can install one or several objects under its name.
89 Such objects are identified by an @dfn{object path}, which looks
90 similar to paths in a filesystem. An example of such an object path
91 could be @samp{/org/gnu/Emacs/}.
93 Applications might send a request to an object, that means sending a
94 message with some data as input parameters, and receiving a message
95 from that object with the result of this message, the output
96 parameters. Such a request is called @dfn{method} in D-Bus.
98 The other form of communication are @dfn{signals}. The underlying
99 message is emitted from an object and will be received by all other
100 applications which have registered for such a signal.
102 All methods and signals an object supports are called @dfn{interface}
103 of the object. Interfaces are specified under a hierarchical name in
104 D-Bus; an object can support several interfaces. Such an interface
105 name could be @samp{org.gnu.Emacs.TextEditor} or
106 @samp{org.gnu.Emacs.FileManager}.
110 @chapter Inspection of the bus names.
113 There are several basic functions which inspect the buses for
114 registered names. Internally they use the basic interface
115 @samp{org.freedesktop.DBus}, which is supported by all objects of a bus.
117 @defun dbus-list-activatable-names
118 This function returns the D-Bus service names, which can be activated.
119 An activatable service is described in a service registration file.
120 Under GNU/Linux, such files are located at
121 @file{/usr/share/dbus-1/services/}.
123 The result is a list of strings, which is @code{nil} when there are no
124 activatable service names at all.
127 @defun dbus-list-names bus
128 All service names, which are registered at D-Bus @var{bus}, are
129 returned. The result is a list of strings, which is @code{nil} when
130 there are no registered service names at all. Well known names are
131 strings like @samp{org.freedesktop.DBus}. Names starting with
132 @samp{:} are unique names for services.
134 @var{bus} must be either the symbol @code{:system} or the symbol
138 @defun dbus-list-known-names bus
139 Retrieves all services which correspond to a known name in @var{bus}.
140 A service has a known name if it doesn't start with @samp{:}. The
141 result is a list of strings, which is @code{nil} when there are no
144 @var{bus} must be either the symbol @code{:system} or the symbol
148 @defun dbus-list-queued-owners bus service
149 For a given service, registered at D-Bus @var{bus} under the name
150 @var{service}, all queued unique names are returned. The result is a
151 list of strings, or @code{nil} when there are no queued names for
152 @var{service} at all.
154 @var{bus} must be either the symbol @code{:system} or the symbol
155 @code{:session}. @var{service} must be a known service name as
159 @defun dbus-get-name-owner bus service
160 For a given service, registered at D-Bus @var{bus} under the name
161 @var{service}, the unique name of the name owner is returned. The result is a
162 string, or @code{nil} when there exist no name owner of @var{service}.
164 @var{bus} must be either the symbol @code{:system} or the symbol
165 @code{:session}. @var{service} must be a known service name as
169 @defun dbus-get-unique-name bus
170 The unique name, under which Emacs is registered at D-Bus @var{bus},
171 is returned as string.
173 @var{bus} must be either the symbol @code{:system} or the symbol
177 @defun dbus-introspect bus service path
178 Objects can publish there interfaces to the D-Bus. This function
179 returns all interfaces of @var{service}, registered at object path
180 @var{path} at bus @var{bus}.
182 @var{bus} must be either the symbol @code{:system} or the symbol
183 @code{:session}. @var{service} must be a known service name, and
184 @var{path} must be a valid object path. The last two parameters are
185 strings. The result, the introspection data, is a string in XML
190 :system "org.freedesktop.Hal"
191 "/org/freedesktop/Hal/devices/computer")
193 @result{} "<!DOCTYPE node PUBLIC
194 \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"
195 \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">
197 <interface name=\"org.freedesktop.Hal.Device\">
198 <method name=\"GetAllProperties\">
199 <arg name=\"properties\" direction=\"out\" type=\"a@{sv@}\"/>
202 <signal name=\"PropertyModified\">
203 <arg name=\"num_updates\" type=\"i\"/>
204 <arg name=\"updates\" type=\"a(sbb)\"/>
211 This example informs us, that the service @code{org.freedesktop.Hal}
212 at object path @code{/org/freedesktop/Hal/devices/computer} offers the
213 interface @code{org.freedesktop.Hal.Device} (and 2 other interfaces
214 not documented here). This interface contains the method
215 @code{GetAllProperties}, which needs no input parameters, but returns
216 as output parameter an array of dictionary entries (key-value pairs).
217 Every dictionary entry has a string as key, and a variant as value.
219 The interface offers also a signal, which returns 2 parameters: an
220 integer, and an array consisting of elements which are a struct of a
221 string and 2 boolean values.
223 Such type descriptions are called @dfn{signature} in D-Bus. For a
224 discussion of D-Bus types and their Lisp representation see @ref{Type
225 Conversion}.@footnote{D-Bus signatures are explained in the D-Bus
227 @uref{http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-signatures}.
228 The interfaces of the service @code{org.freedesktop.Hal} are described
230 @uref{http://people.freedesktop.org/~david/hal-spec/hal-spec.html#interfaces}.}
234 @node Type Conversion
235 @chapter Mapping Lisp types and D-Bus types.
236 @cindex type conversion
238 D-Bus method calls and signals accept usually several arguments as
239 parameters, either as input parameter, or as output parameter. Every
240 argument belongs to a D-Bus type.
242 Such arguments must be mapped between the value encoded as a D-Bus
243 type, and the corresponding type of Lisp objects. The mapping is
244 applied Lisp object @expansion{} D-Bus type for input parameters, and
245 D-Bus type @expansion{} Lisp object for output parameters.
248 @section Input parameters.
250 Input parameters for D-Bus methods and signals occur as arguments of a
251 Lisp function call. The following mapping to D-Bus types is
252 applied, when the corresponding D-Bus message is created:
255 @multitable {@code{t} and @code{nil}} {@expansion{}} {DBUS_TYPE_BOOLEAN}
256 @item Lisp type @tab @tab D-Bus type
258 @item @code{t} and @code{nil} @tab @expansion{} @tab DBUS_TYPE_BOOLEAN
259 @item number @tab @expansion{} @tab DBUS_TYPE_UINT32
260 @item integer @tab @expansion{} @tab DBUS_TYPE_INT32
261 @item float @tab @expansion{} @tab DBUS_TYPE_DOUBLE
262 @item string @tab @expansion{} @tab DBUS_TYPE_STRING
263 @item list @tab @expansion{} @tab DBUS_TYPE_ARRAY
267 Other Lisp objects, like symbols or hash tables, are not accepted as
270 If it is necessary to use another D-Bus type, a corresponding type
271 symbol can be preceeded to the corresponding Lisp object. Basic D-Bus
272 types are represented by the type symbols @code{:byte},
273 @code{:boolean}, @code{:int16}, @code{:uint16}, @code{:int32},
274 @code{:uint32}, @code{:int64}, @code{:uint64}, @code{:double},
275 @code{:string}, @code{:object-path} and @code{:signature}.
281 (dbus-call-method @dots{} @var{NUMBER} @var{STRING})
287 (dbus-call-method @dots{} :uint32 @var{NUMBER} :string @var{STRING})
293 (dbus-call-method @dots{} :int32 @var{NUMBER} :signature @var{STRING})
296 The value for a byte D-Bus type can be any integer in the range 0
297 through 255. If a character is used as argument, modifiers
298 represented outside this range are stripped of. For example,
299 @code{:byte ?x} is equal to @code{:byte ?\M-x}, but it is not equal to
300 @code{:byte ?\C-x} or @code{:byte ?\M-\C-x}.
302 A D-Bus compound type is always represented as a list. The @sc{car}
303 of this list can be the type symbol @code{:array}, @code{:variant},
304 @code{:struct} or @code{:dict-entry}, which would result in a
305 corresponding D-Bus container. @code{:array} is optional, because
306 this is the default compound D-Bus type for a list.
308 The objects being elements of the list are checked according to the
309 D-Bus compound type rules.
312 @item An array must contain only elements of the same D-Bus type. It
315 @item A variant must contain only one single element.
317 @item A dictionary entry must be element of an array, and it must
318 contain only a key-value pair of two elements, with a basic D-Bus type
321 @item There is no restriction for structs.
324 If an empty array needs an element D-Bus type other than string, it
325 can contain exactly one element of D-Bus type @code{:signature}. The
326 value of this element (a string) is used as the signature of the
327 elements of this array. Example:
331 :session "org.freedesktop.Notifications"
332 "/org/freedesktop/Notifications"
333 "org.freedesktop.Notifications" "Notify"
334 "GNU Emacs" ;; Application name.
335 0 ;; No replacement of other notifications.
337 "Notification summary" ;; Summary.
339 "This is a test notification, raised from %s" (emacs-version))
340 '(:array) ;; No actions (empty array of strings).
341 '(:array :signature "@{sv@}") ;; No hints
342 ;; (empty array of dictionary entries).
343 ':int32 -1) ;; Default timeout.
349 @section Output parameters.
351 Output parameters of D-Bus methods and signals are mapped to Lisp
355 @multitable {DBUS_TYPE_OBJECT_PATH} {@expansion{}} {@code{t} or @code{nil}}
356 @item D-Bus type @tab @tab Lisp type
358 @item DBUS_TYPE_BOOLEAN @tab @expansion{} @tab @code{t} or @code{nil}
359 @item DBUS_TYPE_BYTE @tab @expansion{} @tab number
360 @item DBUS_TYPE_UINT16 @tab @expansion{} @tab number
361 @item DBUS_TYPE_INT16 @tab @expansion{} @tab number
362 @item DBUS_TYPE_UINT32 @tab @expansion{} @tab number or float
363 @item DBUS_TYPE_INT32 @tab @expansion{} @tab number or float
364 @item DBUS_TYPE_UINT64 @tab @expansion{} @tab number or float
365 @item DBUS_TYPE_INT64 @tab @expansion{} @tab number or float
366 @item DBUS_TYPE_DOUBLE @tab @expansion{} @tab float
367 @item DBUS_TYPE_STRING @tab @expansion{} @tab string
368 @item DBUS_TYPE_OBJECT_PATH @tab @expansion{} @tab string
369 @item DBUS_TYPE_SIGNATURE @tab @expansion{} @tab string
370 @item DBUS_TYPE_ARRAY @tab @expansion{} @tab list
371 @item DBUS_TYPE_VARIANT @tab @expansion{} @tab list
372 @item DBUS_TYPE_STRUCT @tab @expansion{} @tab list
373 @item DBUS_TYPE_DICT_ENTRY @tab @expansion{} @tab list
377 A float object in case of @code{DBUS_TYPE_UINT32},
378 @code{DBUS_TYPE_INT32}, @code{DBUS_TYPE_UINT64} and
379 @code{DBUS_TYPE_INT6432} is returned, when the C value exceeds the
380 Emacs number size range.
382 The resulting list of the last 4 D-Bus compound types contains as
383 elements the elements of the D-Bus container, mapped according to the
386 The signal @code{PropertyModified}, discussed as example in
387 @ref{Inspection}, would offer as Lisp data the following object
388 (@var{BOOL} stands here for either @code{nil} or @code{t}):
391 (@var{NUMBER} ((@var{STRING} @var{BOOL} @var{BOOL}) (@var{STRING} @var{BOOL} @var{BOOL}) @dots{}))
395 @node Synchronous Methods
396 @chapter Calling methods in a blocking way.
397 @cindex method calls, synchronous
398 @cindex synchronous method calls
400 Methods can be called synchronously (@dfn{blocking}) or asynchronously
401 (@dfn{non-blocking}). Currently, just synchronous methods are
404 At D-Bus level, a method call consist of two messages: one message
405 which carries the input parameters to the object owning the method to
406 be called, and a reply message returning the resulting output
407 parameters from the object.
409 @defun dbus-call-method bus service path interface method &rest args
410 This function calls @var{method} on the D-Bus @var{bus}. @var{bus} is
411 either the symbol @code{:system} or the symbol @code{:session}.
413 @var{service} is the D-Bus service name to be used. @var{path} is the
414 D-Bus object path, @var{service} is registered at. @var{interface} is
415 an interface offered by @var{service}. It must provide @var{method}.
417 All other arguments args are passed to @var{method} as arguments.
418 They are converted into D-Bus types as described in @ref{Type
421 The function returns the resulting values of @var{method} as a list of
422 Lisp objects, according to the type conversion rules described in
423 @ref{Type Conversion}. Example:
427 :session "org.gnome.seahorse" "/org/gnome/seahorse/keys/openpgp"
428 "org.gnome.seahorse.Keys" "GetKeyField"
429 "openpgp:657984B8C7A966DD" "simple-name")
431 @result{} (t ("Philip R. Zimmermann"))
434 If the result of the method call is just one value, the converted Lisp
435 object is returned instead of a list containing this single Lisp
440 :system "org.freedesktop.Hal"
441 "/org/freedesktop/Hal/devices/computer"
442 "org.freedesktop.Hal.Device" "GetPropertyString"
443 "system.kernel.machine")
448 With the @code{dbus-introspect} function it is possible to explore the
449 interfaces of @samp{org.freedesktop.Hal} service. It offers the
450 interfaces @samp{org.freedesktop.Hal.Manager} for the object at the
451 path @samp{/org/freedesktop/Hal/Manager} as well as the interface
452 @samp{org.freedesktop.Hal.Device} for all objects prefixed with the
453 path @samp{/org/freedesktop/Hal/devices}. With the methods
454 @samp{GetAllDevices} and @samp{GetAllProperties}, it is simple to
455 emulate the @code{lshal} command on GNU/Linux systems:
460 :system "org.freedesktop.Hal"
461 "/org/freedesktop/Hal/Manager"
462 "org.freedesktop.Hal.Manager" "GetAllDevices"))
463 (message "\nudi = %s" device)
466 :system "org.freedesktop.Hal" device
467 "org.freedesktop.Hal.Device" "GetAllProperties"))
469 (car properties) (or (caar (cdr properties)) ""))))
471 @print{} "udi = /org/freedesktop/Hal/devices/computer
472 info.addons = (\"hald-addon-acpi\")
473 info.bus = \"unknown\"
474 info.product = \"Computer\"
475 info.subsystem = \"unknown\"
476 info.udi = \"/org/freedesktop/Hal/devices/computer\"
477 linux.sysfs_path_device = \"(none)\"
478 power_management.acpi.linux.version = \"20051216\"
479 power_management.can_suspend_to_disk = t
480 power_management.can_suspend_to_ram = \"\"
481 power_management.type = \"acpi\"
482 smbios.bios.release_date = \"11/07/2001\"
483 system.chassis.manufacturer = \"COMPAL\"
484 system.chassis.type = \"Notebook\"
485 system.firmware.release_date = \"03/19/2005\"
491 @node Receiving Method Calls
492 @chapter Offering own methods.
493 @cindex method calls, returning
494 @cindex returning method calls
496 Emacs can also offer own methods, which can be called by other
497 applications. These methods could be an implementation of an
498 interface of a well known service, like @code{org.freedesktop.TextEditor}.
500 It could be also an implementation of an own interface. In this case,
501 the service name must be @code{org.gnu.Emacs}. The object path shall
502 begin with @code{/org/gnu/Emacs/@strong{Application}/}, and the
503 interface name shall be @code{org.gnu.Emacs.@strong{Application}}.
504 @code{@strong{Application}} is the name of the application which
505 provides the interface.
507 @defun dbus-register-method bus service path interface method handler
508 With this function, an application registers @var{method} on the D-Bus
511 @var{bus} is either the symbol @code{:system} or the symbol
514 @var{service} is the D-Bus service name of the D-Bus object
515 @var{method} is registered for. It must be a known name.
517 @var{path} is the D-Bus object path @var{service} is
520 @var{interface} is the interface offered by @var{service}. It must
521 provide @var{method}.
523 @var{handler} is a Lisp function to be called when when a @var{method}
524 call is is received. It must accept as arguments the input arguments
525 of @var{method}. @var{handler} must return a list, which elements are
526 used as arguments for the reply message of @var{method}. This list
527 can be composed like the input parameters in @ref{Type Conversion}.
529 @code{dbus-register-method} returns a Lisp symbol, which can be used
530 as argument in @code{dbus-unregister-object} for removing the
531 registration for @var{method}. Example:
534 (defun my-dbus-method-handler (filename)
536 (if (find-file filename)
537 (setq result '(:boolean t))
538 (setq result '(:boolean nil)))
541 @result{} my-dbus-method-handler
543 (dbus-register-method
544 :session "org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
545 "org.freedesktop.TextEditor" "OpenFile"
546 'my-dbus-method-handler)
548 @result{} ((:system "org.freedesktop.TextEditor" "OpenFile")
549 ("org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
553 If you invoke the method @code{org.freedesktop.TextEditor.OpenFile}
554 from another D-Bus application with a filename as parameter, the file
555 is opened in Emacs, and the method returns either @var{true} or
556 @var{false}, indicating the success if the method. As test tool one
557 could use the command line tool @code{dbus-send} in a shell:
560 # dbus-send --session --print-reply \
561 --dest="org.freedesktop.TextEditor" \
562 "/org/freedesktop/TextEditor" \
563 "org.freedesktop.TextEditor.OpenFile" string:"/etc/hosts"
565 @print{} method return sender=:1.22 -> dest=:1.23 reply_serial=2
572 @chapter Sending and receiving signals.
575 Signals are broadcast messages. They carry input parameters, which
576 are received by all objects which have registered for such a signal.
578 @defun dbus-send-signal bus service path interface signal &rest args
579 This function is similar to @code{dbus-call-method}. The difference
580 is, that there are no returning output parameters.
582 The function emits @var{signal} on the D-Bus @var{bus}. @var{bus} is
583 either the symbol @code{:system} or the symbol @code{:session}. It
584 doesn't matter whether another object has registered for @var{signal}.
586 @var{service} is the D-Bus service name of the object the signal is
587 emitted from. @var{path} is the corresponding D-Bus object path,
588 @var{service} is registered at. @var{interface} is an interface
589 offered by @var{service}. It must provide @var{signal}.
591 All other arguments args are passed to @var{signal} as arguments.
592 They are converted into D-Bus types as described in @ref{Type
593 Conversion}. Example:
597 :session "org.gnu.Emacs" "/org/gnu/Emacs"
598 "org.gnu.Emacs.FileManager" "FileModified" "/home/albinus/.emacs")
602 @defun dbus-register-signal bus service path interface signal handler
603 With this function, an application registers for @var{signal} on the
606 @var{bus} is either the symbol @code{:system} or the symbol
609 @var{service} is the D-Bus service name used by the sending D-Bus
610 object. It can be either a known name or the unique name of the D-Bus
611 object sending the signal. In case of a unique name, signals won't be
612 received any longer once the object owning this unique name has
613 disappeared, and a new queued object has replaced it.
615 When @var{service} is @code{nil}, related signals from all D-Bus
616 objects shall be accepted.
618 @var{path} is the corresponding D-Bus object path, @var{service} is
619 registered at. It can also be @code{nil} if the path name of incoming
620 signals shall not be checked.
622 @var{interface} is an interface offered by @var{service}. It must
623 provide @var{signal}.
625 @var{handler} is a Lisp function to be called when the @var{signal} is
626 received. It must accept as arguments the output parameters
627 @var{signal} is sending. Example:
630 (defun my-dbus-signal-handler (device)
631 (message "Device %s added" device))
633 @result{} my-dbus-signal-handler
635 (dbus-register-signal
636 :system "org.freedesktop.Hal" "/org/freedesktop/Hal/Manager"
637 "org.freedesktop.Hal.Manager" "DeviceAdded"
638 'my-dbus-signal-handler)
640 @result{} ((:system "org.freedesktop.Hal.Manager" "DeviceAdded")
641 ("org.freedesktop.Hal" "/org/freedesktop/Hal/Manager"
645 As we know from the inspection data of interface
646 @code{org.freedesktop.Hal.Manager}, the signal @code{DeviceAdded}
647 provides one single parameter, which is mapped into a Lisp string.
648 The callback function @code{my-dbus-signal-handler} must define one
649 single string argument therefore. Plugging an USB device to your
650 machine, when registered for signal @code{DeviceAdded}, will show you
651 which objects the GNU/Linux @code{hal} daemon adds.
653 @code{dbus-register-signal} returns a Lisp symbol, which can be used
654 as argument in @code{dbus-unregister-object} for removing the
655 registration for @var{signal}.
658 @defun dbus-unregister-object object
659 Unregister @var{object} from the the D-Bus. @var{object} must be the
660 result of a preceding @code{dbus-register-signal} or
661 @code{dbus-register-method} call. It returns @code{t} if @var{object}
662 has been unregistered, @code{nil} otherwise.
666 @node Errors and Events
667 @chapter Errors and events.
671 Input parameters of @code{dbus-call-method} and
672 @code{dbus-register-signal} are checked for correct D-Bus types. If
673 there is a type mismatch, the Lisp error @code{wrong-type-argument}
674 @code{D-Bus ARG} is raised.
676 All errors raised by D-Bus are signaled with the error symbol
677 @code{dbus-error}. If possible, error messages from D-Bus are
678 appended to the @code{dbus-error}.
680 @defspec dbus-ignore-errors forms@dots{}
681 This executes @var{forms} exactly like a @code{progn}, except that
682 @code{dbus-error} errors are ignored during the @var{forms}. These
683 errors can be made visible when variable @code{dbus-debug} is set to
687 Incoming D-Bus messages are handled as Emacs events (see @pxref{Misc
688 Events, , , elisp}). The generated event has this form:
691 (dbus-event @var{bus} @var{serial} @var{service} @var{path} @var{interface} @var{member} @var{handler} &rest @var{args})
694 @var{bus} identifies the D-Bus the signal is coming from. It is
695 either the symbol @code{:system} or the symbol @code{:session}.
697 @var{serial} is the serial number of the received D-Bus message if it
698 is a method call, or @code{nil}.
700 @var{service} and @var{path} are the unique name and the object path
701 of the D-Bus object emitting the message. @var{interface} and
702 @var{member} denote the message which has been sent.
704 @var{handler} is the callback function which has been registered for
705 this message (see @pxref{Signals}). When a @code{dbus-event} event
706 arrives, @var{handler} is called with @var{args} as arguments.
708 In order to inspect the @code{dbus-event} data, you could extend the
709 definition of the callback function in @ref{Signals}:
712 (defun my-dbus-signal-handler (&rest args)
713 (message "my-dbus-signal-handler: %S" last-input-event))
716 There exist convenience functions which could be called inside a
717 callback function in order to retrieve the information from the event.
719 @defun dbus-event-bus-name event
720 Returns the bus name @var{event} is coming from.
721 The result is either the symbol @code{:system} or the symbol @code{:session}.
724 @defun dbus-event-serial-number event
725 Returns the serial number of the corresponding D-Bus message.
726 The result is a number in case the D-Bus message is a method
727 call, or @code{nil} for all other mesage types.
730 @defun dbus-event-service-name event
731 Returns the unique name of the D-Bus object @var{event} is coming from.
734 @defun dbus-event-path-name event
735 Returns the object path of the D-Bus object @var{event} is coming from.
738 @defun dbus-event-interface-name event
739 Returns the interface name of of the D-Bus object @var{event} is coming from.
742 @defun dbus-event-member-name event
743 Returns the member name of of the D-Bus object @var{event} is coming
744 from. It is either a signal name or a method name.
747 D-Bus errors are not propagated during event handling, because it is
748 usually not desired. D-Bus errors in events can be made visible by
749 setting the variable @code{dbus-debug} to @code{t}.
752 @node GNU Free Documentation License
753 @appendix GNU Free Documentation License
754 @include doclicense.texi
761 arch-tag: 2eeec19d-0caf-44e0-a193-329d7f9951d8