+2003-09-24 Seth Nickell <seth@gnome.org>
+
+ * python/dbus.py:
+
+ Connect Object methods (when you are sharing an object) up... pass
+ in a list of methods to be shared. Sharing all the methods just
+ worked out too weird. You can now create nice Services over the
+ DBus in Python. :-)
+
+ * python/dbus_bindings.pyx.in:
+
+ Keep references to user_data tuples passed into C functions so
+ Python doesn't garbage collect on us.
+
+ Implement MethodReturn and Error subclasses of Message for creating
+ DBusMessage's of those types.
+
+ * python/examples/example-client.py:
+ * python/examples/example-service.py:
+
+ Simple example code showing both how create DBus services and objects,
+ and how to use them.
+
2003-09-23 Havoc Pennington <hp@pobox.com>
* glib/dbus-gproxy.c (dbus_gproxy_manager_filter): implement
def __init__(self, object_path, methods_to_share, service):
self._object_path = object_path
self._service = service
- self._object_methods = methods_to_share
self._bus = service.get_bus()
self._connection = self._bus.get_connection()
+
+ self._method_name_to_method = self._build_method_dictionary(methods_to_share)
self._connection.register_object_path(object_path, self._unregister_cb, self._message_cb)
def _unregister_cb(self, connection):
print ("Unregister")
- def message_cb(self, connection, message):
- print ("Message %s received" % (message))
- print ("MethodCall %s" % (message.get_member()))
+ def _message_cb(self, connection, message):
+ target_method_name = message.get_member()
+ target_method = self._method_name_to_method[target_method_name]
+ args = message.get_args_list()
+
+ retval = target_method(*args)
+
+ reply = dbus_bindings.MethodReturn(message)
+ if retval != None:
+ reply.append(retval)
+ self._connection.send(reply)
+
+ def _build_method_dictionary(self, methods):
+ dictionary = {}
+ for method in methods:
+ if dictionionary.has_key(method.__name__):
+ print ('WARNING: registering DBus Object methods, already have a method named %s' % (method.__name__)
+ dictionary[method.__name__] = method
+ return dictionary
class RemoteService:
"""A remote service providing objects.
void (* dbus_internal_pad4) (void *)
+_user_data_references = [ ]
+
class DBusException(Exception):
pass
void *user_data):
print ("cmessage_function_handler() called")
tup = <object>user_data
+ print (type(tup))
print (tup)
function = tup[1]
message = Message(_create=0)
# FIXME: this is a major major hack. We use this because casting values to
# python objects and returning seemed to be corrupting them. This is a "global variable" :-(
cdef char **_parsed_path
-
+
def __init__(self, address=None, _conn=None):
cdef DBusError error
dbus_error_init(&error)
cvtable.message_function = cmessage_function_handler
user_data = [unregister_cb, message_cb]
- #Py_XINCREF(user_data)
+ global _user_data_references
+ _user_data_references.append(user_data)
path_element_list = path[1:].split('/')
self._build_parsed_path(path_element_list)
cvtable.message_function = cmessage_function_handler
user_data = [unregister_cb, message_cb]
- Py_XINCREF(user_data)
-
- print ("Ref inced")
+ global _user_data_references
+ _user_data_references.append(user_data)
path_element_list = path[1:].split('/')
self._build_parsed_path(path_element_list)
cdef class Message:
cdef DBusMessage *msg
- def __init__(self, message_type=MESSAGE_TYPE_INVALID, service=None, path=None, interface=None,
- method=None, name=None, reply_to=None, error_name=None, error_message=None,
+ def __init__(self, message_type=MESSAGE_TYPE_INVALID,
+ service=None, path=None, interface=None, method=None,
+ method_call=None,
+ name=None,
+ reply_to=None, error_name=None, error_message=None,
_create=1):
cdef char *cservice
if (service == None):
cservice = service
if not _create:
- return 0
+ return
if message_type == MESSAGE_TYPE_METHOD_CALL:
self.msg = dbus_message_new_method_call(cservice, path, interface, method)
elif message_type == MESSAGE_TYPE_METHOD_RETURN:
- msg = method_call._get_msg()
- self.msg = dbus_message_new_method_return(<DBusMessage*>msg)
+ print ("Doing this")
+ cmsg = method_call._get_msg()
+ self.msg = dbus_message_new_method_return(<DBusMessage*>cmsg)
+ print ("Done")
elif message_type == MESSAGE_TYPE_SIGNAL:
self.msg = dbus_message_new_signal(path, interface, name)
elif message_type == MESSAGE_TYPE_ERROR:
- msg = reply_to._get_msg()
- self.msg = dbus_message_new_error(<DBusMessage*>msg, error_name, error_message)
+ cmsg = reply_to._get_msg()
+ self.msg = dbus_message_new_error(<DBusMessage*>cmsg, error_name, error_message)
def type_to_name(self, type):
if type == MESSAGE_TYPE_SIGNAL:
def __init__(self, mpath, minterface, mmethod):
Message.__init__(self, MESSAGE_TYPE_METHOD_CALL, path=mpath, interface=minterface, method=mmethod)
+class MethodReturn(Message):
+ def __init__(self, method_call):
+ Message.__init__(self, MESSAGE_TYPE_METHOD_RETURN, method_call=method_call)
+
+class Error(Message):
+ def __init__(self, reply_to, error_name, error_message):
+ Message.__init__(self, MESSAGE_TYPE_ERROR, reply_to=reply_to, error_name=error_name, error_message=error_message)
+
cdef class Server:
cdef DBusServer *server
def __init__(self, address):