def callback(proxy, result, reply, error):
try:
value = proxy.call_finish(result).unpack()
if reply: reply(*value)
else: return value
except GLib.Error as e:
if error: error(parse_dbus_error(e))
else: raise parse_dbus_error(e)
def callback(proxy, result, reply, error):
try:
value = proxy.call_finish(result).unpack()
if reply: reply(*value)
else: return value
except GLib.Error as e:
if error: error(parse_dbus_error(e))
else: raise parse_dbus_error(e)
def callback(
proxy: Base,
result: Gio.Task,
reply: Optional[Callable[..., None]],
error: Optional[Callable[[BluezDBusException], None]],
) -> None:
try:
value = proxy.call_finish(result).unpack()
if reply:
reply(*value)
except GLib.Error as e:
if error:
error(parse_dbus_error(e))
else:
raise parse_dbus_error(e)
def get(self, name):
try:
prop = self.call_sync(
'org.freedesktop.DBus.Properties.Get',
GLib.Variant('(ss)', (self._interface_name, name)),
Gio.DBusCallFlags.NONE, GLib.MAXINT, None)
return prop.unpack()[0]
except GLib.Error as e:
if name in self.__fallback:
return self.__fallback[name]
else:
raise parse_dbus_error(e)
def get(self, name):
try:
prop = self.call_sync(
'org.freedesktop.DBus.Properties.Get',
GLib.Variant('(ss)', (self._interface_name, name)),
Gio.DBusCallFlags.NONE,
GLib.MAXINT,
None)
return prop.unpack()[0]
except GLib.Error as e:
if name in self.__fallback:
return self.__fallback[name]
else:
raise parse_dbus_error(e)
def _call(self, method, param=None, properties=False, *args, **kwargs):
def callback(proxy, result, reply_handler, error_handler):
try:
result = proxy.call_finish(result).unpack()
reply_handler(*result)
except GLib.Error as e:
error_handler(parse_dbus_error(e))
def ok(*args, **kwargs):
if callable(reply_handler):
reply_handler(*args, **kwargs)
def err(e):
if callable(error_handler):
error_handler(e)
else:
raise exception
if properties: dbus_proxy = self.__dbus_properties_proxy
else: dbus_proxy = self.__dbus_proxy
if 'reply_handler' in kwargs:
reply_handler = kwargs.pop('reply_handler')
else:
reply_handler = None
if 'error_handler' in kwargs:
error_handler = kwargs.pop('error_handler')
else:
error_handler = None
if reply_handler or error_handler:
# Make sure we have an error handler if we do async calls
assert (error_handler != None)
dbus_proxy.call(method, param, Gio.DBusCallFlags.NONE, GLib.MAXINT,
None, callback, ok, err)
else:
try:
result = dbus_proxy.call_sync(method, param,
Gio.DBusCallFlags.NONE,
GLib.MAXINT, None)
if result:
return result.unpack()
except GLib.Error as e:
raise parse_dbus_error(e)
def callback(
proxy: Base,
result: Gio.Task,
reply: Optional[Callable[..., None]],
error: Optional[Callable[[BluezDBusException], None]],
) -> None:
try:
value = proxy.call_finish(result).unpack()
if reply:
reply(*value)
except GLib.Error as e:
if error:
error(parse_dbus_error(e))
else:
logging.error(
f"Unhandled error for {self.get_interface_name()}.{method}",
exc_info=True)
def _call(self, method, param=None, properties=False, *args, **kwargs):
def callback(proxy, result, reply_handler, error_handler):
try:
result = proxy.call_finish(result).unpack()
reply_handler(*result)
except GLib.Error as e:
error_handler(parse_dbus_error(e))
def ok(*args, **kwargs):
if callable(reply_handler):
reply_handler(*args, **kwargs)
def err(e):
if callable(error_handler):
error_handler(e)
else:
raise exception
if properties: dbus_proxy = self.__dbus_properties_proxy
else: dbus_proxy = self.__dbus_proxy
if 'reply_handler' in kwargs:
reply_handler = kwargs.pop('reply_handler')
else:
reply_handler = None
if 'error_handler' in kwargs:
error_handler = kwargs.pop('error_handler')
else:
error_handler = None
if reply_handler or error_handler:
# Make sure we have an error handler if we do async calls
assert(error_handler != None)
dbus_proxy.call(method, param, Gio.DBusCallFlags.NONE, GLib.MAXINT, None,
callback, ok, err)
else:
try:
result = dbus_proxy.call_sync(method, param, Gio.DBusCallFlags.NONE,
GLib.MAXINT, None)
if result:
return result.unpack()
except GLib.Error as e:
raise parse_dbus_error(e)
def _call(self, method, *args, **kwargs):
def ok(*args, **kwargs):
if callable(reply_handler):
reply_handler(*args, **kwargs)
def err(e):
exception = parse_dbus_error(e)
if callable(error_handler):
error_handler(exception)
else:
raise exception
if 'interface' in kwargs:
interface = kwargs.pop('interface')
else:
interface = self.__interface
if 'reply_handler' in kwargs:
reply_handler = kwargs.pop('reply_handler')
else:
reply_handler = None
if 'error_handler' in kwargs:
error_handler = kwargs.pop('error_handler')
else:
error_handler = None
# Make sure we have an error handler if we do async calls
if reply_handler: assert(error_handler is not None)
try:
if reply_handler or error_handler:
return getattr(interface, method)(reply_handler=ok, error_handler=err, *args, **kwargs)
else:
return getattr(interface, method)(*args, **kwargs)
except dbus.DBusException as exception:
raise parse_dbus_error(exception)
def callback(proxy, result, reply_handler, error_handler):
try:
result = proxy.call_finish(result).unpack()
reply_handler(*result)
except GLib.Error as e:
error_handler(parse_dbus_error(e))
def error_handler_wrapper(exception):
exception = parse_dbus_error(exception)
if not callable(error_handler):
raise exception
error_handler(exception)
def err(e):
exception = parse_dbus_error(e)
if callable(error_handler):
error_handler(exception)
else:
raise exception
def callback(proxy, result, reply_handler, error_handler):
try:
result = proxy.call_finish(result).unpack()
reply_handler(*result)
except GLib.Error as e:
error_handler(parse_dbus_error(e))
