This outline is also available in PDF.
Held: Thursday, 28 February 2013
Summary:
We continue our exploration of D-Bus by considering the typical
form of a D-Bus server written using the GDBus library.
Related Pages:
Notes:
- No class next week. I'll be off at SIGCSE.
- I may use the whiteboard board more today than normal. Sorry.
- We won't go over your homework.
- Today's code can be found in
Examples/DBus/Server.
- We're working a bit with
GVariants today. You may find it useful to read the documentation at http://developer.gnome.org/glib/2.28/glib-GVariant.html.
- Homework, part 1: Take one of the sample servers and add a few useful methods (E.g., to multiply two numbers).
- Homework, part 2: (Will be sent next week. Will involve looking at sample client code.)
Overview:
- Basic issues
- Preparation
- The
main function
- When the bus is acquired
- Detour: GVariants
- Handling events
- Adding selected capabilities
- So, you want to write a D-Bus server, what are things you need to know?
- More precisely, you want to write a D-Bus server using the glib and gio
libraries. What are the things you have to do.
- As you may recall, D-Bus has an object-oriented model
- Each service must register a name on the bus
- Each service must have one or more objects that provide the services.
- So, the first thing is register your name
- And the second thing is publish objects
- Of course, publishing objects needs a lot of substeps. So, what do we
need to do
- We need to describe the interfaces the object supports
- We need to publish those interface on the D-Bus
- Once we've published an object, we need to be able to respond to
requests. That's typically done using an event loop.
(Conveniently, glib/gio provide the event loop, along with a callback
system that ensures that certain functions get called when requests
arrive).
- We'll have handlers for
- Method calls (
handle_method_call)
- Getting a property (
handle_get_property)
- Setting a property (
handle_set_property)
- Because glib often does things asynchronously, we'll also have handlers
for
- Successful acquistion of the bus (
on_bus_acquired)
- Successful acquisition of the name on the bus (
on_name_acquired)
- Loss of a name (for whatever reason) (
on_name_lost)
- Set up glib
- Build an internal representation of the interfaces
- Request the name on the bus (
g_bus_own_name)
- Callbacks indicate when the bus and name have been acquired
- Start the loop
- Clean up
- Register objects.
- Perhaps do other things (e.g., set up events to happen later).
- We're about to write the various handlers.
- How can we write handlers that will deal with different types of values?
(After all, different properties may have different types.)
- The gio solution: have one generic type (
GVariant) and
provide methods for packing data into that type and extracting data
from that type.
- To create a new
GVariant use
g_variant_new(type-abbrev, values)
or g_variant_new_xxx(value)
- To extract a value from
GVariant use
g_variant_get(type-abbrev, locations)
or g_variant_get_xxx(value)
- A method that returns a value. [v1]
- A property (readable and writable), but not implemented. [v2]
- A property (readable and writable). [v3]
- User data.
- ...
;
