dbus 0.1.5

data/examples/example-client.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'dbus'
+
+bus = DBus::SessionBus.new
+remote_service = bus.get_service("org.designfu.SampleService")
+remote_object = remote_service.get_object("/SomeObject",
+                                          "org.designfu.SampleInterface")
+
+hello_reply_list = remote_object.HelloWorld("Hello from example-client.rb!")
+p hello_reply_list

data/examples/example-service.rb

@@ -0,0 +1,19 @@
+require 'dbus'
+require 'gtk2'
+
+class SomeObject < DBus::Object
+    def initialize(service)
+        super("/SomeObject", service, [:HelloWorld])
+    end
+
+    def HelloWorld(message, hello_message)
+        puts hello_message
+        return ["Hello", "from example-service.rb"]
+    end
+end
+
+session_bus = DBus::SessionBus.new
+service = DBus::Service.new("org.designfu.SampleService", session_bus)
+object = SomeObject.new(service)
+
+Gtk.main

data/examples/example-signal-emitter.rb

@@ -0,0 +1,18 @@
+require 'dbus'
+require 'gtk2'
+
+class TestObject < DBus::Object
+  def initialize(service)
+    super("/object", service, [:EmitHelloSignal])
+  end
+
+  def EmitHelloSignal(message)
+    emit_signal("org.designfu.TestService", "hello")
+  end
+end
+
+session_bus = DBus::SessionBus.new
+service = DBus::Service.new("org.designfu.TestService", session_bus)
+object = TestObject.new(service)
+
+Gtk.main

data/examples/example-signal-recipient.rb

@@ -0,0 +1,17 @@
+require 'dbus'
+require 'gtk2'
+
+bus = DBus::SessionBus.new
+service = bus.get_service("org.designfu.TestService")
+object  = service.get_object("/object", "org.designfu.TestService")
+
+def hello_signal_handler(interface, signal_name, service, path, message)
+  puts "Received signal '%s.%s' from object '%s%s'" % [interface, signal_name, service, path]
+end
+
+object.connect_to_signal("hello", method(:hello_signal_handler))
+
+# Tell the remote object to emit the signal
+object.EmitHelloSignal()
+
+Gtk.main

data/examples/gconf-proxy-client.rb

@@ -0,0 +1,11 @@
+require 'dbus'
+
+gconf_key = "/desktop/gnome/file_views/icon_theme"
+
+bus = DBus::SessionBus.new
+gconf_service = bus.get_service("org.gnome.GConf")
+gconf_key_object = gconf_service.get_object("/org/gnome/GConf" + gconf_key, "org.gnome.GConf")
+
+value = gconf_key_object.getString()
+
+puts "Value of GConf key %s is %s" % [gconf_key, value]

data/examples/gconf-proxy-service.rb

@@ -0,0 +1,39 @@
+require 'dbus'
+require 'gtk2'
+require 'gconf2'
+
+class GConfService < DBus::Service
+  def initialize
+    super("org.gnome.GConf", DBus::SessionBus.new)
+    gconf_object_tree = GConfObjectTree.new(self)
+  end
+    
+  class GConfObjectTree < DBus::ObjectTree
+    def initialize(service)
+      super("/org/gnome/GConf", service, dbus_methods=[:getString, :setString, :getInt, :setInt])
+      @client = GConf::Client.default
+    end
+
+    def get(message, object_path)
+      puts "get called for GConf key %s" % object_path
+      @client[object_path]
+    end
+
+    def set(message, object_path, new_value)
+      puts "set called for GConf key %s" % object_path
+      @client[object_path] = new_value
+    end
+
+    alias :getString :get
+    alias :setString :set
+    alias :getInt :get
+    alias :setInt :set
+  end
+end
+        
+gconf_service = GConfService.new
+
+puts "GConf Proxy service started."
+puts "Run 'gconf-proxy-client.rb' to fetch a GConf key through the proxy..."
+
+Gtk.main

data/examples/list-session-services.rb

@@ -0,0 +1,26 @@
+# List services on the system bus
+
+require 'dbus'
+
+# Get a connection to the SESSION bus
+bus = DBus::SessionBus.new
+
+# Get the service provided by the dbus-daemon named org.freedesktop.DBus
+dbus_service = bus.get_service('org.freedesktop.DBus')
+
+# Get a reference to the desktop bus' standard object, denoted
+# by the path /org/freedesktop/DBus. The object /org/freedesktop/DBus
+# implements the 'org.freedesktop.DBus' interface
+dbus_object = dbus_service.get_object('/org/freedesktop/DBus',
+                                      'org.freedesktop.DBus')
+            
+# One of the member functions in the org.freedesktop.DBus interface
+# is ListServices(), which provides a list of all the other services
+# registered on this bus. Call it, and print the list.
+system_service_list = dbus_object.ListServices
+
+for service in system_service_list
+  if service[0,1] != ':'
+    puts service
+  end
+end

data/examples/list-system-services.rb

@@ -0,0 +1,26 @@
+# List services on the system bus
+
+require 'dbus'
+
+# Get a connection to the SYSTEM bus
+bus = DBus::SystemBus.new
+
+# Get the service provided by the dbus-daemon named org.freedesktop.DBus
+dbus_service = bus.get_service('org.freedesktop.DBus')
+
+# Get a reference to the desktop bus' standard object, denoted
+# by the path /org/freedesktop/DBus. The object /org/freedesktop/DBus
+# implements the 'org.freedesktop.DBus' interface
+dbus_object = dbus_service.get_object('/org/freedesktop/DBus',
+                                      'org.freedesktop.DBus')
+            
+# One of the member functions in the org.freedesktop.DBus interface
+# is ListServices(), which provides a list of all the other services
+# registered on this bus. Call it, and print the list.
+system_service_list = dbus_object.ListServices
+
+for service in system_service_list
+  if service[0,1] != ':'
+    puts service
+  end
+end

data/examples/volumed.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/ruby
+
+# Volume Manager example ported from HAL
+
+require 'dbus'
+require 'gtk2'
+
+# This just watches the CD-ROM volumes on the system, and prints messages when
+# they are added or removed (tray opened/closed). At startup, it adds all the
+# existing ones.
+#
+# This requires udev with D-BUS enabled and HAL to work correctly
+#
+
+class HalDevice
+  attr :service
+  attr :udi
+  attr :object
+
+  def initialize(service, udi_or_object, properties={})
+    @service = service
+    if !udi_or_object.is_a?(String)
+      @udi = properties['info.udi']
+      @object = udi_or_object
+      @properties = properties
+    else
+      @udi = udi_or_object
+      @object = @service.get_object(udi_or_object, 'org.freedesktop.Hal.Device')
+      @properties = @object.GetAllProperties()
+    end
+  end
+
+  def [](name)
+    @properties[name]
+  end
+end
+
+class StorageDevice < HalDevice
+  def drive_type
+    self['storage.drive_type']
+  end
+
+  def device_node
+    self['block.device']
+  end
+
+  def to_s
+    "#<StorageDevice drive_type=\"#{self.drive_type}\" device_node=\"#{self.device_node}\">"
+  end
+end
+
+class Volume < HalDevice
+  attr :storage
+
+  def initialize(service, udi_or_object, properties={}, storage=nil)
+    super(service, udi_or_object, properties)
+    @storage = storage.nil?? StorageDevice.new(@service, self['block.storage_device']) : storage
+  end
+
+  def label
+    self['volume.label']
+  end
+
+  def mount_point
+    self['volume.mount_point']
+  end
+
+  def to_s
+    "#<Volume mount_point=\"#{self.mount_point}\" storage=#{@storage}>"
+  end
+end
+
+class CDRomVolume < Volume
+  def has_data?
+    if self['volume.disc.has_data'] == 1
+      return true
+    else
+      return false
+    end
+  end
+
+  def has_audio?
+    if self['volume.disc.has_audio'] == 1
+      return true
+    else
+      return false
+    end
+  end
+
+  def to_s
+    "#<CDRomVolume label=\"#{self.label}\" mount_point=\"#{self.mount_point}\" storage=#{self.storage}>"
+  end
+end
+
+class VolumeManager
+  def initialize
+    @bus = DBus::SystemBus.new
+    @hal_service = @bus.get_service('org.freedesktop.Hal')
+    @hal_manager = @hal_service.get_object('/org/freedesktop/Hal/Manager',
+                                           'org.freedesktop.Hal.Manager')
+    connect_gdl_signal(method(:on_gdl_device_added), 'DeviceAdded')
+    connect_gdl_signal(method(:on_gdl_device_removed), 'DeviceRemoved')
+    @volumes = {}
+    device_names = @hal_manager.GetAllDevices()
+    device_names.each{|d| add_device(d)}
+  end
+
+  def add_device(udi)
+    volume_obj = @hal_service.get_object(udi, 'org.freedesktop.Hal.Device')
+    volume_prop = volume_obj.GetAllProperties()
+    # this causes hald to segfault (!!)
+    # return nil unless volume_obj.QueryCapability('volume')
+    return nil unless volume_prop['info.category'] == 'volume'
+    storage_device = StorageDevice.new(@hal_service, volume_prop['block.storage_device'])
+    return nil unless storage_device.drive_type == 'cdrom'
+    volume = CDRomVolume.new(@hal_service, volume_obj, volume_prop, storage_device)
+    @volumes[volume.udi] = volume
+    puts "Add Volume: #{volume}"
+  end
+
+  def remove_device(udi)
+    return nil unless @volumes.has_key?(udi)
+    volume = @volumes.delete(udi)
+    puts "Remove Volume: #{volume}"
+  end
+
+  def connect_gdl_signal(handler_proc, member)
+    @bus.add_signal_receiver(handler_proc,
+                             member,                         # member
+                             'org.freedesktop.Hal.Manager',  # interface
+                             'org.freedesktop.Hal',          # service
+                             '/org/freedesktop/Hal/Manager') # path
+  end
+
+  def on_gdl_device_added(dbus_if, member, svc, obj_path, message)
+    add_device(message.get_iter.value)
+  end
+
+  def on_gdl_device_removed(dbus_if, member, svc, obj_path, message)
+    remove_device(message.get_iter.value)
+  end
+
+  def run
+    Gtk.main
+  end
+end
+
+if __FILE__ == $0
+  manager = VolumeManager.new
+  manager.run
+end

data/ext/extconf.rb

@@ -0,0 +1,19 @@
+begin
+  require 'mkmf-gnome2'
+rescue
+  $stderr.puts "ERROR: you do not have the Ruby Glib2 bindings installed"
+  exit 1
+end
+
+PKGConfig.have_package('dbus-1')
+PKGConfig.have_package('dbus-glib-1')
+PKGConfig.have_package('glib-2.0')
+
+%w[dbus_connection_setup_with_g_main dbus_server_setup_with_g_main dbus_bus_get].each do |f|
+  unless have_func(f)
+    $stderr.puts "\nERROR: missing function #{f}, aborting."
+    exit 1
+  end
+end
+
+create_makefile('dbus')

data/ext/ruby-dbus-bus.c

@@ -0,0 +1,145 @@
+/*--------------------------------------------------
+ * D-BUS bindings for Ruby
+ * (C) Copyright 2004 Leon Breedt
+ * (C) Copyright 2004 Provenco Group Ltd
+ *
+ * Licensed under the same terms as the D-BUS library
+ *--------------------------------------------------*/
+
+#include "ruby-dbus.h"
+
+/*
+ *  call-seq:
+ *      bus_get(type=BUS_SESSION) => connection
+ *  
+ *  Connects to a D-BUS daemon and registers the client with it.
+ *  Existing bus connections are re-used.
+ */
+static VALUE
+mDBusBinding_bus_get(int argc, VALUE *argv)
+{
+  VALUE type;
+  DBusConnection *conn;
+  DBusBusType bus_type;
+
+  type = Qnil;
+  bus_type = DBUS_BUS_SESSION;
+  rb_scan_args(argc, argv, "01", &type);
+  if (type != Qnil)
+    bus_type = (DBusBusType)NUM2INT(type);
+  switch (bus_type) {
+    case DBUS_BUS_SESSION:
+    case DBUS_BUS_SYSTEM:
+    case DBUS_BUS_ACTIVATION:
+      /* fall-through */
+      break;
+    default:
+      rb_raise(eDBusError, "unsupported D-BUS bus type %d", bus_type);
+  }
+
+  conn = NULL;
+  RDBUS_TRY(conn = dbus_bus_get(bus_type, &error));
+  RDBUS_RAISE_IF(conn == NULL, "failed to open D-BUS connection");
+  return RDBUS_NEW(cDBusConnection, conn);
+}
+
+/*
+ *  call-seq:
+ *      bus_acquire_service(connection, service_name, [flags=0]) => retcode
+ *
+ *  Asks the bus connected to the given connection to acquire a service. This
+ *  can be useful for ensuring only one instance of your program is running.
+ */
+static VALUE
+mDBusBinding_bus_acquire_service(int argc, VALUE *argv)
+{
+  VALUE conn;
+  VALUE name;
+  VALUE flags; int service_flags;
+  int ret;
+
+  conn = name = flags = Qnil;
+  service_flags = 0;
+  rb_scan_args(argc, argv, "21", &conn, &name, &flags);
+  if (flags != Qnil)
+    service_flags = NUM2INT(flags);
+  ret = 0;
+  RDBUS_TRY(
+    ret = dbus_bus_acquire_service(CONN_GET(conn),
+                                   StringValuePtr(name),
+                                   service_flags,
+                                   &error)
+  );
+  return INT2FIX(ret);
+}
+
+/*
+ *  call-seq:
+ *      bus_service_exists(connection, service_name) => true | false
+ *
+ *  Checks whether the given service exists on the bus, +true+ is returned
+ *  if it does, +false+ otherwise.
+ */
+static VALUE
+mDBusBinding_bus_service_exists(VALUE klass, VALUE conn, VALUE name)
+{
+  dbus_bool_t ret;
+
+  ret = FALSE;
+  RDBUS_TRY(
+    ret = dbus_bus_service_exists(CONN_GET(conn), StringValuePtr(name),
+                                  &error)
+  );
+  if (ret)
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      bus_add_match(connection, rule) => nil
+ *  
+ *  Adds a match rule on the given connection to match messages passing
+ *  through the bus. A match rule is a string with <tt>key=value</tt> pairs
+ *  seperated by commas.
+ *
+ *  Match keys:
+ *  [+type+]        matches the message type, which can be one of +method_call+,
+ *                  +method_return+, +signal+ or +error+
+ *  [+interface+]   matches the interface field of a message
+ *  [+member+]      matches the member field of a message
+ *  [+path+]        matches the path field of a message
+ *  [+destination+] matches the destination (recipient) of a message
+ *
+ *  In order to receive the messages matching rules added by this method, you
+ *  will need to install a message filter on the connection using
+ *  DBusConnection#add_filter
+ */
+static VALUE
+mDBusBinding_bus_add_match(VALUE klass, VALUE conn, VALUE rule)
+{
+  RDBUS_TRY(dbus_bus_add_match(CONN_GET(conn), StringValuePtr(rule), &error));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      bus_remove_match(connection, rule) => nil
+ *
+ *  Removes a match rule previously added with DBus::Binding#bus_add_match
+ */
+static VALUE
+mDBusBinding_bus_remove_match(VALUE klass, VALUE conn, VALUE rule)
+{
+  RDBUS_TRY(dbus_bus_remove_match(CONN_GET(conn), StringValuePtr(rule), &error));
+  return Qnil;
+}
+
+void Init_dbus_bus()
+{
+  rb_define_module_function(mDBusBinding, "bus_get", mDBusBinding_bus_get, -1);
+  rb_define_module_function(mDBusBinding, "bus_acquire_service", mDBusBinding_bus_acquire_service, -1);
+  rb_define_module_function(mDBusBinding, "bus_service_exists", mDBusBinding_bus_service_exists, 2);
+  rb_define_module_function(mDBusBinding, "bus_add_match", mDBusBinding_bus_add_match, 2);
+  rb_define_module_function(mDBusBinding, "bus_remove_match", mDBusBinding_bus_remove_match, 2);
+}