<article id="index">
<articleinfo>
<title>D-Bus Tutorial</title>
- <releaseinfo>Version 0.4.1</releaseinfo>
- <date>15 July 2005</date>
+ <releaseinfo>Version 0.5.0</releaseinfo>
+ <date>20 August 2006</date>
<authorgroup>
<author>
<firstname>Havoc</firstname>
</authorgroup>
</articleinfo>
+ <sect1 id="meta">
+ <title>Tutorial Work In Progress</title>
+
+ <para>
+ This tutorial is not complete; it probably contains some useful information, but
+ also has plenty of gaps. Right now, you'll also need to refer to the D-Bus specification,
+ Doxygen reference documentation, and look at some examples of how other apps use D-Bus.
+ </para>
+
+ <para>
+ Enhancing the tutorial is definitely encouraged - send your patches or suggestions to the
+ mailing list. If you create a D-Bus binding, please add a section to the tutorial for your
+ binding, if only a short section with a couple of examples.
+ </para>
+
+ </sect1>
+
<sect1 id="whatis">
<title>What is D-Bus?</title>
<para>
</listitem>
<listitem>
<para>
- <firstterm>Wrapper libraries</firstterm> based on particular
- application frameworks. For example, libdbus-glib and
+ <firstterm>Wrapper libraries</firstterm> or <firstterm>bindings</firstterm>
+ based on particular application frameworks. For example, libdbus-glib and
libdbus-qt. There are also bindings to languages such as
Python. These wrapper libraries are the API most people should use,
as they simplify the details of D-Bus programming. libdbus is
</para>
<para>
- If you just want to use D-Bus and don't care how it works, jump directly
- to <xref linkend="concepts"/>.
- Otherwise, read on.
- </para>
-
- <para>
libdbus only supports one-to-one connections, just like a raw network
socket. However, rather than sending byte streams over the connection, you
send <firstterm>messages</firstterm>. Messages have a header identifying
<listitem>
<para>
Many implementation and deployment issues are specified rather
- than left ambiguous.
+ than left ambiguous/configurable/pluggable.
</para>
</listitem>
<listitem>
</para>
<sect2 id="objects">
- <title>Objects and Object Paths</title>
+ <title>Native Objects and Object Paths</title>
<para>
- Each application using D-Bus contains <firstterm>objects</firstterm>,
- which generally map to GObject, QObject, C++ objects, or Python objects
- (but need not). An object is an <emphasis>instance</emphasis> rather
- than a type. When messages are received over a D-Bus connection, they
- are sent to a specific object, not to the application as a whole.
+ Your programming framework probably defines what an "object" is like;
+ usually with a base class. For example: java.lang.Object, GObject, QObject,
+ python's base Object, or whatever. Let's call this a <firstterm>native object</firstterm>.
</para>
<para>
- To allow messages to specify their destination object, there has to be a
- way to refer to an object. In your favorite programming language, this
- is normally called a <firstterm>pointer</firstterm> or
- <firstterm>reference</firstterm>. However, these references are
- implemented as memory addresses relative to the address space of your
- application, and thus can't be passed from one application to another.
+ The low-level D-Bus protocol, and corresponding libdbus API, does not care about native objects.
+ However, it provides a concept called an
+ <firstterm>object path</firstterm>. The idea of an object path is that
+ higher-level bindings can name native object instances, and allow remote applications
+ to refer to them.
</para>
<para>
- To solve this, D-Bus introduces a name for each object. The name
+ The object path
looks like a filesystem path, for example an object could be
named <literal>/org/kde/kspread/sheets/3/cells/4/5</literal>.
Human-readable paths are nice, but you are free to create an
</para>
</sect2>
+ <sect2 id="members">
+ <title>Methods and Signals</title>
+
+ <para>
+ Each object has <firstterm>members</firstterm>; the two kinds of member
+ are <firstterm>methods</firstterm> and
+ <firstterm>signals</firstterm>. Methods are operations that can be
+ invoked on an object, with optional input (aka arguments or "in
+ parameters") and output (aka return values or "out parameters").
+ Signals are broadcasts from the object to any interested observers
+ of the object; signals may contain a data payload.
+ </para>
+
+ <para>
+ Both methods and signals are referred to by name, such as
+ "Frobate" or "OnClicked".
+ </para>
+
+ </sect2>
+
<sect2 id="interfaces">
<title>Interfaces</title>
<para>
just as it is in GLib or Qt or Java. Interfaces define the
<emphasis>type</emphasis> of an object instance.
</para>
+ <para>
+ DBus identifies interfaces with a simple namespaced string,
+ something like <literal>org.freedesktop.Introspectable</literal>.
+ Most bindings will map these interface names directly to
+ the appropriate programming language construct, for example
+ to Java interfaces or C++ pure virtual classes.
+ </para>
</sect2>
-
- <sect2 id="messages">
- <title>Message Types</title>
+
+ <sect2 id="proxies">
+ <title>Proxies</title>
<para>
- Messages are not all the same; in particular, D-Bus has
- 4 built-in message types:
- <itemizedlist>
- <listitem>
- <para>
- Method call messages ask to invoke a method
- on an object.
- </para>
- </listitem>
- <listitem>
- <para>
- Method return messages return the results
- of invoking a method.
- </para>
- </listitem>
- <listitem>
- <para>
- Error messages return an exception caused by
- invoking a method.
- </para>
- </listitem>
- <listitem>
- <para>
- Signal messages are notifications that a given signal
- has been emitted (that an event has occurred).
- You could also think of these as "event" messages.
- </para>
- </listitem>
- </itemizedlist>
+ A <firstterm>proxy object</firstterm> is a convenient native object created to
+ represent a remote object in another process. The low-level DBus API involves manually creating
+ a method call message, sending it, then manually receiving and processing
+ the method reply message. Higher-level bindings provide proxies as an alternative.
+ Proxies look like a normal native object; but when you invoke a method on the proxy
+ object, the binding converts it into a DBus method call message, waits for the reply
+ message, unpacks the return value, and returns it from the native method..
</para>
<para>
- A method call maps very simply to messages, then: you send a method call
- message, and receive either a method return message or an error message
- in reply.
+ In pseudocode, programming without proxies might look like this:
+ <programlisting>
+ Message message = new Message("/remote/object/path", "MethodName", arg1, arg2);
+ Connection connection = getBusConnection();
+ connection.send(message);
+ Message reply = connection.waitForReply(message);
+ if (reply.isError()) {
+
+ } else {
+ Object returnValue = reply.getReturnValue();
+ }
+ </programlisting>
+ </para>
+ <para>
+ Programming with proxies might look like this:
+ <programlisting>
+ Proxy proxy = new Proxy(getBusConnection(), "/remote/object/path");
+ Object returnValue = proxy.MethodName(arg1, arg2);
+ </programlisting>
</para>
</sect2>
<sect2 id="bus-names">
<title>Bus Names</title>
-
+
<para>
- Object paths, interfaces, and messages exist on the level of
- libdbus and the D-Bus protocol; they are used even in the
- 1-to-1 case with no message bus involved.
+ When each application connects to the bus daemon, the daemon immediately
+ assigns it a name, called the <firstterm>unique connection name</firstterm>.
+ A unique name begins with a ':' (colon) character. These names are never
+ reused during the lifetime of the bus daemon - that is, you know
+ a given name will always refer to the same application.
+ An example of a unique name might be
+ <literal>:34-907</literal>. The numbers after the colon have
+ no meaning other than their uniqueness.
</para>
<para>
- Bus names, on the other hand, are a property of the message bus daemon.
- The bus maintains a mapping from names to message bus connections.
- These names are used to specify the origin and destination
- of messages passing through the message bus. When a name is mapped
+ When a name is mapped
to a particular application's connection, that application is said to
<firstterm>own</firstterm> that name.
</para>
<para>
- On connecting to the bus daemon, each application immediately owns a
- special name called the <firstterm>unique connection name</firstterm>.
- A unique name begins with a ':' (colon) character; no other names are
- allowed to begin with that character. Unique names are special because
- they are created dynamically, and are never re-used during the lifetime
- of the same bus daemon. You know that a given unique name will have the
- same owner at all times. An example of a unique name might be
- <literal>:34-907</literal>. The numbers after the colon have
- no meaning other than their uniqueness.
- </para>
-
- <para>
Applications may ask to own additional <firstterm>well-known
names</firstterm>. For example, you could write a specification to
define a name called <literal>com.mycompany.TextEditor</literal>.
Your definition could specify that to own this name, an application
should have an object at the path
<literal>/com/mycompany/TextFileManager</literal> supporting the
- interface <literal>org.freedesktop.FileHandler</literal>.
+ interface <literal>org.freedesktop.FileHandler</literal>.
</para>
<para>
monitor the lifetime of other applications.
</para>
+ <para>
+ Bus names can also be used to coordinate single-instance applications.
+ If you want to be sure only one
+ <literal>com.mycompany.TextEditor</literal> application is running for
+ example, have the text editor application exit if the bus name already
+ has an owner.
+ </para>
+
</sect2>
<sect2 id="addresses">
</para>
<para>
+ If you're using the bus daemon, as you probably are, your application
+ will be a client of the bus daemon. That is, the bus daemon listens
+ for connections and your application initiates a connection to the bus
+ daemon.
+ </para>
+
+ <para>
A D-Bus <firstterm>address</firstterm> specifies where a server will
listen, and where a client will connect. For example, the address
<literal>unix:path=/tmp/abcdef</literal> specifies that the server will
</para>
<para>
- When using D-Bus with a message bus, the bus daemon is a server
- and all other applications are clients of the bus daemon.
+ When using D-Bus with a message bus daemon,
libdbus automatically discovers the address of the per-session bus
daemon by reading an environment variable. It discovers the
systemwide bus daemon by checking a well-known UNIX domain socket path
If you're using D-Bus without a bus daemon, it's up to you to
define which application will be the server and which will be
the client, and specify a mechanism for them to agree on
- the server's address.
+ the server's address. This is an unusual case.
</para>
</sect2>
omit the interface, but if your method name is ambiguous
it is undefined which method will be invoked.
</para>
-
+
+ </sect2>
+
+ <sect2 id="messages">
+ <title>Messages - Behind the Scenes</title>
+ <para>
+ D-Bus works by sending messages between processes. If you're using
+ a sufficiently high-level binding, you may never work with messages directly.
+ </para>
+ <para>
+ There are 4 message types:
+ <itemizedlist>
+ <listitem>
+ <para>
+ Method call messages ask to invoke a method
+ on an object.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Method return messages return the results
+ of invoking a method.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Error messages return an exception caused by
+ invoking a method.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Signal messages are notifications that a given signal
+ has been emitted (that an event has occurred).
+ You could also think of these as "event" messages.
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ A method call maps very simply to messages: you send a method call
+ message, and receive either a method return message or an error message
+ in reply.
+ </para>
+ <para>
+ Each message has a <firstterm>header</firstterm>, including <firstterm>fields</firstterm>,
+ and a <firstterm>body</firstterm>, including <firstterm>arguments</firstterm>. You can think
+ of the header as the routing information for the message, and the body as the payload.
+ Header fields might include the sender bus name, destination bus name, method or signal name,
+ and so forth. One of the header fields is a <firstterm>type signature</firstterm> describing the
+ values found in the body. For example, the letter "i" means "32-bit integer" so the signature
+ "ii" means the payload has two 32-bit integers.
+ </para>
+ </sect2>
+
+ <sect2 id="callprocedure">
+ <title>Calling a Method - Behind the Scenes</title>
+
+ <para>
+ A method call in DBus consists of two messages; a method call message sent from process A to process B,
+ and a matching method reply message sent from process B to process A. Both the call and the reply messages
+ are routed through the bus daemon. The caller includes a different serial number in each call message, and the
+ reply message includes this number to allow the caller to match replies to calls.
+ </para>
+
+ <para>
+ The call message will contain any arguments to the method.
+ The reply message may indicate an error, or may contain data returned by the method.
+ </para>
+
+ <para>
+ A method invocation in DBus happens as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ The language binding may provide a proxy, such that invoking a method on
+ an in-process object invokes a method on a remote object in another process. If so, the
+ application calls a method on the proxy, and the proxy
+ constructs a method call message to send to the remote process.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ For more low-level APIs, the application may construct a method call message itself, without
+ using a proxy.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ In either case, the method call message contains: a bus name belonging to the remote process; the name of the method;
+ the arguments to the method; an object path inside the remote process; and optionally the name of the
+ interface that specifies the method.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ The method call message is sent to the bus daemon.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ The bus daemon looks at the destination bus name. If a process owns that name,
+ the bus daemon forwards the method call to that process. Otherwise, the bus daemon
+ creates an error message and sends it back as the reply to the method call message.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ The receiving process unpacks the method call message. In a simple low-level API situation, it
+ may immediately run the method and send a method reply message to the bus daemon.
+ When using a high-level binding API, the binding might examine the object path, interface,
+ and method name, and convert the method call message into an invocation of a method on
+ a native object (GObject, java.lang.Object, QObject, etc.), then convert the return
+ value from the native method into a method reply message.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ The bus daemon receives the method reply message and sends it to the process that
+ made the method call.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ The process that made the method call looks at the method reply and makes use of any
+ return values included in the reply. The reply may also indicate that an error occurred.
+ When using a binding, the method reply message may be converted into the return value of
+ of a proxy method, or into an exception.
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+
+ <para>
+ The bus daemon never reorders messages. That is, if you send two method call messages to the same recipient,
+ they will be received in the order they were sent. The recipient is not required to reply to the calls
+ in order, however; for example, it may process each method call in a separate thread, and return reply messages
+ in an undefined order depending on when the threads complete. Method calls have a unique serial
+ number used by the method caller to match reply messages to call messages.
+ </para>
+
+ </sect2>
+
+ <sect2 id="signalprocedure">
+ <title>Emitting a Signal - Behind the Scenes</title>
+
+ <para>
+ A signal in DBus consists of a single message, sent by one process to any number of other processes.
+ That is, a signal is a unidirectional broadcast. The signal may contain arguments (a data payload), but
+ because it is a broadcast, it never has a "return value." Contrast this with a method call
+ (see <xref linkend="callprocedure"/>) where the method call message has a matching method reply message.
+ </para>
+
+ <para>
+ The emitter (aka sender) of a signal has no knowledge of the signal recipients. Recipients register
+ with the bus daemon to receive signals based on "match rules" - these rules would typically include the sender and
+ the signal name. The bus daemon sends each signal only to recipients who have expressed interest in that
+ signal.
+ </para>
+
+ <para>
+ A signal in DBus happens as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ A signal message is created and sent to the bus daemon. When using the low-level API this may be
+ done manually, with certain bindings it may be done for you by the binding when a native object
+ emits a native signal or event.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ The signal message contains the name of the interface that specifies the signal;
+ the name of the signal; the bus name of the process sending the signal; and
+ any arguments
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Any process on the message bus can register "match rules" indicating which signals it
+ is interested in. The bus has a list of registered match rules.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ The bus daemon examines the signal and determines which processes are interested in it.
+ It sends the signal message to these processes.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Each process receiving the signal decides what to do with it; if using a binding,
+ the binding may choose to emit a native signal on a proxy object. If using the
+ low-level API, the process may just look at the signal sender and name and decide
+ what to do based on that.
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+
+ </sect2>
+
+ <sect2 id="introspection">
+ <title>Introspection</title>
+
+ <para>
+ D-Bus objects may support the interface <literal>org.freedesktop.DBus.Introspectable</literal>.
+ This interface has one method <literal>Introspect</literal> which takes no arguments and returns
+ an XML string. The XML string describes the interfaces, methods, and signals of the object.
+ See the D-Bus specification for more details on this introspection format.
+ </para>
+
</sect2>
</sect1>
</sect1>
<sect1 id="python-client">
- <title>Python API: Using Remote Objects</title>
+ <title>Python API</title>
<para>
- The Python bindings provide a simple to use interface for talking over D-Bus.
- Where possible much of the inner-workings of D-Bus are hidden behind what looks
- like normal Python objects.
+ The Python API, dbus-python, is now documented separately in
+ <ulink url="http://dbus.freedesktop.org/doc/dbus-python/doc/tutorial.html">the dbus-python tutorial</ulink> (also available in doc/tutorial.txt,
+ and doc/tutorial.html if built with python-docutils, in the dbus-python
+ source distribution).
</para>
- <sect2 id="python-typemappings">
- <title>D-Bus - Python type mappings</title>
- <para>
- While python itself is a largely untyped language D-Bus provides a simple type system
- for talking with other languages which may be strongly typed. Python for the most part
- tries automatically map python objects to types on the bus. It is none the less good to
- know what the type mappings are so one can better utilize services over the bus.
- </para>
- <sect3 id="python-basic-typemappings">
- <title>Basic type mappings</title>
- <para>
- Below is a list of the basic types, along with their associated
- mapping to a Python object.
- <informaltable>
- <tgroup cols="3">
- <thead>
- <row>
- <entry>D-Bus basic type</entry>
- <entry>Python wrapper</entry>
- <entry>Notes</entry>
- </row>
- </thead>
- <tbody>
- <row>
- <entry><literal>BYTE</literal></entry>
- <entry><literal>dbus.Byte</literal></entry>
- <entry></entry>
- </row><row>
- <entry><literal>BOOLEAN</literal></entry>
- <entry><literal>dbus.Boolean</literal></entry>
- <entry>Any variable assigned a True or False boolean value will automatically be converted into a BOOLEAN over the bus</entry>
- </row><row>
- <entry><literal>INT16</literal></entry>
- <entry><literal>dbus.Int16</literal></entry>
- <entry></entry>
- </row><row>
- <entry><literal>UINT16</literal></entry>
- <entry><literal>dbus.UInt16</literal></entry>
- <entry></entry>
- </row><row>
- <entry><literal>INT32</literal></entry>
- <entry><literal>dbus.Int32</literal></entry>
- <entry>This is the default mapping for Python integers</entry>
- </row><row>
- <entry><literal>UINT32</literal></entry>
- <entry><literal>dbus.UInt32</literal></entry>
- <entry></entry>
- </row><row>
- <entry><literal>INT64</literal></entry>
- <entry><literal>dbus.Int64</literal></entry>
- <entry></entry>
- </row><row>
- <entry><literal>UINT64</literal></entry>
- <entry><literal>dbus.UInt64</literal></entry>
- <entry></entry>
- </row><row>
- <entry><literal>DOUBLE</literal></entry>
- <entry><literal>dbus.Double</literal></entry>
- <entry>Any variable assigned a floating point number will automatically be converted into a DOUBLE over the bus</entry>
- </row><row>
- <entry><literal>STRING</literal></entry>
- <entry><literal>dbus.String</literal></entry>
- <entry>Any variable assigned a quoted string will automatically be converted into a STRING over the bus</entry>
- </row><row>
- <entry><literal>OBJECT_PATH</literal></entry>
- <entry><literal>dbus.ObjectPath</literal></entry>
- <entry></entry>
- </row>
- </tbody>
- </tgroup>
- </informaltable>
- </para>
- </sect3>
- <sect3 id="python-container-typemappings">
- <title>Container type mappings</title>
- <para>
- The D-Bus type system also has a number of "container"
- types, such as <literal>DBUS_TYPE_ARRAY</literal> and
- <literal>DBUS_TYPE_STRUCT</literal>. The D-Bus type system
- is fully recursive, so one can for example have an array of
- array of strings (i.e. type signature
- <literal>aas</literal>).
- </para>
- <para>
- D-Bus container types have native corresponding built-in Python types
- so it is easy to use them.
- <informaltable>
- <tgroup cols="3">
- <thead>
- <row>
- <entry>D-Bus type</entry>
- <entry>Python type</entry>
- <entry>Python wrapper</entry>
- <entry>Notes</entry>
- </row>
- </thead>
- <tbody>
- <row>
- <entry><literal>ARRAY</literal></entry>
- <entry><literal>Python lists</literal></entry>
- <entry><literal>dbus.Array</literal></entry>
- <entry>Python lists, denoted by square brackets [], are converted into arrays and visa versa.
- The one restriction is that when sending a Python list each element of the list must be of the same
- type. This is because D-Bus arrays can contain only one element type. Use Python tuples for mixed types.
-
- When using the wrapper you may also specify a type or signature of the elements contained in the Array.
- This is manditory when passing an empty Array to a method on the bus because Python can not guess at the
- contents of an empty array. For example if a method is expecting an Array of int32's and you need to pass
- it an empty Array you would do it as such:
-
- <programlisting>emptyint32array = dbus.Array([], type=dbus.Int32)</programlisting>
-
- or
-
- <programlisting>emptyint32array = dbus.Array([], signature="i")</programlisting>
-
- Note that dbus.Array derives from list so it acts just like a python list.
- </entry>
- </row>
- <row>
- <entry><literal>STRUCT</literal></entry>
- <entry><literal>Python tuple</literal></entry>
- <entry><literal>dbus.Struct</literal></entry>
- <entry>Python tuples, denoted by parentheses (,), are converted into structs and visa versa.
- Tuples can have mixed types.</entry>
- </row>
- <row>
- <entry><literal>DICTIONARY</literal></entry>
- <entry><literal>Python dictionary</literal></entry>
- <entry><literal>dbus.Dictionary</literal></entry>
- <entry>D-Bus doesn't have an explicit dictionary type. Instead it uses LISTS of DICT_ENTRIES to
- represent a dictionary. A DICT_ENTRY is simply a two element struct containing a key/value pair.
- Python dictionaries are automatically converted to a LIST of DICT_ENTRIES and visa versa.
-
- Since dictonaries are described as lists of dict_entries we also need the signature in order
- to pass empty dictionaries. The wrapper provides a way of specifying this through the key_type/value_type
- type parameters or the signature parameters. To send an empty Dictionary where the key is a string
- and the value is a string you would do it as such:
-
- <programlisting>emptystringstringdict = dbus.Dictionary({}, key_type=dbus.String, value_type=dbus.Value)</programlisting>
-
- or
-
- <programlisting>emptystringstringdict = dbus.Dictionary({}, signature="ss")</programlisting>
-
- Note that dbus.Dictionary derives from dict so it acts just like a python dictionary.
- </entry>
- </row>
- <row>
- <entry><literal>VARIANT</literal></entry>
- <entry><literal>any type</literal></entry>
- <entry><literal>dbus.Variant</literal></entry>
- <entry>A variant is a container for any type. Python exports its methods to accept only variants
- since we are an untyped language and can demarshal into any Python type.
-
- To send a variant you must first wrap it in a<literal>dbus.Variant</literal>. If no type or signiture is
- given to the variant the marshaler will get the type from the contents.</entry>
- </row>
-
- </tbody>
- </tgroup>
- </informaltable>
- </para>
- </sect3>
- </sect2>
- <sect2 id="python-invoking-methods">
- <title>Invoking Methods</title>
- <para>Here is a D-Bus program using the Python bindings to get a listing of all names on the session bus.
-<programlisting>
-import dbus
-
-bus = dbus.SessionBus()
-proxy_obj = bus.bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
-dbus_iface = dbus.Interface(proxy_obj, 'org.freedesktop.DBus')
-
-print dbus_iface.ListNames()
-</programlisting>
- </para>
- <para>
- Notice I get an interface on the proxy object and use that to make the call. While the specifications
- state that you do not need to specify an interface if the call is unambiguous (i.e. only one method implements
- that name) due to a bug on the bus that drops messages which don't have an interface field you need to specify
- interfaces at this time. In any event it is always good practice to specify the interface of the method you
- wish to call to avoid any side effects should a method of the same name be implemented on another interface.
- </para>
- <para>
- You can specify the interface for a single call using the dbus_interface keyword.
-<programlisting>
-proxy_obj.ListNames(dbus_interface = 'org.freedesktop.DBus')
-</programlisting>
- </para>
- <para>
- This is all fine and good if all you want to do is call methods on the bus and then exit. In order to
- do more complex things such as use a GUI or make asynchronous calls you will need a mainloop. You would use
- asynchronous calls because in GUI applications it is very bad to block for any long period of time. This cause
- the GUI to seem to freeze. Since replies to D-Bus messages can take an indeterminate amount of time using async
- calls allows you to return control to the GUI while you wait for the reply. This is exceedingly easy to do in
- Python. Here is an example using the GLib/GTK+ mainloop.
-<programlisting>
-import gobject
-import dbus
-if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
- import dbus.glib
-
-def print_list_names_reply(list):
- print str(list)
-
-def print_error(e):
- print str(e)
-
-bus = dbus.SessionBus()
-proxy_obj = bus.bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
-dbus_iface = dbus.Interface(proxy_obj, 'org.freedesktop.DBus')
-
-dbus_iface.ListNames(reply_handler=print_list_names_reply, error_handler=print_error)
-
-mainloop = gobject.MainLoop()
-mainloop.run()
-</programlisting>
- </para>
- <para>
- In the above listing you will notice the reply_handler and error_handler keywords. These tell the method that
- it should be called async and to call print_list_names_reply or print_error depending if you get a reply or an error.
- The signature for replys depends on the number of arguments being sent back. Error handlers always take one parameter
- which is the error object returned.
- </para>
- <para>
- You will also notice that I check the version of the dbus bindings before importing dbus.glib. In older versions
- glib was the only available mainloop. As of version 0.41.0 we split out the glib dependency to allow for other mainloops
- to be implemented. Notice also the python binding version does not match up with the D-Bus version. Once we reach 1.0
- this should change with Python changes simply tracking the D-Bus changes.
- While the glib mainloop is the only mainloop currently implemented, integrating other mainloops should
- be very easy to do. There are plans for creating a a generic mainloop to be the default for non gui programs.
- </para>
- </sect2>
- <sect2 id="python-listening-for-signals">
- <title>Listening for Signals</title>
- <para>
- Signals are emitted by objects on the bus to notify listening programs that an event has occurred. There are a couple of ways
- to register a signal handler on the bus. One way is to attach to an already created proxy using the connect_to_signal method
- which takes a signal name and handler as arguments. Let us look at an example of connecting to the HAL service to receive
- signals when devices are added and removed and when devices register a capability. This example assumes you have HAL already running.
-<programlisting>
-import gobject
-import dbus
-if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
- import dbus.glib
-
-def device_added_callback(udi):
- print 'Device with udi %s was added' % (udi)
-
-def device_removed_callback(udi):
- print 'Device with udi %s was added' % (udi)
-
-def device_capability_callback(udi, capability):
- print 'Device with udi %s added capability %s' % (udi, capability)
-
-bus = dbus.SystemBus()
-hal_manager_obj = bus.get_object('org.freedesktop.Hal',
- '/org/freedesktop/Hal/Manager')
-hal_manager = dbus.Interface(hal_manager_obj,
- 'org.freedesktop.Hal.Manager')
-
-hal_manager.connect_to_signal('DeviceAdded', device_added_callback)
-hal_manager.connect_to_signal('DeviceRemoved', device_removed_callback)
-hal_manager.connect_to_signal('NewCapability', device_capability_callback)
-
-mainloop = gobject.MainLoop()
-mainloop.run()
-</programlisting>
- </para>
- <para>
- The drawback of using this method is that the service that you are connecting to has to be around when you register
- your signal handler. While HAL is guaranteed to be around on systems that use it this is not always the case for every
- service on the bus. Say our program started up before HAL, we could connect to the signal by adding a signal receiver
- directly to the bus.
-<programlisting>
-bus.add_signal_receiver(device_added_callback,
- 'DeviceAdded',
- 'org.freedesktop.Hal.Manager',
- 'org.freedesktop.Hal',
- '/org/freedesktop/Hal/Manager')
-
-bus.add_signal_receiver(device_removed_callback,
- 'DeviceRemoved',
- 'org.freedesktop.Hal.Manager',
- 'org.freedesktop.Hal',
- '/org/freedesktop/Hal/Manager')
-
-bus.add_signal_receiver(device_capability_callback,
- 'DeviceAdded',
- 'org.freedesktop.Hal.Manager',
- 'org.freedesktop.Hal',
- '/org/freedesktop/Hal/Manager')
-</programlisting>
- </para>
- <para>
- All this can be done without creating the proxy object if one wanted to but in most cases you would want to have
- a reference to the object so once a signal was received operations could be executed on the object.
- </para>
- <sidebar>
- <title>Signal matching on arguments</title>
- <para>
- Starting with D-Bus 0.36 and the (0, 43, 0) version of the python
- bindings you can now add a match on arguments being sent in a signal.
- This is useful for instance for only getting NameOwnerChanged
- signals for your service. Lets say we create a name on the bus called
- 'org.foo.MyName' we could also add a match to just get
- NameOwnerChanges for that name as such:
-<programlisting>
-bus.add_signal_receiver(myname_changed,
- 'NameOwnerChanged',
- 'org.freedesktop.DBus',
- 'org.freedesktop.DBus',
- '/org/freedesktop/DBus',
- arg0='org.foo.MyName')
-</programlisting>
-
- It is as simple as that. To match the second arg you would use arg1=,
- the third arg2=, etc.
- </para>
- </sidebar>
- <sidebar>
- <title>Cost of Creating a Proxy Object</title>
- <para>
- Note that creating proxy objects can have an associated processing cost. When introspection is implemented
- a proxy may wait for introspection data before processing any requests. It is generally good practice to
- create proxies once and reuse the proxy when calling into the object. Constantly creating the same proxy
- over and over again can become a bottleneck for your program.
- </para>
- </sidebar>
- <para>
- TODO: example of getting information about devices from HAL
- </para>
- </sect2>
- </sect1>
-
- <sect1 id="python-server">
- <title>Python API: Implementing Objects</title>
- <para>
- Implementing object on the bus is just as easy as invoking methods or listening for signals on the bus.
- </para>
- <sidebar>
- <title>Version Alert</title>
- <para>
- The Python D-Bus bindings require version 2.4 or greater of Python when creating D-Bus objects.
- </para>
- </sidebar>
-
- <sect2 id="python-inheriting-from-dbus-object">
- <title>Inheriting From dbus.service.Object</title>
- <para>
- In order to export a Python object over the bus one must first get a bus name and then create
- a Python object that inherits from dbus.service.Object. The following is the start of an example
- HelloWorld object that we want to export over the session bus.
-<programlisting>
-import gobject
-import dbus
-import dbus.service
-if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
- import dbus.glib
-
-class HelloWorldObject(dbus.service.Object):
- def __init__(self, bus_name, object_path='/org/freedesktop/HelloWorldObject'):
- dbus.service.Object.__init__(self, bus_name, object_path)
-
-session_bus = dbus.SessionBus()
-bus_name = dbus.service.BusName('org.freedesktop.HelloWorld', bus=session_bus)
-object = HelloWorldObject(bus_name)
-
-mainloop = gobject.MainLoop()
-mainloop.run()
-</programlisting>
- </para>
- <para>
- Here we got the session bus, then created a BusName object which requests a name on the bus.
- We pass that bus name to the HelloWorldObject object which inherits from dbus.service.Object.
- We now have an object on the bus but it is pretty useless.
- </para>
- </sect2>
- <sect2 id="python-exporting-methods">
- <title>Exporting Methods Over The Bus</title>
- <para>
- Let's make this object do something and export a method over the bus.
-<programlisting>
-import gobject
-import dbus
-import dbus.service
-if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
- import dbus.glib
-
-class HelloWorldObject(dbus.service.Object):
- def __init__(self, bus_name, object_path='/org/freedesktop/HelloWorldObject'):
- dbus.service.Object.__init__(self, bus_name, object_path)
-
- @dbus.service.method('org.freedesktop.HelloWorldIFace')
- def hello(self):
- return 'Hello from the HelloWorldObject'
-
-session_bus = dbus.SessionBus()
-bus_name = dbus.service.BusName('org.freedesktop.HelloWorld', bus=session_bus)
-object = HelloWorldObject(bus_name)
-
-mainloop = gobject.MainLoop()
-mainloop.run()
-</programlisting>
- </para>
- <sidebar>
- <title>Python Decorators</title>
- <para>
- Notice the @ symbol on the line before the hello method. This is a new directive introduced in
- Python 2.4. It is called a decorator and it "decorates" methods. All you have to know is that
- it provides metadata that can then be used to alter the behavior of the method being decorated.
- In this case we are telling the bindings that the hello method should be exported as a D-Bus method
- over the bus.
- </para>
- </sidebar>
- <para>
- As you can see we exported the hello method as part of the org.freedesktop.HelloWorldIFace interface.
- It takes no arguments and returns a string to the calling program. Let's create a proxy and invoke this
- method.
-<programlisting>
-import dbus
-
-bus = dbus.SessionBus()
-proxy_obj = bus.bus.get_object('org.freedesktop.HelloWorld', '/org/freedesktop/HelloWorldObject')
-iface = dbus.Interface(proxy_obj, 'org.freedesktop.HelloWorldIFace')
-
-print iface.hello()
-</programlisting>
- </para>
- <para>
- When invoking methods exported over the bus the bindings automatically know how many parameters
- the method exports. You can even make a method that exports an arbitrary number of parameters.
- Also, whatever you return will automatically be transfered as a reply over the bus. Some examples.
-<programlisting>
- @dbus.service.method('org.freedesktop.HelloWorldIFace')
- def one_arg(self, first_arg):
- return 'I got arg %s' % first_arg
-
- @dbus.service.method('org.freedesktop.HelloWorldIFace')
- def two_args(self, first_arg, second_arg):
- return ('I got 2 args', first_arg, second_arg)
-
- @dbus.service.method('org.freedesktop.HelloWorldIFace')
- def return_list(self):
- return [1, 2, 3, 4, 5, 6]
-
- @dbus.service.method('org.freedesktop.HelloWorldIFace')
- def return_dict(self):
- return {one: '1ne', two: '2wo', three: '3ree'}
-</programlisting>
- </para>
- </sect2>
- <sect2 id="python-emitting-signals">
- <title>Emitting Signals</title>
- <para>
- Setting up signals to emit is just as easy as exporting methods. It uses the same syntax as methods.
-<programlisting>
-import gobject
-import dbus
-import dbus.service
-if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
- import dbus.glib
-
-class HelloWorldObject(dbus.service.Object):
- def __init__(self, bus_name, object_path='/org/freedesktop/HelloWorldObject'):
- dbus.service.Object.__init__(self, bus_name, object_path)
-
- @dbus.service.method('org.freedesktop.HelloWorldIFace')
- def hello(self):
- return 'Hello from the HelloWorldObject'
-
- @dbus.service.signal('org.freedesktop.HelloWorldIFace')
- def hello_signal(self, message):
- pass
-
-session_bus = dbus.SessionBus()
-bus_name = dbus.service.BusName('org.freedesktop.HelloWorld', bus=session_bus)
-object = HelloWorldObject(bus_name)
-
-object.hello_signal('I sent a hello signal')
-
-mainloop = gobject.MainLoop()
-mainloop.run()
-</programlisting>
- </para>
- <para>
- Adding a @dbus.service.signal decorator to a method turns it into a signal emitter. You can put code
- in this method to do things like keep track of how many times you call the emitter or to print out debug
- messages but for the most part a pass noop will do. Whenever you call the emitter a signal will be emitted
- with the parameters you passed in as arguments. In the above example we send the message 'I sent a hello signal'
- with the signal.
- </para>
- </sect2>
- <sect2 id="python-inheriting-and-overriding">
- <title>Inheriting from HelloWorldObject</title>
- <para>
- One of the cool things you can do in Python is inherit from another D-Bus object. We use this trick in
- the bindings to provide a default implementation for the org.freedesktop.DBus.Introspectable interface.
- Let's inherit from the HelloWorldObject example above and overide the hello method to say goodbye.
-<programlisting>
-class HelloWorldGoodbyeObject(HelloWorldObject):
- def __init__(self, bus_name, object_path='/org/freedesktop/HelloWorldGoodbyeObject'):
- HelloWorldObject.__init__(self, bus_name, object_path)
-
- @dbus.service.method('org.freedesktop.HelloWorldGoodbyeIFace')
- def hello(self):
- return 'Goodbye'
-
-goodbye_object = HelloWorldGoodbyeObject(bus_name)
-</programlisting>
- </para>
- <para>
- Let's now call both methods with a little help from interfaces.
-<programlisting>
-import dbus
-
-bus = dbus.SessionBus()
-proxy_obj = bus.bus.get_object('org.freedesktop.HelloWorld', '/org/freedesktop/HelloWorldGoodbyeObject')
-
-print proxy_obj.hello(dbus_interface='org.freedesktop.HelloWorldIFace')
-print proxy_obj.hello(dbus_interface='org.freedesktop.HelloWorldGoodbyeIFace')
-</programlisting>
- </para>
- <para>
- This should print out 'Hello from the HelloWorldObject' followed by a 'Goodbye'.
- </para>
- </sect2>
- <sect2 id="python-conclusion">
- <title>Conclusion</title>
- <para>
- As you can see, using D-Bus from Python is an extremely easy proposition. Hopefully
- the tutorial has been helpful in getting you started. If you need anymore help please
- feel free to post on the <ulink url="http://lists.freedesktop.org/mailman/listinfo/dbus/">mailing list</ulink>.
- The Python bindings are still in a state of flux and there may be API changes in the future.
- This tutorial will be updated if such changes occur.
- </para>
- </sect2>
</sect1>
<sect1 id="qt-client">
projects / platform / upstream / dbus.git / blobdiff