1 \input texinfo @c -*-texinfo-*-
2 @setfilename ../../info/dbus
4 @settitle Using of D-Bus
5 @c @setchapternewpage odd
12 Copyright @copyright{} 2007--2013 Free Software Foundation, Inc.
15 Permission is granted to copy, distribute and/or modify this document
16 under the terms of the GNU Free Documentation License, Version 1.3 or
17 any later version published by the Free Software Foundation; with no
18 Invariant Sections, with the Front-Cover texts being ``A GNU Manual'',
19 and with the Back-Cover Texts as in (a) below. A copy of the license
20 is included in the section entitled ``GNU Free Documentation License''.
22 (a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
23 modify this GNU manual.''
27 @dircategory Emacs lisp libraries
29 * D-Bus: (dbus). Using D-Bus in Emacs.
35 @node Top, Overview, (dir), (dir)
36 @top D-Bus integration in Emacs
38 This manual documents an API for usage of D-Bus in Emacs. D-Bus is a
39 message bus system, a simple way for applications to talk to one
40 another. An overview of D-Bus can be found at
41 @uref{http://dbus.freedesktop.org/}.
48 * Overview:: An overview of D-Bus.
49 * Inspection:: Inspection of D-Bus services.
50 * Type Conversion:: Mapping Lisp types and D-Bus types.
51 * Synchronous Methods:: Calling methods in a blocking way.
52 * Asynchronous Methods:: Calling methods non-blocking.
53 * Receiving Method Calls:: Offering own methods.
54 * Signals:: Sending and receiving signals.
55 * Alternative Buses:: Alternative buses and environments.
56 * Errors and Events:: Errors and events.
57 * Index:: Index including concepts, functions, variables.
59 * GNU Free Documentation License:: The license for this documentation.
64 @chapter An overview of D-Bus
67 D-Bus is an inter-process communication mechanism for applications
68 residing on the same host. The communication is based on
69 @dfn{messages}. Data in the messages is carried in a structured way,
70 it is not just a byte stream.
72 The communication is connection oriented to two kinds of message
73 buses: a so called @dfn{system bus}, and a @dfn{session bus}. On a
74 given machine, there is always one single system bus for miscellaneous
75 system-wide communication, like changing of hardware configuration.
76 On the other hand, the session bus is always related to a single
79 Every client application, which is connected to a bus, registers under
80 a @dfn{unique name} at the bus. This name is used for identifying the
81 client application. Such a unique name starts always with a colon,
82 and looks like @samp{:1.42}.
84 Additionally, a client application can register itself to a so called
85 @dfn{known name}, which is a series of identifiers separated by dots,
86 as in @samp{org.gnu.Emacs}. If several applications register to the
87 same known name, these registrations are queued, and only the first
88 application which has registered for the known name is reachable via
89 this name. If this application disconnects from the bus, the next
90 queued unique name becomes the owner of this known name.
92 An application can install one or several objects under its name.
93 Such objects are identified by an @dfn{object path}, which looks
94 similar to paths in a filesystem. An example of such an object path
95 could be @samp{/org/gnu/Emacs/}.
97 Applications might send a request to an object, that means sending a
98 message with some data as input parameters, and receiving a message
99 from that object with the result of this message, the output
100 parameters. Such a request is called @dfn{method} in D-Bus.
102 The other form of communication are @dfn{signals}. The underlying
103 message is emitted from an object and will be received by all other
104 applications which have registered for such a signal.
106 All methods and signals an object supports are called @dfn{interface}
107 of the object. Interfaces are specified under a hierarchical name in
108 D-Bus; an object can support several interfaces. Such an interface
109 name could be @samp{org.gnu.Emacs.TextEditor} or
110 @samp{org.gnu.Emacs.FileManager}.
114 @chapter Inspection of D-Bus services.
118 * Version:: Determining the D-Bus version.
119 * Bus names:: Discovering D-Bus names.
120 * Introspection:: Knowing the details of D-Bus services.
121 * Nodes and Interfaces:: Detecting object paths and interfaces.
122 * Methods and Signal:: Applying the functionality.
123 * Properties and Annotations:: What else to know about interfaces.
124 * Arguments and Signatures:: The final details.
129 @section D-Bus version.
131 D-Bus has evolved over the years. New features have been added with
132 new D-Bus versions. There are two variables, which allow to determine
133 the used D-Bus version.
135 @defvar dbus-compiled-version
136 This variable, a string, determines the version of D-Bus Emacs is
137 compiled against. If it cannot be determined the value is @code{nil}.
140 @defvar dbus-runtime-version
141 The other D-Bus version to be checked is the version of D-Bus Emacs
142 runs with. This string can be different from @code{dbus-compiled-version}.
143 It is also @code{nil}, if it cannot be determined at runtime.
150 There are several basic functions which inspect the buses for
151 registered names. Internally they use the basic interface
152 @samp{org.freedesktop.DBus}, which is supported by all objects of a bus.
154 @defun dbus-list-activatable-names &optional bus
155 This function returns the D-Bus service names, which can be activated
156 for @var{bus}. It must be either the symbol @code{:system} (the
157 default) or the symbol @code{:session}. An activatable service is
158 described in a service registration file. Under GNU/Linux, such files
159 are located at @file{/usr/share/dbus-1/system-services/} (for the
160 @code{:system} bus) or @file{/usr/share/dbus-1/services/}. An
161 activatable service is not necessarily registered at @var{bus} at already.
163 The result is a list of strings, which is @code{nil} when there are no
164 activatable service names at all. Example:
167 ;; Check, whether the document viewer can be accessed via D-Bus.
168 (member "org.gnome.evince.Daemon"
169 (dbus-list-activatable-names :session))
173 @defun dbus-list-names bus
174 All service names, which are registered at D-Bus @var{bus}, are
175 returned. The result is a list of strings, which is @code{nil} when
176 there are no registered service names at all. Well known names are
177 strings like @samp{org.freedesktop.DBus}. Names starting with
178 @samp{:} are unique names for services.
180 @var{bus} must be either the symbol @code{:system} or the symbol
184 @defun dbus-list-known-names bus
185 Retrieves all registered services which correspond to a known name in @var{bus}.
186 A service has a known name if it doesn't start with @samp{:}. The
187 result is a list of strings, which is @code{nil} when there are no
190 @var{bus} must be either the symbol @code{:system} or the symbol
194 @defun dbus-list-queued-owners bus service
195 For a given service, registered at D-Bus @var{bus} under the name
196 @var{service}, all queued unique names are returned. The result is a
197 list of strings, or @code{nil} when there are no queued names for
198 @var{service} at all.
200 @var{bus} must be either the symbol @code{:system} or the symbol
201 @code{:session}. @var{service} must be a known service name as
205 @defun dbus-get-name-owner bus service
206 For a given service, registered at D-Bus @var{bus} under the name
207 @var{service}, the unique name of the name owner is returned. The
208 result is a string, or @code{nil} when there exist no name owner of
211 @var{bus} must be either the symbol @code{:system} or the symbol
212 @code{:session}. @var{service} must be a known service name as
216 @defun dbus-ping bus service &optional timeout
217 Check whether the service name @var{service} is registered at D-Bus
218 @var{bus}. @var{service} might not have been started yet, it is
219 autostarted if possible. The result is either @code{t} or @code{nil}.
221 @var{bus} must be either the symbol @code{:system} or the symbol
222 @code{:session}. @var{service} must be a string. @var{timeout}, a
223 nonnegative integer, specifies the maximum number of milliseconds
224 @code{dbus-ping} must return. The default value is 25,000. Example:
228 "%s screensaver on board."
230 ((dbus-ping :session "org.gnome.ScreenSaver" 100) "Gnome")
231 ((dbus-ping :session "org.freedesktop.ScreenSaver" 100) "KDE")
235 If it shall be checked whether @var{service} is already running
236 without autostarting it, one shall apply
239 (member service (dbus-list-known-names bus))
243 @defun dbus-get-unique-name bus
244 The unique name, under which Emacs is registered at D-Bus @var{bus},
245 is returned as string.
247 @var{bus} must be either the symbol @code{:system} or the symbol
253 @section Knowing the details of D-Bus services.
255 D-Bus services publish their interfaces. This can be retrieved and
256 analyzed during runtime, in order to understand the used
259 The resulting introspection data are in XML format. The root
260 introspection element is always a @code{node} element. It might have
261 a @code{name} attribute, which denotes the (absolute) object path an
262 interface is introspected.
264 The root @code{node} element may have @code{node} and @code{interface}
265 children. A child @code{node} element must have a @code{name}
266 attribute, this case it is the relative object path to the root
269 An @code{interface} element has just one attribute, @code{name}, which
270 is the full name of that interface. The default interface
271 @samp{org.freedesktop.DBus.Introspectable} is always present. Example:
274 <node name="/org/bluez">
275 <interface name="org.freedesktop.DBus.Introspectable">
278 <interface name="org.bluez.Manager">
281 <interface name="org.bluez.Database">
284 <interface name="org.bluez.Security">
287 <node name="service_audio"/>
288 <node name="service_input"/>
289 <node name="service_network"/>
290 <node name="service_serial"/>
294 Children of an @code{interface} element can be @code{method},
295 @code{signal} and @code{property} elements. A @code{method} element
296 stands for a D-Bus method of the surrounding interface. The element
297 itself has a @code{name} attribute, showing the method name. Children
298 elements @code{arg} stand for the arguments of a method. Example:
301 <method name="ResolveHostName">
302 <arg name="interface" type="i" direction="in"/>
303 <arg name="protocol" type="i" direction="in"/>
304 <arg name="name" type="s" direction="in"/>
305 <arg name="aprotocol" type="i" direction="in"/>
306 <arg name="flags" type="u" direction="in"/>
307 <arg name="interface" type="i" direction="out"/>
308 <arg name="protocol" type="i" direction="out"/>
309 <arg name="name" type="s" direction="out"/>
310 <arg name="aprotocol" type="i" direction="out"/>
311 <arg name="address" type="s" direction="out"/>
312 <arg name="flags" type="u" direction="out"/>
316 @code{arg} elements can have the attributes @code{name}, @code{type}
317 and @code{direction}. The @code{name} attribute is optional. The
318 @code{type} attribute stands for the @dfn{signature} of the argument
319 in D-Bus. For a discussion of D-Bus types and their Lisp
320 representation see @ref{Type Conversion}.@footnote{D-Bus signatures
321 are explained in the D-Bus specification
322 @uref{http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-signatures}.}
323 The @code{direction} attribute of an @code{arg} element can be only
324 @samp{in} or @samp{out}; in case it is omitted, it defaults to
327 A @code{signal} element of an @code{interface} has a similar
328 structure. The @code{direction} attribute of an @code{arg} child
329 element can be only @samp{out} here; which is also the default value.
333 <signal name="StateChanged">
334 <arg name="state" type="i"/>
335 <arg name="error" type="s"/>
339 A @code{property} element has no @code{arg} child
340 element. It just has the attributes @code{name}, @code{type} and
341 @code{access}, which are all mandatory. The @code{access} attribute
342 allows the values @samp{readwrite}, @samp{read}, and @samp{write}.
346 <property name="Status" type="u" direction="read"/>
349 @code{annotation} elements can be children of @code{interface},
350 @code{method}, @code{signal}, and @code{property} elements. Unlike
351 properties, which can change their values during lifetime of a D-Bus
352 object, annotations are static. Often they are used for code
353 generators of D-Bus language bindings. Example:
356 <annotation name="de.berlios.Pinot.GetStatistics" value="pinotDBus"/>
359 Annotations have just @code{name} and @code{value} attributes, both
362 @defun dbus-introspect bus service path
363 This function returns all interfaces and sub-nodes of @var{service},
364 registered at object path @var{path} at bus @var{bus}.
366 @var{bus} must be either the symbol @code{:system} or the symbol
367 @code{:session}. @var{service} must be a known service name, and
368 @var{path} must be a valid object path. The last two parameters are
369 strings. The result, the introspection data, is a string in XML
374 :system "org.freedesktop.Hal"
375 "/org/freedesktop/Hal/devices/computer")
377 @result{} "<!DOCTYPE node PUBLIC
378 "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
379 "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
381 <interface name="org.freedesktop.Hal.Device">
382 <method name="GetAllProperties">
383 <arg name="properties" direction="out" type="a@{sv@}"/>
386 <signal name="PropertyModified">
387 <arg name="num_updates" type="i"/>
388 <arg name="updates" type="a(sbb)"/>
395 This example informs us, that the service @samp{org.freedesktop.Hal}
396 at object path @samp{/org/freedesktop/Hal/devices/computer} offers the
397 interface @samp{org.freedesktop.Hal.Device} (and 2 other interfaces
398 not documented here). This interface contains the method
399 @samp{GetAllProperties}, which needs no input parameters, but returns
400 as output parameter an array of dictionary entries (key-value pairs).
401 Every dictionary entry has a string as key, and a variant as value.
403 The interface offers also a signal, which returns 2 parameters: an
404 integer, and an array consisting of elements which are a struct of a
405 string and 2 boolean values.@footnote{ The interfaces of the service
406 @samp{org.freedesktop.Hal} are described at
407 @uref{http://people.freedesktop.org/~david/hal-spec/hal-spec.html#interfaces}.}
410 @defun dbus-introspect-xml bus service path
411 This function has the same intention as function
412 @code{dbus-introspect}. The returned value is a parsed XML tree,
413 which can be used for further analysis. Example:
417 :session "org.freedesktop.xesam.searcher"
418 "/org/freedesktop/xesam/searcher/main")
420 @result{} (node ((name . "/org/freedesktop/xesam/searcher/main"))
421 (interface ((name . "org.freedesktop.xesam.Search"))
422 (method ((name . "GetHitData"))
423 (arg ((name . "search") (type . "s") (direction . "in")))
424 (arg ((name . "hit_ids") (type . "au") (direction . "in")))
425 (arg ((name . "fields") (type . "as") (direction . "in")))
426 (arg ((name . "hit_data") (type . "aav") (direction . "out")))
429 (signal ((name . "HitsAdded"))
430 (arg ((name . "search") (type . "s")))
431 (arg ((name . "count") (type . "u")))
439 @defun dbus-introspect-get-attribute object attribute
440 It returns the @var{attribute} value of a D-Bus introspection
441 @var{object}. @var{object} can be every subtree of a parsed XML tree
442 as retrieved with @code{dbus-introspect-xml}. @var{attribute} must be
443 a string according to the attribute names in the D-Bus specification.
447 (dbus-introspect-get-attribute
448 (dbus-introspect-xml :system "org.freedesktop.SystemToolsBackends"
449 "/org/freedesktop/SystemToolsBackends/UsersConfig")
452 @result{} "/org/freedesktop/SystemToolsBackends/UsersConfig"
455 If @var{object} has no @var{attribute}, the function returns
460 @node Nodes and Interfaces
461 @section Detecting object paths and interfaces.
463 The first elements, to be introspected for a D-Bus object, are further
464 object paths and interfaces.
466 @defun dbus-introspect-get-node-names bus service path
467 All node names of @var{service} in D-Bus @var{bus} at object path
468 @var{path} are returned as list of strings. Example:
471 (dbus-introspect-get-node-names
472 :session "org.gnome.seahorse" "/org/gnome/seahorse")
474 @result{} ("crypto" "keys")
477 The node names stand for further object paths of the D-Bus
478 @var{service}, relative to @var{path}. In the example,
479 @samp{/org/gnome/seahorse/crypto} and @samp{/org/gnome/seahorse/keys}
480 are also object paths of the D-Bus service @samp{org.gnome.seahorse}.
483 @defun dbus-introspect-get-all-nodes bus service path
484 This function returns all node names of @var{service} in D-Bus
485 @var{bus} at object path @var{path}. It returns a list of strings
486 with all object paths of @var{service}, starting at @var{path}.
490 (dbus-introspect-get-all-nodes :session "org.gnome.seahorse" "/")
492 @result{} ("/" "/org" "/org/gnome" "/org/gnome/seahorse"
493 "/org/gnome/seahorse/crypto"
494 "/org/gnome/seahorse/keys"
495 "/org/gnome/seahorse/keys/openpgp"
496 "/org/gnome/seahorse/keys/openpgp/local"
497 "/org/gnome/seahorse/keys/openssh"
498 "/org/gnome/seahorse/keys/openssh/local")
502 @defun dbus-introspect-get-interface-names bus service path
503 There will be returned a list strings of all interface names of
504 @var{service} in D-Bus @var{bus} at object path @var{path}. This list
505 will contain the default interface @samp{org.freedesktop.DBus.Introspectable}.
507 Another default interface is @samp{org.freedesktop.DBus.Properties}.
508 If present, @code{interface} elements can also have @code{property}
512 (dbus-introspect-get-interface-names
513 :system "org.freedesktop.Hal"
514 "/org/freedesktop/Hal/devices/computer")
516 @result{} ("org.freedesktop.DBus.Introspectable"
517 "org.freedesktop.Hal.Device"
518 "org.freedesktop.Hal.Device.SystemPowerManagement"
519 "org.freedesktop.Hal.Device.CPUFreq")
523 @defun dbus-introspect-get-interface bus service path interface
524 Return @var{interface} of @var{service} in D-Bus @var{bus} at object
525 path @var{path}. The return value is an XML element. @var{interface}
526 must be a string, element of the list returned by
527 @code{dbus-introspect-get-interface-names}. Example:
530 (dbus-introspect-get-interface
531 :session "org.freedesktop.xesam.searcher"
532 "/org/freedesktop/xesam/searcher/main"
533 "org.freedesktop.xesam.Search")
535 @result{} (interface ((name . "org.freedesktop.xesam.Search"))
536 (method ((name . "GetHitData"))
537 (arg ((name . "search") (type . "s") (direction . "in")))
538 (arg ((name . "hit_ids") (type . "au") (direction . "in")))
539 (arg ((name . "fields") (type . "as") (direction . "in")))
540 (arg ((name . "hit_data") (type . "aav") (direction . "out")))
543 (signal ((name . "HitsAdded"))
544 (arg ((name . "search") (type . "s")))
545 (arg ((name . "count") (type . "u")))
552 With these functions, it is possible to retrieve all introspection
553 data from a running system:
556 (with-current-buffer (switch-to-buffer "*introspect*")
558 (dolist (service (dbus-list-known-names :session))
559 (dolist (path (dbus-introspect-get-all-nodes :session service "/"))
560 ;; We want to introspect only elements, which have more than
561 ;; the default interface "org.freedesktop.DBus.Introspectable".
563 "org.freedesktop.DBus.Introspectable"
564 (dbus-introspect-get-interface-names :session service path))
565 (insert (message "\nservice: \"%s\" path: \"%s\"\n" service path)
566 (dbus-introspect :session service path))
571 @node Methods and Signal
572 @section Applying the functionality.
574 Methods and signals are the communication means to D-Bus. The
575 following functions return their specifications.
577 @defun dbus-introspect-get-method-names bus service path interface
578 Return a list of strings of all method names of @var{interface} of
579 @var{service} in D-Bus @var{bus} at object path @var{path}. Example:
582 (dbus-introspect-get-method-names
583 :session "org.freedesktop.xesam.searcher"
584 "/org/freedesktop/xesam/searcher/main"
585 "org.freedesktop.xesam.Search")
587 @result{} ("GetState" "StartSearch" "GetHitCount" "GetHits" "NewSession"
588 "CloseSession" "GetHitData" "SetProperty" "NewSearch"
589 "GetProperty" "CloseSearch")
593 @defun dbus-introspect-get-method bus service path interface method
594 This function returns @var{method} of @var{interface} as XML element.
595 It must be located at @var{service} in D-Bus @var{bus} at object path
596 @var{path}. @var{method} must be a string, element of the list
597 returned by @code{dbus-introspect-get-method-names}. Example:
600 (dbus-introspect-get-method
601 :session "org.freedesktop.xesam.searcher"
602 "/org/freedesktop/xesam/searcher/main"
603 "org.freedesktop.xesam.Search" "GetHitData")
605 @result{} (method ((name . "GetHitData"))
606 (arg ((name . "search") (type . "s") (direction . "in")))
607 (arg ((name . "hit_ids") (type . "au") (direction . "in")))
608 (arg ((name . "fields") (type . "as") (direction . "in")))
609 (arg ((name . "hit_data") (type . "aav") (direction . "out")))
614 @defun dbus-introspect-get-signal-names bus service path interface
615 Return a list of strings of all signal names of @var{interface} of
616 @var{service} in D-Bus @var{bus} at object path @var{path}. Example:
619 (dbus-introspect-get-signal-names
620 :session "org.freedesktop.xesam.searcher"
621 "/org/freedesktop/xesam/searcher/main"
622 "org.freedesktop.xesam.Search")
624 @result{} ("StateChanged" "SearchDone" "HitsModified"
625 "HitsRemoved" "HitsAdded")
629 @defun dbus-introspect-get-signal bus service path interface signal
630 This function returns @var{signal} of @var{interface} as XML element.
631 It must be located at @var{service} in D-Bus @var{bus} at object path
632 @var{path}. @var{signal} must be a string, element of the list
633 returned by @code{dbus-introspect-get-signal-names}. Example:
636 (dbus-introspect-get-signal
637 :session "org.freedesktop.xesam.searcher"
638 "/org/freedesktop/xesam/searcher/main"
639 "org.freedesktop.xesam.Search" "HitsAdded")
641 @result{} (signal ((name . "HitsAdded"))
642 (arg ((name . "search") (type . "s")))
643 (arg ((name . "count") (type . "u")))
649 @node Properties and Annotations
650 @section What else to know about interfaces.
652 Interfaces can have properties. These can be exposed via the
653 @samp{org.freedesktop.DBus.Properties} interface@footnote{See
654 @uref{http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties}}.
655 That is, properties can be retrieved and changed during lifetime of an
658 A generalized interface is
659 @samp{org.freedesktop.DBus.Objectmanager}@footnote{See
660 @uref{http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager}},
661 which returns objects, their interfaces and properties for a given
662 service in just one call.
664 Annotations, on the other hand, are static values for an element.
665 Often, they are used to instruct generators, how to generate code from
666 the interface for a given language binding.
668 @defun dbus-introspect-get-property-names bus service path interface
669 Return a list of strings with all property names of @var{interface} of
670 @var{service} in D-Bus @var{bus} at object path @var{path}. Example:
673 (dbus-introspect-get-property-names
674 :session "org.kde.kded" "/modules/networkstatus"
675 "org.kde.Solid.Networking.Client")
680 If an interface declares properties, the corresponding element supports
681 also the @samp{org.freedesktop.DBus.Properties} interface.
684 @defun dbus-introspect-get-property bus service path interface property
685 This function returns @var{property} of @var{interface} as XML element.
686 It must be located at @var{service} in D-Bus @var{bus} at object path
687 @var{path}. @var{property} must be a string, element of the list
688 returned by @code{dbus-introspect-get-property-names}.
690 A @var{property} value can be retrieved by the function
691 @code{dbus-introspect-get-attribute}. Example:
694 (dbus-introspect-get-property
695 :session "org.kde.kded" "/modules/networkstatus"
696 "org.kde.Solid.Networking.Client" "Status")
698 @result{} (property ((access . "read") (type . "u") (name . "Status")))
700 (dbus-introspect-get-attribute
701 (dbus-introspect-get-property
702 :session "org.kde.kded" "/modules/networkstatus"
703 "org.kde.Solid.Networking.Client" "Status")
710 @defun dbus-get-property bus service path interface property
711 This function returns the value of @var{property} of @var{interface}.
712 It will be checked at @var{bus}, @var{service}, @var{path}. The
713 result can be any valid D-Bus value, or @code{nil} if there is no
714 @var{property}. Example:
718 :session "org.kde.kded" "/modules/networkstatus"
719 "org.kde.Solid.Networking.Client" "Status")
725 @defun dbus-set-property bus service path interface property value
726 Set value of @var{property} of @var{interface} to @var{value}. It
727 will be checked at @var{bus}, @var{service}, @var{path}. When the
728 value has been set successful, the result is @var{value}. Otherwise,
729 @code{nil} is returned. Example:
733 :session "org.kde.kaccess" "/MainApplication"
734 "com.trolltech.Qt.QApplication" "doubleClickInterval" 500)
740 @defun dbus-get-all-properties bus service path interface
741 This function returns all properties of @var{interface}. It will be
742 checked at @var{bus}, @var{service}, @var{path}. The result is a list
743 of cons. Every cons contains the name of the property, and its value.
744 If there are no properties, @code{nil} is returned. Example:
747 (dbus-get-all-properties
748 :session "org.kde.kaccess" "/MainApplication"
749 "com.trolltech.Qt.QApplication")
751 @result{} (("cursorFlashTime" . 1000) ("doubleClickInterval" . 500)
752 ("keyboardInputInterval" . 400) ("wheelScrollLines" . 3)
753 ("globalStrut" 0 0) ("startDragTime" . 500)
754 ("startDragDistance" . 4) ("quitOnLastWindowClosed" . t)
759 @defun dbus-get-all-managed-objects bus service path
760 This functions returns all objects at @var{bus}, @var{service},
761 @var{path}, and the children of @var{path}. The result is a list of
762 objects. Every object is a cons of an existing path name, and the
763 list of available interface objects. An interface object is another
764 cons, which car is the interface name, and the cdr is the list of
765 properties as returned by @code{dbus-get-all-properties} for that path
766 and interface. Example:
769 (dbus-get-all-managed-objects
770 :session "org.gnome.SettingsDaemon" "/")
772 @result{} (("/org/gnome/SettingsDaemon/MediaKeys"
773 ("org.gnome.SettingsDaemon.MediaKeys")
774 ("org.freedesktop.DBus.Peer")
775 ("org.freedesktop.DBus.Introspectable")
776 ("org.freedesktop.DBus.Properties")
777 ("org.freedesktop.DBus.ObjectManager"))
778 ("/org/gnome/SettingsDaemon/Power"
779 ("org.gnome.SettingsDaemon.Power.Keyboard")
780 ("org.gnome.SettingsDaemon.Power.Screen")
781 ("org.gnome.SettingsDaemon.Power"
782 ("Icon" . ". GThemedIcon battery-full-charged-symbolic ")
783 ("Tooltip" . "Laptop battery is charged"))
784 ("org.freedesktop.DBus.Peer")
785 ("org.freedesktop.DBus.Introspectable")
786 ("org.freedesktop.DBus.Properties")
787 ("org.freedesktop.DBus.ObjectManager"))
791 If possible, @samp{org.freedesktop.DBus.ObjectManager.GetManagedObjects}
792 is used for retrieving the information. Otherwise, the information
793 is collected via @samp{org.freedesktop.DBus.Introspectable.Introspect}
794 and @samp{org.freedesktop.DBus.Properties.GetAll}, which is slow.
796 An overview of all existing object paths, their interfaces and
797 properties could be retrieved by the following code:
800 (with-current-buffer (switch-to-buffer "*objectmanager*")
803 (dolist (service (dbus-list-known-names :session) result)
804 (message "%s" service)
808 (dbus-get-all-managed-objects :session service "/"))))
809 (insert (message "%s" (pp result)))
814 @defun dbus-introspect-get-annotation-names bus service path interface &optional name
815 Return a list of all annotation names as list of strings. If
816 @var{name} is @code{nil}, the annotations are children of
817 @var{interface}, otherwise @var{name} must be a @code{method},
818 @code{signal}, or @code{property} XML element, where the annotations
822 (dbus-introspect-get-annotation-names
823 :session "de.berlios.Pinot" "/de/berlios/Pinot"
824 "de.berlios.Pinot" "GetStatistics")
826 @result{} ("de.berlios.Pinot.GetStatistics")
829 Default annotation names@footnote{See
830 @uref{http://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format}}
834 @item org.freedesktop.DBus.Deprecated
835 Whether or not the entity is deprecated; defaults to @code{nil}
837 @item org.freedesktop.DBus.GLib.CSymbol
838 The C symbol; may be used for @code{methods} and @code{interfaces}
840 @item org.freedesktop.DBus.Method.NoReply
841 If set, don't expect a reply to the @code{method} call; defaults to @code{nil}
845 @defun dbus-introspect-get-annotation bus service path interface name annotation
846 Return annotation @var{ANNOTATION} as XML object. If @var{name} is
847 @code{nil}, @var{ANNOTATION} is a child of @var{interface}, otherwise
848 @var{name} must be the name of a @code{method}, @code{signal}, or
849 @code{property} XML element, where the @var{ANNOTATION} belongs to.
851 An attribute value can be retrieved by
852 @code{dbus-introspect-get-attribute}. Example:
855 (dbus-introspect-get-annotation
856 :session "de.berlios.Pinot" "/de/berlios/Pinot"
857 "de.berlios.Pinot" "GetStatistics"
858 "de.berlios.Pinot.GetStatistics")
860 @result{} (annotation ((name . "de.berlios.Pinot.GetStatistics")
861 (value . "pinotDBus")))
863 (dbus-introspect-get-attribute
864 (dbus-introspect-get-annotation
865 :session "de.berlios.Pinot" "/de/berlios/Pinot"
866 "de.berlios.Pinot" "GetStatistics"
867 "de.berlios.Pinot.GetStatistics")
870 @result{} "pinotDBus"
875 @node Arguments and Signatures
876 @section The final details.
878 Methods and signals have arguments. They are described in the
879 @code{arg} XML elements.
881 @defun dbus-introspect-get-argument-names bus service path interface name
882 Return a list of all argument names as list of strings. @var{name}
883 must be a @code{method} or @code{signal} XML element. Example:
886 (dbus-introspect-get-argument-names
887 :session "org.freedesktop.xesam.searcher"
888 "/org/freedesktop/xesam/searcher/main"
889 "org.freedesktop.xesam.Search" "GetHitData")
891 @result{} ("search" "hit_ids" "fields" "hit_data")
894 Argument names are optional; the function can return @code{nil}
895 therefore, even if the method or signal has arguments.
898 @defun dbus-introspect-get-argument bus service path interface name arg
899 Return argument @var{ARG} as XML object. @var{name}
900 must be a @code{method} or @code{signal} XML element. Example:
903 (dbus-introspect-get-argument
904 :session "org.freedesktop.xesam.searcher"
905 "/org/freedesktop/xesam/searcher/main"
906 "org.freedesktop.xesam.Search" "GetHitData" "search")
908 @result{} (arg ((name . "search") (type . "s") (direction . "in")))
912 @defun dbus-introspect-get-signature bus service path interface name &optional direction
913 Return signature of a @code{method} or @code{signal}, represented by
914 @var{name}, as string.
916 If @var{name} is a @code{method}, @var{direction} can be either
917 @samp{in} or @samp{out}. If @var{direction} is @code{nil}, @samp{in}
920 If @var{name} is a @code{signal}, and @var{direction} is
921 non-@code{nil}, @var{direction} must be @samp{out}. Example:
924 (dbus-introspect-get-signature
925 :session "org.freedesktop.xesam.searcher"
926 "/org/freedesktop/xesam/searcher/main"
927 "org.freedesktop.xesam.Search" "GetHitData" "in")
931 (dbus-introspect-get-signature
932 :session "org.freedesktop.xesam.searcher"
933 "/org/freedesktop/xesam/searcher/main"
934 "org.freedesktop.xesam.Search" "HitsAdded")
941 @node Type Conversion
942 @chapter Mapping Lisp types and D-Bus types.
943 @cindex type conversion
945 D-Bus method calls and signals accept usually several arguments as
946 parameters, either as input parameter, or as output parameter. Every
947 argument belongs to a D-Bus type.
949 Such arguments must be mapped between the value encoded as a D-Bus
950 type, and the corresponding type of Lisp objects. The mapping is
951 applied Lisp object @expansion{} D-Bus type for input parameters, and
952 D-Bus type @expansion{} Lisp object for output parameters.
955 @section Input parameters.
957 Input parameters for D-Bus methods and signals occur as arguments of a
958 Lisp function call. The following mapping to D-Bus types is
959 applied, when the corresponding D-Bus message is created:
962 @multitable {negative integer} {@expansion{}} {DBUS_TYPE_BOOLEAN}
963 @item Lisp type @tab @tab D-Bus type
965 @item @code{t} and @code{nil} @tab @expansion{} @tab DBUS_TYPE_BOOLEAN
966 @item natural number @tab @expansion{} @tab DBUS_TYPE_UINT32
967 @item negative integer @tab @expansion{} @tab DBUS_TYPE_INT32
968 @item float @tab @expansion{} @tab DBUS_TYPE_DOUBLE
969 @item string @tab @expansion{} @tab DBUS_TYPE_STRING
970 @item list @tab @expansion{} @tab DBUS_TYPE_ARRAY
974 Other Lisp objects, like symbols or hash tables, are not accepted as
977 If it is necessary to use another D-Bus type, a corresponding type
978 symbol can be prepended to the corresponding Lisp object. Basic D-Bus
979 types are represented by the type symbols @code{:byte},
980 @code{:boolean}, @code{:int16}, @code{:uint16}, @code{:int32},
981 @code{:uint32}, @code{:int64}, @code{:uint64}, @code{:double},
982 @code{:string}, @code{:object-path}, @code{:signature} and
989 (dbus-call-method @dots{} @var{NAT-NUMBER} @var{STRING})
995 (dbus-call-method @dots{} :uint32 @var{NAT-NUMBER} :string @var{STRING})
1001 (dbus-call-method @dots{} :int32 @var{NAT-NUMBER} :signature @var{STRING})
1004 The value for a byte D-Bus type can be any integer in the range 0
1005 through 255. If a character is used as argument, modifiers
1006 represented outside this range are stripped of. For example,
1007 @code{:byte ?x} is equal to @code{:byte ?\M-x}, but it is not equal to
1008 @code{:byte ?\C-x} or @code{:byte ?\M-\C-x}.
1010 Signed and unsigned integer D-Bus types expect a corresponding integer
1011 value. If the value does not fit Emacs's integer range, it is also
1012 possible to use an equivalent floating point number.
1014 A D-Bus compound type is always represented as a list. The @sc{car}
1015 of this list can be the type symbol @code{:array}, @code{:variant},
1016 @code{:struct} or @code{:dict-entry}, which would result in a
1017 corresponding D-Bus container. @code{:array} is optional, because
1018 this is the default compound D-Bus type for a list.
1020 The objects being elements of the list are checked according to the
1021 D-Bus compound type rules.
1024 @item An array must contain only elements of the same D-Bus type. It
1027 @item A variant must contain only one single element.
1029 @item A dictionary entry must be element of an array, and it must
1030 contain only a key-value pair of two elements, with a basic D-Bus type
1033 @item There is no restriction for structs.
1036 If an empty array needs an element D-Bus type other than string, it
1037 can contain exactly one element of D-Bus type @code{:signature}. The
1038 value of this element (a string) is used as the signature of the
1039 elements of this array. Example:
1043 :session "org.freedesktop.Notifications"
1044 "/org/freedesktop/Notifications"
1045 "org.freedesktop.Notifications" "Notify"
1046 "GNU Emacs" ;; Application name.
1047 0 ;; No replacement of other notifications.
1049 "Notification summary" ;; Summary.
1051 "This is a test notification, raised from %s" (emacs-version))
1052 '(:array) ;; No actions (empty array of strings).
1053 '(:array :signature "@{sv@}") ;; No hints
1054 ;; (empty array of dictionary entries).
1055 :int32 -1) ;; Default timeout.
1060 @defun dbus-string-to-byte-array string
1061 Sometimes, D-Bus methods require as input parameter an array of bytes,
1062 instead of a string. If it is guaranteed, that @var{string} is an
1063 UTF8 string, this function performs the conversion. Example:
1066 (dbus-string-to-byte-array "/etc/hosts")
1068 @result{} (:array :byte 47 :byte 101 :byte 116 :byte 99 :byte 47
1069 :byte 104 :byte 111 :byte 115 :byte 116 :byte 115)
1073 @defun dbus-escape-as-identifier string
1074 Escape an arbitrary @var{string} so it follows the rules for a C
1075 identifier. The escaped string can be used as object path component,
1076 interface element component, bus name component or member name in
1079 The escaping consists of replacing all non-alphanumerics, and the
1080 first character if it's a digit, with an underscore and two
1081 lower-case hex digits. As a special case, "" is escaped to
1085 (dbus-escape-as-identifier "0123abc_xyz\x01\xff")
1087 @result{} "_30123abc_5fxyz_01_ff"
1092 @section Output parameters.
1094 Output parameters of D-Bus methods and signals are mapped to Lisp
1098 @multitable {DBUS_TYPE_OBJECT_PATH} {@expansion{}} {natural number or float}
1099 @item D-Bus type @tab @tab Lisp type
1101 @item DBUS_TYPE_BOOLEAN @tab @expansion{} @tab @code{t} or @code{nil}
1102 @item DBUS_TYPE_BYTE @tab @expansion{} @tab natural number
1103 @item DBUS_TYPE_UINT16 @tab @expansion{} @tab natural number
1104 @item DBUS_TYPE_INT16 @tab @expansion{} @tab integer
1105 @item DBUS_TYPE_UINT32 @tab @expansion{} @tab natural number or float
1106 @item DBUS_TYPE_UNIX_FD @tab @expansion{} @tab natural number or float
1107 @item DBUS_TYPE_INT32 @tab @expansion{} @tab integer or float
1108 @item DBUS_TYPE_UINT64 @tab @expansion{} @tab natural number or float
1109 @item DBUS_TYPE_INT64 @tab @expansion{} @tab integer or float
1110 @item DBUS_TYPE_DOUBLE @tab @expansion{} @tab float
1111 @item DBUS_TYPE_STRING @tab @expansion{} @tab string
1112 @item DBUS_TYPE_OBJECT_PATH @tab @expansion{} @tab string
1113 @item DBUS_TYPE_SIGNATURE @tab @expansion{} @tab string
1114 @item DBUS_TYPE_ARRAY @tab @expansion{} @tab list
1115 @item DBUS_TYPE_VARIANT @tab @expansion{} @tab list
1116 @item DBUS_TYPE_STRUCT @tab @expansion{} @tab list
1117 @item DBUS_TYPE_DICT_ENTRY @tab @expansion{} @tab list
1121 A float object in case of @code{DBUS_TYPE_UINT32},
1122 @code{DBUS_TYPE_INT32}, @code{DBUS_TYPE_UINT64},
1123 @code{DBUS_TYPE_INT64} and @code{DBUS_TYPE_UNIX_FD} is returned, when
1124 the C value exceeds the Emacs number size range.
1126 The resulting list of the last 4 D-Bus compound types contains as
1127 elements the elements of the D-Bus container, mapped according to the
1130 The signal @code{PropertyModified}, discussed as example in
1131 @ref{Inspection}, would offer as Lisp data the following object
1132 (@var{BOOL} stands here for either @code{nil} or @code{t}):
1135 (@var{INTEGER} ((@var{STRING} @var{BOOL} @var{BOOL}) (@var{STRING} @var{BOOL} @var{BOOL}) @dots{}))
1138 @defun dbus-byte-array-to-string byte-array
1139 If a D-Bus method or signal returns an array of bytes, which are known
1140 to represent an UTF8 string, this function converts @var{byte-array}
1141 to the corresponding string. Example:
1144 (dbus-byte-array-to-string '(47 101 116 99 47 104 111 115 116 115))
1146 @result{} "/etc/hosts"
1150 @defun dbus-unescape-from-identifier string
1151 Retrieve the original string from the encoded @var{string}.
1152 @var{string} must have been coded with
1153 @code{dbus-escape-as-identifier}. Example:
1156 (dbus-unescape-from-identifier "_30123abc_5fxyz_01_ff")
1159 @result{} "0123abc_xyz^Aÿ"
1162 @result{} "0123abc_xyz^A@"y"
1168 @node Synchronous Methods
1169 @chapter Calling methods in a blocking way.
1170 @cindex method calls, synchronous
1171 @cindex synchronous method calls
1173 Methods can be called synchronously (@dfn{blocking}) or asynchronously
1174 (@dfn{non-blocking}).
1176 At D-Bus level, a method call consist of two messages: one message
1177 which carries the input parameters to the object owning the method to
1178 be called, and a reply message returning the resulting output
1179 parameters from the object.
1181 @defun dbus-call-method bus service path interface method &optional :timeout timeout &rest args
1182 This function calls @var{method} on the D-Bus @var{bus}. @var{bus} is
1183 either the symbol @code{:system} or the symbol @code{:session}.
1185 @var{service} is the D-Bus service name to be used. @var{path} is the
1186 D-Bus object path, @var{service} is registered at. @var{interface} is
1187 an interface offered by @var{service}. It must provide @var{method}.
1189 If the parameter @code{:timeout} is given, the following integer
1190 @var{timeout} specifies the maximum number of milliseconds the method
1191 call must return. The default value is 25,000. If the method call
1192 doesn't return in time, a D-Bus error is raised (@pxref{Errors and
1195 All other arguments args are passed to @var{method} as arguments.
1196 They are converted into D-Bus types as described in @ref{Type
1199 The function returns the resulting values of @var{method} as a list of
1200 Lisp objects, according to the type conversion rules described in
1201 @ref{Type Conversion}. Example:
1205 :session "org.gnome.seahorse" "/org/gnome/seahorse/keys/openpgp"
1206 "org.gnome.seahorse.Keys" "GetKeyField"
1207 "openpgp:657984B8C7A966DD" "simple-name")
1209 @result{} (t ("Philip R. Zimmermann"))
1212 If the result of the method call is just one value, the converted Lisp
1213 object is returned instead of a list containing this single Lisp
1218 :system "org.freedesktop.Hal"
1219 "/org/freedesktop/Hal/devices/computer"
1220 "org.freedesktop.Hal.Device" "GetPropertyString"
1221 "system.kernel.machine")
1226 With the @code{dbus-introspect} function it is possible to explore the
1227 interfaces of @samp{org.freedesktop.Hal} service. It offers the
1228 interfaces @samp{org.freedesktop.Hal.Manager} for the object at the
1229 path @samp{/org/freedesktop/Hal/Manager} as well as the interface
1230 @samp{org.freedesktop.Hal.Device} for all objects prefixed with the
1231 path @samp{/org/freedesktop/Hal/devices}. With the methods
1232 @samp{GetAllDevices} and @samp{GetAllProperties}, it is simple to
1233 emulate the @code{lshal} command on GNU/Linux systems:
1238 :system "org.freedesktop.Hal"
1239 "/org/freedesktop/Hal/Manager"
1240 "org.freedesktop.Hal.Manager" "GetAllDevices"))
1241 (message "\nudi = %s" device)
1244 :system "org.freedesktop.Hal" device
1245 "org.freedesktop.Hal.Device" "GetAllProperties"))
1247 (car properties) (or (caar (cdr properties)) ""))))
1249 @print{} "udi = /org/freedesktop/Hal/devices/computer
1250 info.addons = (\"hald-addon-acpi\")
1251 info.bus = \"unknown\"
1252 info.product = \"Computer\"
1253 info.subsystem = \"unknown\"
1254 info.udi = \"/org/freedesktop/Hal/devices/computer\"
1255 linux.sysfs_path_device = \"(none)\"
1256 power_management.acpi.linux.version = \"20051216\"
1257 power_management.can_suspend_to_disk = t
1258 power_management.can_suspend_to_ram = \"\"
1259 power_management.type = \"acpi\"
1260 smbios.bios.release_date = \"11/07/2001\"
1261 system.chassis.manufacturer = \"COMPAL\"
1262 system.chassis.type = \"Notebook\"
1263 system.firmware.release_date = \"03/19/2005\"
1269 @node Asynchronous Methods
1270 @chapter Calling methods non-blocking.
1271 @cindex method calls, asynchronous
1272 @cindex asynchronous method calls
1274 @defun dbus-call-method-asynchronously bus service path interface method handler &optional :timeout timeout &rest args
1275 This function calls @var{method} on the D-Bus @var{bus}
1276 asynchronously. @var{bus} is either the symbol @code{:system} or the
1277 symbol @code{:session}.
1279 @var{service} is the D-Bus service name to be used. @var{path} is the
1280 D-Bus object path, @var{service} is registered at. @var{interface} is
1281 an interface offered by @var{service}. It must provide @var{method}.
1283 @var{handler} is a Lisp function, which is called when the
1284 corresponding return message has arrived. If @var{handler} is
1285 @code{nil}, no return message will be expected.
1287 If the parameter @code{:timeout} is given, the following integer
1288 @var{timeout} specifies the maximum number of milliseconds a reply
1289 message must arrive. The default value is 25,000. If there is no
1290 reply message in time, a D-Bus error is raised (@pxref{Errors and
1293 All other arguments args are passed to @var{method} as arguments.
1294 They are converted into D-Bus types as described in @ref{Type
1297 If @var{handler} is a Lisp function, the function returns a key into
1298 the hash table @code{dbus-registered-objects-table}. The
1299 corresponding entry in the hash table is removed, when the return
1300 message has been arrived, and @var{handler} is called. Example:
1303 (dbus-call-method-asynchronously
1304 :system "org.freedesktop.Hal"
1305 "/org/freedesktop/Hal/devices/computer"
1306 "org.freedesktop.Hal.Device" "GetPropertyString" 'message
1307 "system.kernel.machine")
1309 @result{} (:serial :system 2)
1316 @node Receiving Method Calls
1317 @chapter Offering own methods.
1318 @cindex method calls, returning
1319 @cindex returning method calls
1321 In order to register methods on the D-Bus, Emacs has to request a well
1322 known name on the D-Bus under which it will be available for other
1323 clients. Names on the D-Bus can be registered and unregistered using
1324 the following functions:
1326 @defun dbus-register-service bus service &rest flags
1327 Register the known name @var{service} on D-Bus @var{bus}.
1329 @var{bus} is either the symbol @code{:system} or the symbol
1332 @var{service} is the service name to be registered on the D-Bus. It
1333 must be a known name.
1335 @var{flags} is a subset of the following keywords:
1338 @item @code{:allow-replacement}: Allow another service to become the primary
1341 @item @code{:replace-existing}: Request to replace the current primary owner.
1343 @item @code{:do-not-queue}: If we can not become the primary owner do not
1344 place us in the queue.
1347 One of the following keywords is returned:
1351 @item @code{:primary-owner}: We have become the primary owner of the name
1354 @item @code{:in-queue}: We could not become the primary owner and
1355 have been placed in the queue.
1357 @item @code{:exists}: We already are in the queue.
1359 @item @code{:already-owner}: We already are the primary
1364 @defun dbus-unregister-service bus service
1365 Unregister all objects from D-Bus @var{bus}, registered by Emacs for
1368 @var{bus} is either the symbol @code{:system} or the symbol
1371 @var{service} is the D-Bus service name of the D-Bus. It must be a
1372 known name. Emacs releases its association to @var{service} from
1375 One of the following keywords is returned:
1378 @item @code{:released}: We successfully released the name @var{service}.
1379 @item @code{:non-existent}: The name @var{service} does not exist on the bus.
1380 @item @code{:not-owner}: We are not an owner of the name @var{service}.
1384 When a name has been chosen, Emacs can offer own methods, which can be
1385 called by other applications. These methods could be an
1386 implementation of an interface of a well known service, like
1387 @samp{org.freedesktop.TextEditor}.
1389 It could be also an implementation of an own interface. In this case,
1390 the service name must be @samp{org.gnu.Emacs}. The object path shall
1391 begin with @samp{/org/gnu/Emacs/@strong{Application}}, and the
1392 interface name shall be @code{org.gnu.Emacs.@strong{Application}}.
1393 @samp{@strong{Application}} is the name of the application which
1394 provides the interface.
1396 @deffn Constant dbus-service-emacs
1397 The well known service name @samp{org.gnu.Emacs} of Emacs.
1400 @deffn Constant dbus-path-emacs
1401 The object path namespace @samp{/org/gnu/Emacs} used by Emacs.
1404 @deffn Constant dbus-interface-emacs
1405 The interface namespace @code{org.gnu.Emacs} used by Emacs.
1408 @defun dbus-register-method bus service path interface method handler dont-register-service
1409 With this function, an application registers @var{method} on the D-Bus
1412 @var{bus} is either the symbol @code{:system} or the symbol
1415 @var{service} is the D-Bus service name of the D-Bus object
1416 @var{method} is registered for. It must be a known name (See
1417 discussion of @var{dont-register-service} below).
1419 @var{path} is the D-Bus object path @var{service} is registered (See
1420 discussion of @var{dont-register-service} below).
1422 @var{interface} is the interface offered by @var{service}. It must
1423 provide @var{method}.
1425 @var{handler} is a Lisp function to be called when a @var{method} call
1426 is received. It must accept as arguments the input arguments of
1427 @var{method}. @var{handler} should return a list, whose elements are
1428 to be used as arguments for the reply message of @var{method}. This
1429 list can be composed like the input parameters in @ref{Type
1432 If @var{handler} wants to return just one Lisp object and it is not a
1433 cons cell, @var{handler} can return this object directly, instead of
1434 returning a list containing the object.
1436 In case @var{handler} shall return a reply message with an empty
1437 argument list, @var{handler} must return the symbol @code{:ignore}.
1439 When @var{dont-register-service} is non-@code{nil}, the known name
1440 @var{service} is not registered. This means that other D-Bus clients
1441 have no way of noticing the newly registered method. When interfaces
1442 are constructed incrementally by adding single methods or properties
1443 at a time, @var{dont-register-service} can be used to prevent other
1444 clients from discovering the still incomplete interface.
1446 The default D-Bus timeout when waiting for a message reply is 25
1447 seconds. This value could be even smaller, depending on the calling
1448 client. Therefore, @var{handler} shall not last longer than
1449 absolutely necessary.
1451 @code{dbus-register-method} returns a Lisp object, which can be used
1452 as argument in @code{dbus-unregister-object} for removing the
1453 registration for @var{method}. Example:
1456 (defun my-dbus-method-handler (filename)
1458 (if (find-file filename)
1459 (setq result '(:boolean t))
1460 (setq result '(:boolean nil)))
1463 @result{} my-dbus-method-handler
1465 (dbus-register-method
1466 :session "org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
1467 "org.freedesktop.TextEditor" "OpenFile"
1468 'my-dbus-method-handler)
1470 @result{} ((:method :session "org.freedesktop.TextEditor" "OpenFile")
1471 ("org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
1472 my-dbus-method-handler))
1475 If you invoke the method @samp{org.freedesktop.TextEditor.OpenFile}
1476 from another D-Bus application with a filename as parameter, the file
1477 is opened in Emacs, and the method returns either @var{true} or
1478 @var{false}, indicating the success of the method. As test tool one
1479 could use the command line tool @code{dbus-send} in a shell:
1482 # dbus-send --session --print-reply \
1483 --dest="org.freedesktop.TextEditor" \
1484 "/org/freedesktop/TextEditor" \
1485 "org.freedesktop.TextEditor.OpenFile" string:"/etc/hosts"
1487 @print{} method return sender=:1.22 -> dest=:1.23 reply_serial=2
1491 You can indicate an error by raising the Emacs signal
1492 @code{dbus-error}. The handler above could be changed like this:
1495 (defun my-dbus-method-handler (&rest args)
1496 (unless (and (= (length args) 1) (stringp (car args)))
1497 (signal 'dbus-error (list (format "Wrong argument list: %S" args))))
1499 (find-file (car args))
1500 (error (signal 'dbus-error (cdr err))))
1503 @result{} my-dbus-method-handler
1509 # dbus-send --session --print-reply \
1510 --dest="org.freedesktop.TextEditor" \
1511 "/org/freedesktop/TextEditor" \
1512 "org.freedesktop.TextEditor.OpenFile" \
1513 string:"/etc/hosts" string:"/etc/passwd"
1515 @print{} Error org.freedesktop.DBus.Error.Failed:
1516 Wrong argument list: ("/etc/hosts" "/etc/passwd")
1520 @defun dbus-register-property bus service path interface property access value &optional emits-signal dont-register-service
1521 With this function, an application declares a @var{property} on the D-Bus
1524 @var{bus} is either the symbol @code{:system} or the symbol
1527 @var{service} is the D-Bus service name of the D-Bus. It must be a
1530 @var{path} is the D-Bus object path @var{service} is registered (See
1531 discussion of @var{dont-register-service} below).
1533 @var{interface} is the name of the interface used at @var{path},
1534 @var{property} is the name of the property of @var{interface}.
1536 @var{access} indicates, whether the property can be changed by other
1537 services via D-Bus. It must be either the symbol @code{:read} or
1538 @code{:readwrite}. @var{value} is the initial value of the property,
1539 it can be of any valid type (see @code{dbus-call-method} for details).
1541 If @var{property} already exists on @var{path}, it will be
1542 overwritten. For properties with access type @code{:read} this is the
1543 only way to change their values. Properties with access type
1544 @code{:readwrite} can be changed by @code{dbus-set-property}.
1546 The interface @samp{org.freedesktop.DBus.Properties} is added to
1547 @var{path}, including a default handler for the @samp{Get},
1548 @samp{GetAll} and @samp{Set} methods of this interface. When
1549 @var{emits-signal} is non-@code{nil}, the signal
1550 @samp{PropertiesChanged} is sent when the property is changed by
1551 @code{dbus-set-property}.
1553 When @var{dont-register-service} is non-@code{nil}, the known name
1554 @var{service} is not registered. This means that other D-Bus clients
1555 have no way of noticing the newly registered method. When interfaces
1556 are constructed incrementally by adding single methods or properties
1557 at a time, @var{dont-register-service} can be used to prevent other
1558 clients from discovering the still incomplete interface.
1563 (dbus-register-property
1564 :session "org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
1565 "org.freedesktop.TextEditor" "name" :read "GNU Emacs")
1567 @result{} ((:property :session "org.freedesktop.TextEditor" "name")
1568 ("org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"))
1570 (dbus-register-property
1571 :session "org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
1572 "org.freedesktop.TextEditor" "version" :readwrite emacs-version t)
1574 @result{} ((:property :session "org.freedesktop.TextEditor" "version")
1575 ("org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"))
1578 Other D-Bus applications can read the property via the default methods
1579 @samp{org.freedesktop.DBus.Properties.Get} and
1580 @samp{org.freedesktop.DBus.Properties.GetAll}. Testing is also
1581 possible via the command line tool @code{dbus-send} in a shell:
1584 # dbus-send --session --print-reply \
1585 --dest="org.freedesktop.TextEditor" \
1586 "/org/freedesktop/TextEditor" \
1587 "org.freedesktop.DBus.Properties.GetAll" \
1588 string:"org.freedesktop.TextEditor"
1590 @print{} method return sender=:1.22 -> dest=:1.23 reply_serial=3
1594 variant string "GNU Emacs"
1598 variant string "23.1.50.5"
1603 It is also possible, to apply the @code{dbus-get-property},
1604 @code{dbus-get-all-properties} and @code{dbus-set-property} functions
1605 (@pxref{Properties and Annotations}).
1609 :session "org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
1610 "org.freedesktop.TextEditor" "version" "23.1.50")
1615 :session "org.freedesktop.TextEditor" "/org/freedesktop/TextEditor"
1616 "org.freedesktop.TextEditor" "version")
1622 @defun dbus-unregister-object object
1623 Unregister @var{object} from the D-Bus. @var{object} must be the
1624 result of a preceding @code{dbus-register-method},
1625 @code{dbus-register-property} or @code{dbus-register-signal} call
1626 (@pxref{Signals}). It returns @code{t} if @var{object} has been
1627 unregistered, @code{nil} otherwise.
1629 When @var{object} identifies the last method or property, which is
1630 registered for the respective service, Emacs releases its association
1631 to the service from D-Bus.
1636 @chapter Sending and receiving signals.
1639 Signals are one way messages. They carry input parameters, which are
1640 received by all objects which have registered for such a signal.
1642 @defun dbus-send-signal bus service path interface signal &rest args
1643 This function is similar to @code{dbus-call-method}. The difference
1644 is, that there are no returning output parameters.
1646 The function emits @var{signal} on the D-Bus @var{bus}. @var{bus} is
1647 either the symbol @code{:system} or the symbol @code{:session}. It
1648 doesn't matter whether another object has registered for @var{signal}.
1650 Signals can be unicast or broadcast messages. For broadcast messages,
1651 @var{service} must be @code{nil}. Otherwise, @var{service} is the
1652 D-Bus service name the signal is sent to as unicast
1653 message.@footnote{For backward compatibility, a broadcast message is
1654 also emitted if @var{service} is the known or unique name Emacs is
1655 registered at D-Bus @var{bus}.} @var{path} is the D-Bus object path
1656 @var{signal} is sent from. @var{interface} is an interface available
1657 at @var{path}. It must provide @var{signal}.
1659 All other arguments args are passed to @var{signal} as arguments.
1660 They are converted into D-Bus types as described in @ref{Type
1661 Conversion}. Example:
1665 :session nil dbus-path-emacs
1666 (concat dbus-interface-emacs ".FileManager") "FileModified"
1667 "/home/albinus/.emacs")
1671 @defun dbus-register-signal bus service path interface signal handler &rest args
1672 With this function, an application registers for a signal on the D-Bus
1675 @var{bus} is either the symbol @code{:system} or the symbol
1678 @var{service} is the D-Bus service name used by the sending D-Bus
1679 object. It can be either a known name or the unique name of the D-Bus
1680 object sending the signal. A known name will be mapped onto the
1681 unique name of the object, owning @var{service} at registration time.
1682 When the corresponding D-Bus object disappears, signals won't be
1683 received any longer.
1685 @var{path} is the corresponding D-Bus object path, @var{service} is
1686 registered at. @var{interface} is an interface offered by
1687 @var{service}. It must provide @var{signal}.
1689 @var{service}, @var{path}, @var{interface} and @var{signal} can be
1690 @code{nil}. This is interpreted as a wildcard for the respective
1693 @var{handler} is a Lisp function to be called when the @var{signal} is
1694 received. It must accept as arguments the output parameters
1695 @var{signal} is sending.
1697 The remaining arguments @var{args} can be keywords or keyword string
1698 pairs.@footnote{For backward compatibility, the arguments @var{args}
1699 can also be just strings. They stand for the respective arguments of
1700 @var{signal} in their order, and are used for filtering as well. A
1701 @code{nil} argument might be used to preserve the order.} The meaning
1705 @item @code{:argN} @var{string}:@*
1706 @code{:pathN} @var{string}:@*
1707 This stands for the Nth argument of the signal. @code{:pathN}
1708 arguments can be used for object path wildcard matches as specified by
1709 D-Bus, while an @code{:argN} argument requires an exact match.
1711 @item @code{:arg-namespace} @var{string}:@*
1712 Register for the signals, which first argument defines the service or
1713 interface namespace @var{string}.
1715 @item @code{:path-namespace} @var{string}:@*
1716 Register for the object path namespace @var{string}. All signals sent
1717 from an object path, which has @var{string} as the preceding string,
1718 are matched. This requires @var{path} to be @code{nil}.
1720 @item @code{:eavesdrop}:@*
1721 Register for unicast signals which are not directed to the D-Bus
1722 object Emacs is registered at D-Bus BUS, if the security policy of BUS
1723 allows this. Otherwise, this argument is ignored.
1726 @code{dbus-register-signal} returns a Lisp object, which can be used
1727 as argument in @code{dbus-unregister-object} for removing the
1728 registration for @var{signal}. Example:
1731 (defun my-dbus-signal-handler (device)
1732 (message "Device %s added" device))
1734 @result{} my-dbus-signal-handler
1736 (dbus-register-signal
1737 :system "org.freedesktop.Hal" "/org/freedesktop/Hal/Manager"
1738 "org.freedesktop.Hal.Manager" "DeviceAdded"
1739 'my-dbus-signal-handler)
1741 @result{} ((:signal :system "org.freedesktop.Hal.Manager" "DeviceAdded")
1742 ("org.freedesktop.Hal" "/org/freedesktop/Hal/Manager"
1746 As we know from the introspection data of interface
1747 @samp{org.freedesktop.Hal.Manager}, the signal @samp{DeviceAdded}
1748 provides one single parameter, which is mapped into a Lisp string.
1749 The callback function @code{my-dbus-signal-handler} must define one
1750 single string argument therefore. Plugging an USB device to your
1751 machine, when registered for signal @samp{DeviceAdded}, will show you
1752 which objects the GNU/Linux @code{hal} daemon adds.
1754 Some of the match rules have been added to a later version of D-Bus.
1755 In order to test the availability of such features, you could register
1756 for a dummy signal, and check the result:
1760 (dbus-register-signal
1761 :system nil nil nil nil 'ignore :path-namespace "/invalid/path"))
1768 @node Alternative Buses
1769 @chapter Alternative buses and environments.
1771 @cindex UNIX domain socket
1772 @cindex TCP/IP socket
1774 Until now, we have spoken about the system and the session buses,
1775 which are the default buses to be connected to. However, it is
1776 possible to connect to any bus, from which the address is known. This
1777 is a UNIX domain or TCP/IP socket. Everywhere, where a @var{bus} is
1778 mentioned as argument of a function (the symbol @code{:system} or the
1779 symbol @code{:session}), this address can be used instead. The
1780 connection to this bus must be initialized first.
1782 @defun dbus-init-bus bus &optional private
1783 Establish the connection to D-Bus @var{bus}.
1785 @var{bus} can be either the symbol @code{:system} or the symbol
1786 @code{:session}, or it can be a string denoting the address of the
1787 corresponding bus. For the system and session buses, this function
1788 is called when loading @file{dbus.el}, there is no need to call it
1791 The function returns a number, which counts the connections this Emacs
1792 session has established to the @var{bus} under the same unique name
1793 (see @code{dbus-get-unique-name}). It depends on the libraries Emacs
1794 is linked with, and on the environment Emacs is running. For example,
1795 if Emacs is linked with the gtk toolkit, and it runs in a GTK-aware
1796 environment like Gnome, another connection might already be
1799 When @var{private} is non-@code{nil}, a new connection is established
1800 instead of reusing an existing one. It results in a new unique name
1801 at the bus. This can be used, if it is necessary to distinguish from
1802 another connection used in the same Emacs process, like the one
1803 established by GTK+. It should be used with care for at least the
1804 @code{:system} and @code{:session} buses, because other Emacs Lisp
1805 packages might already use this connection to those buses.
1807 Example: You initialize a connection to the AT-SPI bus on your host:
1812 :session "org.a11y.Bus" "/org/a11y/bus"
1813 "org.a11y.Bus" "GetAddress"))
1815 @result{} "unix:abstract=/tmp/dbus-2yzWHOCdSD,guid=a490dd26625870ca1298b6e10000fd7f"
1817 ;; If Emacs is built with gtk support, and you run in a GTK enabled
1818 ;; environment (like a GNOME session), the initialization reuses the
1819 ;; connection established by GTK's atk bindings.
1820 (dbus-init-bus my-bus)
1824 (dbus-get-unique-name my-bus)
1828 ;; Open a new connection to the same bus. This obsoletes the
1830 (dbus-init-bus my-bus 'private)
1834 (dbus-get-unique-name my-bus)
1839 D-Bus addresses can specify different transport. A possible address
1840 could be based on TCP/IP sockets, see next example. However, it
1841 depends on the bus daemon configuration, which transport is supported.
1844 @defun dbus-setenv bus variable value
1845 Set the value of the @var{bus} environment variable @var{variable} to
1848 @var{bus} is either a Lisp symbol, @code{:system} or @code{:session},
1849 or a string denoting the bus address. Both @var{variable} and
1850 @var{value} should be strings.
1852 Normally, services inherit the environment of the bus daemon. This
1853 function adds to or modifies that environment when activating services.
1855 Some bus instances, such as @code{:system}, may disable setting the
1856 environment. In such cases, or if this feature is not available in
1857 older D-Bus versions, a @code{dbus-error} error is raised.
1859 As an example, it might be desirable to start X11 enabled services on
1860 a remote host's bus on the same X11 server the local Emacs is
1861 running. This could be achieved by
1864 (setq my-bus "unix:host=example.gnu.org,port=4711")
1866 @result{} "unix:host=example.gnu.org,port=4711"
1868 (dbus-init-bus my-bus)
1872 (dbus-setenv my-bus "DISPLAY" (getenv "DISPLAY"))
1879 @node Errors and Events
1880 @chapter Errors and events.
1885 The internal actions can be traced by running in a debug mode.
1888 If this variable is non-@code{nil}, D-Bus specific debug messages are raised.
1891 Input parameters of @code{dbus-call-method},
1892 @code{dbus-call-method-asynchronously}, @code{dbus-send-signal},
1893 @code{dbus-register-method}, @code{dbus-register-property} and
1894 @code{dbus-register-signal} are checked for correct D-Bus types. If
1895 there is a type mismatch, the Lisp error @code{wrong-type-argument}
1896 @code{D-Bus ARG} is raised.
1898 All errors raised by D-Bus are signaled with the error symbol
1899 @code{dbus-error}. If possible, error messages from D-Bus are
1900 appended to the @code{dbus-error}.
1902 @defspec dbus-ignore-errors forms@dots{}
1903 This executes @var{forms} exactly like a @code{progn}, except that
1904 @code{dbus-error} errors are ignored during the @var{forms}. These
1905 errors can be made visible when @code{dbus-debug} is set to @code{t}.
1908 Incoming D-Bus messages are handled as Emacs events, see @pxref{Misc
1909 Events, , , elisp}. They are retrieved only, when Emacs runs in
1910 interactive mode. The generated event has this form:
1913 (dbus-event @var{bus} @var{type} @var{serial} @var{service} @var{path} @var{interface} @var{member} @var{handler}
1917 @var{bus} identifies the D-Bus the message is coming from. It is
1918 either the symbol @code{:system} or the symbol @code{:session}.
1920 @var{type} is the D-Bus message type which has caused the event. It
1921 can be @code{dbus-message-type-invalid},
1922 @code{dbus-message-type-method-call},
1923 @code{dbus-message-type-method-return},
1924 @code{dbus-message-type-error}, or @code{dbus-message-type-signal}.
1925 @var{serial} is the serial number of the received D-Bus message.
1927 @var{service} and @var{path} are the unique name and the object path
1928 of the D-Bus object emitting the message. @var{interface} and
1929 @var{member} denote the message which has been sent.
1931 @var{handler} is the callback function which has been registered for
1932 this message (see @pxref{Signals}). When a @code{dbus-event} event
1933 arrives, @var{handler} is called with @var{args} as arguments.
1935 In order to inspect the @code{dbus-event} data, you could extend the
1936 definition of the callback function in @ref{Signals}:
1939 (defun my-dbus-signal-handler (&rest args)
1940 (message "my-dbus-signal-handler: %S" last-input-event))
1943 There exist convenience functions which could be called inside a
1944 callback function in order to retrieve the information from the event.
1946 @defun dbus-event-bus-name event
1947 Returns the bus name @var{event} is coming from.
1948 The result is either the symbol @code{:system} or the symbol @code{:session}.
1951 @defun dbus-event-message-type event
1952 Returns the message type of the corresponding D-Bus message. The
1953 result is a natural number.
1956 @defun dbus-event-serial-number event
1957 Returns the serial number of the corresponding D-Bus message.
1958 The result is a natural number.
1961 @defun dbus-event-service-name event
1962 Returns the unique name of the D-Bus object @var{event} is coming from.
1965 @defun dbus-event-path-name event
1966 Returns the object path of the D-Bus object @var{event} is coming from.
1969 @defun dbus-event-interface-name event
1970 Returns the interface name of the D-Bus object @var{event} is coming from.
1973 @defun dbus-event-member-name event
1974 Returns the member name of the D-Bus object @var{event} is coming
1975 from. It is either a signal name or a method name.
1978 D-Bus errors are not propagated during event handling, because it is
1979 usually not desired. D-Bus errors in events can be made visible by
1980 setting the variable @code{dbus-debug} to @code{t}. They can also be
1981 handled by a hook function.
1983 @defvar dbus-event-error-functions
1984 This hook variable keeps a list of functions, which are called when a
1985 D-Bus error happens in the event handler. Every function must accept
1986 two arguments, the event and the error variable caught in
1987 @code{condition-case} by @code{dbus-error}.
1989 Such functions can be used the adapt the error signal to be raised.
1993 (defun my-dbus-event-error-handler (event error)
1994 (when (string-equal (concat dbus-interface-emacs ".FileManager")
1995 (dbus-event-interface-name event))
1996 (message "my-dbus-event-error-handler: %S %S" event error)
1997 (signal 'file-error (cdr error))))
1999 (add-hook 'dbus-event-error-functions 'my-dbus-event-error-handler)
2003 Hook functions shall take into account, that there might be other
2004 D-Bus applications running. Therefore, they shall check carefully,
2005 whether a given D-Bus error is related to them.
2014 @node GNU Free Documentation License
2015 @appendix GNU Free Documentation License
2016 @include doclicense.texi