Class: DBus::Object

Inherits:
Object
  • Object
show all
Defined in:
lib/dbus/export.rb

Overview

Exported object type

Exportable D-Bus object class

Objects that are going to be exported by a D-Bus service should inherit from this class. At the client side, use ProxyObject.

Defined Under Namespace

Classes: UndefinedInterface

Constant Summary collapse

@@cur_intf =

Interface

nil
@@intfs_mutex = 
Mutex.new

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(path) ⇒ Object

Create a new object with a given path. Use Service#export to export it.



32
33
34
35
 
# File 'lib/dbus/export.rb', line 32

def initialize(path)
  @path = path
  @service = nil
end

Instance Attribute Details

#path ⇒ Object (readonly)

The path of the object.



21
22
23
 
# File 'lib/dbus/export.rb', line 21

def path
  @path
end

#service=(value) ⇒ Object (writeonly)

The service that the object is exported by.



25
26
27
 
# File 'lib/dbus/export.rb', line 25

def service=(value)
  @service = value
end

Class Method Details

.dbus_interface(s) ⇒ Object

Select (and create) the interface that the following defined methods belong to.



76
77
78
79
80
81
82
83
84
85
 
# File 'lib/dbus/export.rb', line 76

def self.dbus_interface(s)
  @@intfs_mutex.synchronize do
    unless @@cur_intf = (self.intfs && self.intfs[s])
      @@cur_intf = Interface.new(s)
      self.intfs = (self.intfs || {}).merge({s => @@cur_intf})
    end
    yield
    @@cur_intf = nil
  end
end

.dbus_method(sym, protoype = "", &block) ⇒ Object

Defines an exportable method on the object with the given name sym, prototype and the code in a block.

Raises:



96
97
98
99
100
 
# File 'lib/dbus/export.rb', line 96

def self.dbus_method(sym, protoype = "", &block)
  raise UndefinedInterface, sym if @@cur_intf.nil?
  @@cur_intf.define(Method.new(sym.to_s).from_prototype(protoype))
  define_method(Object.make_method_name(@@cur_intf.name, sym.to_s), &block) 
end

.dbus_signal(sym, protoype = "") ⇒ Object

Defines a signal for the object with a given name sym and prototype.

Raises:



109
110
111
112
113
114
115
116
117
 
# File 'lib/dbus/export.rb', line 109

def self.dbus_signal(sym, protoype = "")
  raise UndefinedInterface, sym if @@cur_intf.nil?
  cur_intf = @@cur_intf
  signal = Signal.new(sym.to_s).from_prototype(protoype)
  cur_intf.define(Signal.new(sym.to_s).from_prototype(protoype))
  define_method(sym.to_s) do |*args|
    emit(cur_intf, signal, *args)
  end
end

Instance Method Details

#dispatch(msg) ⇒ Object

Dispatch a message msg to call exported methods



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/dbus/export.rb', line 44

def dispatch(msg)
  case msg.message_type
  when Message::METHOD_CALL
    reply = nil
    begin
      if not self.intfs[msg.interface]
        raise DBus.error("org.freedesktop.DBus.Error.UnknownMethod"),
        "Interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
      end
      meth = self.intfs[msg.interface].methods[msg.member.to_sym]
      if not meth
        raise DBus.error("org.freedesktop.DBus.Error.UnknownMethod"),
        "Method \"#{msg.member}\" on interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
      end
      methname = Object.make_method_name(msg.interface, msg.member)
      retdata = method(methname).call(*msg.params)
      retdata =  [*retdata]

      reply = Message.method_return(msg)
      meth.rets.zip(retdata).each do |rsig, rdata|
        reply.add_param(rsig.type, rdata)
      end
    rescue => ex
      dbus_msg_exc = msg.annotate_exception(ex)
      reply = ErrorMessage.from_exception(dbus_msg_exc).reply_to(msg)
    end
    @service.bus.message_queue.push(reply)
  end
end

#emit(intf, sig, *args) ⇒ Object

Emits a signal from the object with the given interface, signal sig and arguments args.



104
105
106
 
# File 'lib/dbus/export.rb', line 104

def emit(intf, sig, *args)
  @service.bus.emit(@service, self, intf, sig, *args)
end

#implements(intf) ⇒ Object

State that the object implements the given intf.



38
39
40
41
 
# File 'lib/dbus/export.rb', line 38

def implements(intf)
  # use a setter
  self.intfs = (self.intfs || {}).merge({intf.name => intf})
end