em-ruby-dbus 0.11.0

data/lib/dbus/proxy_object.rb

@@ -0,0 +1,149 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+module DBus
+  # D-Bus proxy object class
+  #
+  # Class representing a remote object in an external application.
+  # Typically, calling a method on an instance of a ProxyObject sends a message
+  # over the bus so that the method is executed remotely on the correctponding
+  # object.
+  class ProxyObject
+    # The names of direct subnodes of the object in the tree.
+    attr_accessor :subnodes
+    # Flag determining whether the object has been introspected.
+    attr_accessor :introspected
+    # The (remote) destination of the object.
+    attr_reader :destination
+    # The path to the object.
+    attr_reader :path
+    # The bus the object is reachable via.
+    attr_reader :bus
+    # @return [String] The name of the default interface of the object.
+    attr_accessor :default_iface
+
+    # Creates a new proxy object living on the given _bus_ at destination _dest_
+    # on the given _path_.
+    def initialize(bus, dest, path)
+      @bus, @destination, @path = bus, dest, path
+      @interfaces = Hash.new
+      @subnodes = Array.new
+    end
+
+    # Returns the interfaces of the object.
+    def interfaces
+      @interfaces.keys
+    end
+
+    # Retrieves an interface of the proxy object
+    # @param [String] intfname
+    # @return [ProxyObjectInterface]
+    def [](intfname)
+      @interfaces[intfname]
+    end
+
+    # Maps the given interface name _intfname_ to the given interface _intf.
+    # @param [String] intfname
+    # @param [ProxyObjectInterface] intf
+    # @return [ProxyObjectInterface]
+    def []=(intfname, intf)
+      @interfaces[intfname] = intf
+    end
+
+    # Introspects the remote object. Allows you to find and select
+    # interfaces on the object.
+    def introspect
+      # Synchronous call here.
+      xml = @bus.introspect_data(@destination, @path)
+      ProxyObjectFactory.introspect_into(self, xml)
+      define_shortcut_methods()
+      xml
+    end
+
+    # For each non duplicated method name in any interface present on the
+    # caller, defines a shortcut method dynamically.
+    # This function is automatically called when a {ProxyObject} is
+    # introspected.
+    def define_shortcut_methods
+      # builds a list of duplicated methods
+      dup_meths, univocal_meths = [],{}
+      @interfaces.each_value do |intf|
+        intf.methods.each_value do |meth|
+          name = meth.name.to_sym
+          # don't overwrite instance methods!
+          if dup_meths.include? name or self.class.instance_methods.include? name
+            next
+          elsif univocal_meths.include? name
+            univocal_meths.delete name
+            dup_meths << name
+          else
+            univocal_meths[name] = intf
+          end
+        end
+      end
+      univocal_meths.each do |name, intf|
+        # creates a shortcut function that forwards each call to the method on
+        # the appropriate intf
+        singleton_class.class_eval do
+          define_method name do |*args, &reply_handler|
+            intf.method(name).call(*args, &reply_handler)
+          end
+        end
+      end
+    end
+
+    # Returns whether the object has an interface with the given _name_.
+    def has_iface?(name)
+      raise "Cannot call has_iface? if not introspected" if not @introspected
+      @interfaces.member?(name)
+    end
+
+    # Registers a handler, the code block, for a signal with the given _name_.
+    # It uses _default_iface_ which must have been set.
+    # @return [void]
+    def on_signal(name, &block)
+      if @default_iface and has_iface?(@default_iface)
+        @interfaces[@default_iface].on_signal(name, &block)
+      else
+        # TODO improve
+        raise NoMethodError
+      end
+    end
+
+    ####################################################
+    private
+
+    # Handles all unkown methods, mostly to route method calls to the
+    # default interface.
+    def method_missing(name, *args, &reply_handler)
+      if @default_iface and has_iface?(@default_iface)
+        begin
+          @interfaces[@default_iface].method(name).call(*args, &reply_handler)
+        rescue NameError => e
+          # interesting, foo.method("unknown")
+          # raises NameError, not NoMethodError
+          raise unless e.to_s =~ /undefined method `#{name}'/
+          # BTW e.exception("...") would preserve the class.
+          raise NoMethodError,"undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
+        end
+      else
+        # TODO distinguish:
+        # - di not specified
+        #TODO
+        # - di is specified but not found in introspection data
+        raise NoMethodError, "undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
+      end
+    end
+
+    # Returns the singleton class of the object.
+    def singleton_class
+      (class << self ; self ; end)
+    end
+  end # class ProxyObject
+end

data/lib/dbus/proxy_object_factory.rb

@@ -0,0 +1,41 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+module DBus
+  # = D-Bus proxy object factory class
+  #
+  # Class that generates and sets up a proxy object based on introspection data.
+  class ProxyObjectFactory
+    # Creates a new proxy object factory for the given introspection XML _xml_,
+    # _bus_, destination _dest_, and _path_.
+    def initialize(xml, bus, dest, path)
+      @xml, @bus, @path, @dest = xml, bus, path, dest
+    end
+
+    # Investigates the sub-nodes of the proxy object _po_ based on the
+    # introspection XML data _xml_ and sets them up recursively.
+    def ProxyObjectFactory.introspect_into(po, xml)
+      intfs, po.subnodes = IntrospectXMLParser.new(xml).parse
+      intfs.each do |i|
+        poi = ProxyObjectInterface.new(po, i.name)
+        i.methods.each_value { |m| poi.define(m) }
+        i.signals.each_value { |s| poi.define(s) }
+        po[i.name] = poi
+      end
+      po.introspected = true
+    end
+
+    # Generates, sets up and returns the proxy object.
+    def build
+      po = ProxyObject.new(@bus, @dest, @path)
+      ProxyObjectFactory.introspect_into(po, @xml)
+      po
+    end
+  end # class ProxyObjectFactory
+end

data/lib/dbus/proxy_object_interface.rb

@@ -0,0 +1,128 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+module DBus
+  # = D-Bus proxy object interface class
+  #
+  # A class similar to the normal Interface used as a proxy for remote
+  # object interfaces.
+  class ProxyObjectInterface
+    # The proxied methods contained in the interface.
+    attr_accessor :methods
+    # The proxied signals contained in the interface.
+    attr_accessor :signals
+    # The proxy object to which this interface belongs.
+    attr_reader :object
+    # The name of the interface.
+    attr_reader :name
+
+    # Creates a new proxy interface for the given proxy _object_
+    # and the given _name_.
+    def initialize(object, name)
+      @object, @name = object, name
+      @methods, @signals = Hash.new, Hash.new
+    end
+
+    # Returns the string representation of the interface (the name).
+    def to_str
+      @name
+    end
+
+    # Returns the singleton class of the interface.
+    def singleton_class
+      (class << self ; self ; end)
+    end
+
+    # Defines a method on the interface from the Method descriptor _m_.
+    def define_method_from_descriptor(m)
+      m.params.each do |fpar|
+        par = fpar.type
+        # This is the signature validity check
+        Type::Parser.new(par).parse
+      end
+
+      singleton_class.class_eval do
+        define_method m.name do |*args, &reply_handler|
+          if m.params.size != args.size
+            raise ArgumentError, "wrong number of arguments (#{args.size} for #{m.params.size})"
+          end
+
+          msg = Message.new(Message::METHOD_CALL)
+          msg.path = @object.path
+          msg.interface = @name
+          msg.destination = @object.destination
+          msg.member = m.name
+          msg.sender = @object.bus.unique_name
+          m.params.each do |fpar|
+            par = fpar.type
+            msg.add_param(par, args.shift)
+          end
+          @object.bus.send_sync_or_async(msg, &reply_handler)
+        end
+      end
+
+      @methods[m.name] = m
+    end
+
+    # Defines a signal from the descriptor _s_.
+    def define_signal_from_descriptor(s)
+      @signals[s.name] = s
+    end
+
+    # Defines a signal or method based on the descriptor _m_.
+    def define(m)
+      if m.kind_of?(Method)
+        define_method_from_descriptor(m)
+      elsif m.kind_of?(Signal)
+        define_signal_from_descriptor(m)
+      end
+    end
+
+    # Defines a proxied method on the interface.
+    def define_method(methodname, prototype)
+      m = Method.new(methodname)
+      m.from_prototype(prototype)
+      define(m)
+    end
+
+    # @overload on_signal(name, &block)
+    # @overload on_signal(bus, name, &block)
+    # Registers a handler (code block) for a signal with _name_ arriving
+    # over the given _bus_. If no block is given, the signal is unregistered.
+    # Note that specifying _bus_ is discouraged and the option is kept only for
+    # backward compatibility.
+    # @return [void]
+    def on_signal(bus = @object.bus, name, &block)
+      mr = DBus::MatchRule.new.from_signal(self, name)
+      if block.nil?
+        bus.remove_match(mr)
+      else
+        bus.add_match(mr) { |msg| block.call(*msg.params) }
+      end
+    end
+
+    PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
+
+    # Read a property.
+    def [](propname)
+      self.object[PROPERTY_INTERFACE].Get(self.name, propname)[0]
+    end
+
+    # Write a property.
+    def []=(propname, value)
+      self.object[PROPERTY_INTERFACE].Set(self.name, propname, value)
+    end
+
+    # Read all properties at once, as a hash.
+    # @return [Hash{String}]
+    def all_properties
+      self.object[PROPERTY_INTERFACE].GetAll(self.name)[0]
+    end
+  end # class ProxyObjectInterface
+end

data/lib/dbus/type.rb

@@ -0,0 +1,193 @@
+# dbus/type.rb - module containing low-level D-Bus data type information
+#
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+module DBus
+
+# = D-Bus type module
+#
+# This module containts the constants of the types specified in the D-Bus
+# protocol.
+module Type
+  # Mapping from type number to name and alignment.
+  TypeMapping = {
+    0 => ["INVALID", nil],
+    ?y => ["BYTE", 1],
+    ?b => ["BOOLEAN", 4],
+    ?n => ["INT16", 2],
+    ?q => ["UINT16", 2],
+    ?i => ["INT32", 4],
+    ?u => ["UINT32", 4],
+    ?x => ["INT64", 8],
+    ?t => ["UINT64", 8],
+    ?d => ["DOUBLE", 8],
+    ?r => ["STRUCT", 8],
+    ?a => ["ARRAY", 4],
+    ?v => ["VARIANT", 1],
+    ?o => ["OBJECT_PATH", 4],
+    ?s => ["STRING", 4],
+    ?g => ["SIGNATURE", 1],
+    ?e => ["DICT_ENTRY", 8],
+    ?h => ["UNIX_FD", 4],
+  }
+  # Defines the set of constants
+  TypeMapping.each_pair do |key, value|
+    Type.const_set(value.first, key)
+  end
+
+  # Exception raised when an unknown/incorrect type is encountered.
+  class SignatureException < Exception
+  end
+
+  # = D-Bus type conversion class
+  #
+  # Helper class for representing a D-Bus type.
+  class Type
+    # Returns the signature type number.
+    attr_reader :sigtype
+    # Return contained member types.
+    attr_reader :members
+
+    # Create a new type instance for type number _sigtype_.
+    def initialize(sigtype)
+      if not TypeMapping.keys.member?(sigtype)
+        raise SignatureException, "Unknown key in signature: #{sigtype.chr}"
+      end
+      @sigtype = sigtype
+      @members = Array.new
+    end
+
+    # Return the required alignment for the type.
+    def alignment
+      TypeMapping[@sigtype].last
+    end
+
+    # Return a string representation of the type according to the
+    # D-Bus specification.
+    def to_s
+      case @sigtype
+      when STRUCT
+        "(" + @members.collect { |t| t.to_s }.join + ")"
+      when ARRAY
+        "a" + child.to_s
+      when DICT_ENTRY
+        "{" + @members.collect { |t| t.to_s }.join + "}"
+      else
+        if not TypeMapping.keys.member?(@sigtype)
+          raise NotImplementedError
+        end
+        @sigtype.chr
+      end
+    end
+
+    # Add a new member type _a_.
+    def <<(a)
+      if not [STRUCT, ARRAY, DICT_ENTRY].member?(@sigtype)
+        raise SignatureException
+      end
+      raise SignatureException if @sigtype == ARRAY and @members.size > 0
+      if @sigtype == DICT_ENTRY
+        if @members.size == 2
+          raise SignatureException, "Dict entries have exactly two members"
+        end
+        if @members.size == 0
+          if [STRUCT, ARRAY, DICT_ENTRY].member?(a.sigtype)
+            raise SignatureException, "Dict entry keys must be basic types"
+          end
+        end
+      end
+      @members << a
+    end
+
+    # Return the first contained member type.
+    def child
+      @members[0]
+    end
+
+    def inspect
+      s = TypeMapping[@sigtype].first
+      if [STRUCT, ARRAY].member?(@sigtype)
+        s += ": " + @members.inspect
+      end
+      s
+    end
+  end # class Type
+
+  # = D-Bus type parser class
+  #
+  # Helper class to parse a type signature in the protocol.
+  class Parser
+    # Create a new parser for the given _signature_.
+    def initialize(signature)
+      @signature = signature
+      @idx = 0
+    end
+
+    # Returns the next character from the signature.
+    def nextchar
+      c = @signature[@idx]
+      @idx += 1
+      c
+    end
+
+    # Parse one character _c_ of the signature.
+    def parse_one(c)
+      res = nil
+      case c
+      when ?a
+        res = Type.new(ARRAY)
+        c = nextchar
+        raise SignatureException, "Parse error in #{@signature}" if c == nil
+        child = parse_one(c)
+        res << child
+      when ?(
+        res = Type.new(STRUCT)
+        while (c = nextchar) != nil and c != ?)
+          res << parse_one(c)
+        end
+        raise SignatureException, "Parse error in #{@signature}" if c == nil
+      when ?{
+        res = Type.new(DICT_ENTRY)
+        while (c = nextchar) != nil and c != ?}
+          res << parse_one(c)
+        end
+        raise SignatureException, "Parse error in #{@signature}" if c == nil
+      else
+        res = Type.new(c)
+      end
+      res
+    end
+
+    # Parse the entire signature, return a DBus::Type object.
+    def parse
+      @idx = 0
+      ret = Array.new
+      while (c = nextchar)
+        ret << parse_one(c)
+      end
+      ret
+    end
+  end # class Parser
+end # module Type
+
+# shortcuts
+
+# Parse a String to a DBus::Type::Type
+def type(string_type)
+  Type::Parser.new(string_type).parse[0]
+end
+module_function :type
+
+# Make an explicit [Type, value] pair
+def variant(string_type, value)
+  [type(string_type), value]
+end
+module_function :variant
+
+end # module DBus