def main(args): bus = SessionBus() loop = GLib.MainLoop() def new_wallpaper(): wg.NewWallpaper(args.type, args.subreddit, args.directory, args.output, args.generate_only) if args.dbus: bus.publish('de.thm.mni.mhpp11.WallGen', WallGenDBUSService(loop)) run(loop) else: try: wg = bus.get('de.thm.mni.mhpp11.WallGen') except GLib.Error: wg = WallGenDBUSService(None) if type(wg) != WallGenDBUSService: if args.monitor: dc = bus.get('org.gnome.Mutter.DisplayConfig') with wg.Closed.connect(loop.quit): with dc.MonitorsChanged.connect(new_wallpaper): run(loop) elif args.quit: wg.Close() if not args.monitor: new_wallpaper() elif type(wg) == WallGenDBUSService: raise Exception("Monitoring is not possible without DBus service!")
def main(): win = NotificationsWindow() bus = SessionBus() bus.publish("org.freedesktop.Notifications", Notifications(win)) loop = GLib.MainLoop() th = Thread(target=loop.run) th.start() win.mainloop()
def cli(): loop = GLib.MainLoop() bus = SessionBus() bus.publish(INTERFACE_NAME, RofiDbus()) try: loop.run() except KeyboardInterrupt: loop.quit()
def main(): loop = GLib.MainLoop() bus = SessionBus() service = TestService() print("Publishing service") bus.publish("com.wdc.TestService1", service) loop.run()
def main(): rospy.loginfo("Starting Raven[ops] ROS Bag Player") verbose = False bagfile = "" parser = argparse.ArgumentParser() parser.add_argument('-b', '--bagfile', required=True, default="", help="complete bagfile path") parser.add_argument('-v', '--verbose', default=False, help="select verbose output", action='store_true') parser.add_argument("args", nargs='+') args = parser.parse_args() if args.bagfile: bagfile = args.bagfile if args.verbose: verbose = True # RVN::TODO: Not connected rospy.loginfo("Getting main Glib loop object") try: loop = GLib.MainLoop() except Exception as e: rospy.logerr("Unable to create GLib.MainLoop!") return ExitStatus.PUB_FAIL rospy.loginfo("Creating Publication Control Object") try: pub = PublicationControl(bagfile, loop) except Exception as e: rospy.logerr("{}".format(e)) return ExitStatus.PUB_FAIL rospy.loginfo("starting d-bus service...") try: session_bus = SessionBus() except Exception as e: rospy.logerr("Unable to create the session dbus") return ExitStatus.PUB_FAIL rospy.loginfo("created the session d-bus object") try: session_bus.publish(service_name, pub) except Exception as e: rospy.logerr("Unable to set up session dbus: {}".format(e)) return ExitStatus.PUB_FAIL rospy.loginfo("published to the '{}' dbus ".format(service_name)) rospy.loginfo("running the main loop...") loop.run() rospy.loginfo("...finished d-bus service") return pub.exit_status
def run(): bus = SessionBus() try: hidamari = HidamariService() bus.publish(DBUS_NAME, hidamari) hidamari.dbus_published_callback() loop.run() except RuntimeError: print("Error: Failed to create server")
def init(): print('start convergence.dbus') print('use session.') session_bus = SessionBus() global sm sm = ServiceManager() print('published bus_name: ', SM__BUS_NAME) session_bus.publish(SM__BUS_NAME, (SM__OBJECT_PATH, sm)) signal.signal(signal.SIGINT, receive_signal) sm.sm_start_signal()
def main(): from gi.repository import GLib from pydbus import SessionBus config_home = os.environ.get("XDG_CONFIG_HOME", os.path.join(os.environ["HOME"], ".config")) config = read_config(config_home) log = PladderLog(config) bus = SessionBus() bus.publish("se.raek.PladderLog", log) loop = GLib.MainLoop() loop.run()
def main(): from gi.repository import GLib from pydbus import SessionBus state_home = os.environ.get("XDG_CONFIG_HOME", os.path.join(os.environ["HOME"], ".config")) state_dir = os.path.join(state_home, "pladder-bot") pladder_bot = PladderBot(state_dir) bus = SessionBus() bus.publish("se.raek.PladderBot", pladder_bot) loop = GLib.MainLoop() loop.run()
def main(): from gi.repository import GLib from pydbus import SessionBus state_home = os.environ.get("XDG_CONFIG_HOME", os.path.join(os.environ["HOME"], ".config")) state_dir = os.path.join(state_home, "pladder-bot") bus = SessionBus() with PladderBot(state_dir, bus) as bot: load_standard_plugins(bot) bus.publish("se.raek.PladderBot", bot) loop = GLib.MainLoop() loop.run()
class Mocker(object): def start(self): self._bus = SessionBus() self._mock = SignalCLIDBusMock() self._mockerservice = self._bus.publish( "org.signalbot.signalclidbusmock", self._mock) self._loop = GLib.MainLoop() self._thread = Thread(target=self._loop.run, daemon=True) self._thread.start() self.tosignalbot = [] self._wait_until = 0 def messageSignalbot(self, sender, group_id, text, attachmentfiles): self._mock.MessageReceived(int(time.time()), sender, group_id, text, attachmentfiles) self.tosignalbot.append( [int(time.time()), sender, group_id, text, attachmentfiles]) def _wait_until_n_messages(self, n=1, timeout=1): return self._mock.wait_until_n_messages(n=n, timeout=timeout) def wait_for_n_messages(self, n=1, timeout=1): self._wait_until += n self._wait_until_n_messages(n=self._wait_until, timeout=timeout) @property def fromsignalbot(self): return self._mock._sentmessages def stop(self): self._loop.quit() self._thread.join() self._mockerservice.unpublish()
def start(): args = parse_arguments() config = Config() if not config.is_supported_desktop(): raise Exception('Desktop environment not supported.') bus = SessionBus() loop = GLib.MainLoop() if args.dbus: bus.publish('de.thm.mni.mhpp11.WallGen', WallGenDBUSService(loop)) run(loop) else: try: wg = bus.get('de.thm.mni.mhpp11.WallGen') except GLib.Error: wg = WallGenDBUSService(None) if type(wg) != WallGenDBUSService: if args.monitor: dc = None if config.is_gnome(): dc = bus.get('org.gnome.Mutter.DisplayConfig') elif config.is_kde(): dc = bus.get('org.kde.KScreen', object_path='/backend') with wg.Closed.connect(loop.quit): if config.is_gnome(): with dc.MonitorsChanged.connect(wg.NewWallpaper): run(loop) elif config.is_kde(): class KDENewWallpaper: first_call = True def call(self, _): if (self.first_call): wg.NewWallpaper() self.first_call = not self.first_call with dc.configChanged.connect(KDENewWallpaper().call): run(loop) elif args.quit: wg.Close() elif type(wg) == WallGenDBUSService and args.monitor: raise Exception("Monitoring is not possible without DBus service!") if not args.monitor and not args.quit: wg.NewWallpaper()
def publish(self, bus=None): """Publish the media player to DBus.""" if bus is None: bus = SessionBus() pub = bus.publish("org.mpris.MediaPlayer2.%s" % self.name, ("/org/mpris/MediaPlayer2", self)) return (bus, pub)
class DBusThread(Thread): def __init__(self, c, dbus_mm): super().__init__(name='DBus', daemon=True) self._c = c self._loop = GLib.MainLoop() self._bus = SessionBus() self._dbus_mm = dbus_mm self._dbus_mm.loop = self._loop self._dbus_mm.bus = self._bus def run(self): pub = {} # for t, module in self._mm.modules.items(): # try: # pub[t] = self._bus.publish(module.name, (module)) # except (GLib.Error, TypeError) as e: # logger.error(f'error publishing {t} because {e}') # logger.error('dbus string is likely empty or doesn\'t exist, this can be safely ignored') self._bus.publish(self._c['DBus']['prefix'], self._dbus_mm) self._loop.run()
def RaiseA(self, msg): raise ExceptionA(msg) def RaiseB(self, msg): raise ExceptionB(msg) def RaiseD(self, msg): raise ExceptionD(msg) def RaiseE(self, msg): raise ExceptionE(msg) bus = SessionBus() with bus.publish("net.lew21.pydbus.tests.Test", TestObject()): remote = bus.get("net.lew21.pydbus.tests.Test") def t_func(): # Test new registered errors. try: remote.RaiseA("Test A") except ExceptionA as e: assert str(e) == "Test A" try: remote.RaiseB("Test B") except ExceptionB as e: assert str(e) == "Test B" # Test mapped errors.
def __init__(self, iid): self.id = iid def HelloWorld(self, a, b): res = self.id + ": " + a + str(b) global done done += 1 if done == 2: loop.quit() print("server side: " + res) return res bus = SessionBus() with bus.publish("net.lew21.pydbus.Test", TestObject("Main"), ("Lol", TestObject("Lol"))): remoteMain = bus.get("net.lew21.pydbus.Test") remoteLol = bus.get("net.lew21.pydbus.Test", "Lol") def t1_func(): print(remoteMain.HelloWorld("t", 1)) def t2_func(): print(remoteLol.HelloWorld("t", 2)) t1 = Thread(None, t1_func) t2 = Thread(None, t2_func) t1.daemon = True t2.daemon = True def handle_timeout():
<arg name="request" type="s" direction="in"/> <arg name="resp_result" type="b" direction="out"/> <arg name="resp_data" type="s" direction="out"/> </method> <signal name="UpdateInfo"> <arg type="s" name="info"/> </signal> </interface> </node> """ UpdateInfo = signal() def Get(self, s): print("com.ssangyong.AutomotiveProxy.LocationManager " + "Get : " + s) return (True, "{\"Data\":null,\"Result\":{\"Message\":\"Success\",\"Status\":true}}") def Set(self, s): print("com.ssangyong.AutomotiveProxy.LocationManager " + "Set : " + s) return "Location Manager - Set" def AddListener(self, s): print("com.ssangyong.AutomotiveProxy.LocationManager " + "AddListener : " + s) self.UpdateInfo("{\"Cmd\":\"PTTEvent\",\"Data\":{\"Action\":\"VrStartEvent123\"}}") return (True, "{\"Data\":null,\"Result\":{\"Message\":\"Success\",\"Status\":true}}") bus = SessionBus() bus.publish("com.ssangyong.AutomotiveProxy", VrService(), ("VrManager", VrService()), ("LocationManager", LocationService())) loop.run()
global done done += 1 if done == 2: loop.quit() return "M1" def Method2(self): global done done += 1 if done == 2: loop.quit() return "M2" bus = SessionBus() with bus.publish("net.lew21.pydbus.tests.expose_multiface", TestObject()): remote = bus.get("net.lew21.pydbus.tests.expose_multiface") def t1_func(): print(remote.Method1()) print(remote.Method2()) t1 = Thread(None, t1_func) t1.daemon = True def handle_timeout(): print("ERROR: Timeout.") sys.exit(1) GLib.timeout_add_seconds(2, handle_timeout)
def setup_mpris(app): from pydbus import SessionBus, Variant from pydbus.generic import signal class MPRIS: """ <node> <interface name="org.mpris.MediaPlayer2"> <property name="CanQuit" type="b" access="read" /> <property name="CanRaise" type="b" access="read" /> <property name="HasTrackList" type="b" access="read" /> <property name="Identity" type="s" access="read" /> <property name="SupportedMimeTypes" type="as" access="read" /> <property name="SupportedUriSchemes" type="as" access="read" /> <method name="Quit" /> <method name="Raise" /> </interface> <interface name="org.mpris.MediaPlayer2.Player"> <property name="PlaybackStatus" type="s" access="read" /> <property name="Rate" type="d" access="readwrite" /> <property name="Metadata" type="a{sv}" access="read"/> <property name="Volume" type="d" access="readwrite" /> <property name="Position" type="x" access="read" /> <property name="MinimumRate" type="d" access="readwrite" /> <property name="MaximumRate" type="d" access="readwrite" /> <property name="CanGoNext" type="b" access="read" /> <property name="CanGoPrevious" type="b" access="read" /> <property name="CanPlay" type="b" access="read" /> <property name="CanPause" type="b" access="read" /> <property name="CanSeek" type="b" access="read" /> <property name="CanControl" type="b" access="read" /> <method name="Next" /> <method name="Previous" /> <method name="Pause" /> <method name="PlayPause" /> <method name="Stop" /> <method name="Play" /> <method name="Seek"> <arg type="x" direction="in" /> </method> <method name="SetPosition"> <arg type="o" direction="in" /> <arg type="x" direction="in" /> </method> <method name="OpenUri"> <arg type="s" direction="in" /> </method> </interface> </node> """ PropertiesChanged = signal() def __init__(self, app): self.app = app def emit_property_changed(self, attr): self.PropertiesChanged("org.mpris.MediaPlayer2.Player", {attr: getattr(self, attr)}, []) @property def CanQuit(self): return False @property def CanRaise(self): return False @property def HasTrackList(self): return False @property def Identity(self): return "TUIJam" @property def SupportedMimeTypes(self): return [] @property def SupportedUriSchemes(self): return [] def Raise(self): pass def Quit(self): pass @property def PlaybackStatus(self): return { "play": "Playing", "pause": "Paused", "stop": "Stopped" }[self.app.play_state] @property def Rate(self): return 1.0 @Rate.setter def Rate(self, rate): pass @property def Metadata(self): song = self.app.current_song if type(song) == Song: logging.info("New song ID: " + str(song.id)) return { "mpris:trackid": Variant("o", "/org/tuijam/GM_" + str(song.id).replace("-", "_")), "mpris:artUrl": Variant("s", song.albumArtRef), "xesam:title": Variant("s", song.title), "xesam:artist": Variant("as", [song.artist]), "xesam:album": Variant("s", song.album), "xesam:url": Variant("s", song.stream_url), } elif type(song) == YTVideo: return { "mpris:trackid": Variant("o", "/org/tuijam/YT_" + str(song.id).replace("-", "_")), "mpris:artUrl": Variant("s", song.thumbnail), "xesam:title": Variant("s", song.title), "xesam:artist": Variant("as", [song.channel]), "xesam:album": Variant("s", ""), "xesam:url": Variant("s", song.stream_url), } else: return {} @property def Volume(self): return self.app.volume / 8.0 @Volume.setter def Volume(self, volume): volume = max(0, min(volume, 1)) self.app.volume = int(volume * 8) self.app.player.volume = volume * 100 self.emit_property_changed("Volume") @property def Position(self): try: return int(1000000 * self.app.player.time_pos) except TypeError: return 0 @property def MinimumRate(self): return 1.0 @property def MaximumRate(self): return 1.0 @property def CanGoNext(self): return len(self.app.queue_panel.queue) > 0 @property def CanGoPrevious(self): return False @property def CanPlay(self): return (len(self.app.queue_panel.queue) > 0 or self.app.current_song is not None) @property def CanPause(self): return self.app.current_song is not None @property def CanSeek(self): return self.app.current_song is not None @property def CanControl(self): return True def Next(self): self.app.queue_panel.play_next() def Previous(self): pass def Pause(self): if self.app.play_state == "play": self.app.toggle_play() def PlayPause(self): self.app.toggle_play() def Stop(self): self.app.stop() def Play(self, song_id): self.app.toggle_play() def Seek(self, offset): pass def SetPosition(self, track_id, position): pass def OpenUri(self, uri): pass mpris = MPRIS(app) bus = SessionBus() try: bus.publish("org.mpris.MediaPlayer2.tuijam", ("/org/mpris/MediaPlayer2", mpris)) return mpris except RuntimeError as e: logging.exception(e) return None
def Progress(self, value): self._progress = value self.PropertiesChanged(Installer.interface, {'Progress': self.Progress}, []) @property def LastError(self): return self._last_error @LastError.setter def LastError(self, value): self._last_error = value self.PropertiesChanged(Installer.interface, {'LastError': self.LastError}, []) if __name__ == '__main__': import argparse from pydbus import SessionBus parser = argparse.ArgumentParser() parser.add_argument('bundle', help='Expected RAUC bundle') parser.add_argument('--completed-code', type=int, default=0, help='Code to emit as D-Bus Completed signal') args = parser.parse_args() loop = GLib.MainLoop() bus = SessionBus() installer = Installer(args.bundle, args.completed_code) with bus.publish('de.pengutronix.rauc', ('/', installer)): print('Interface published') loop.run()
""" <node> <interface name='net.lew21.pydbus.ClientServerExample'> <method name='Hello'> <arg type='s' name='response' direction='out'/> </method> <method name='EchoString'> <arg type='s' name='a' direction='in'/> <arg type='s' name='response' direction='out'/> </method> <method name='Quit'/> </interface> </node> """ def Hello(self): """returns the string 'Hello, World!'""" return "Hello, World!" def EchoString(self, s): """returns whatever is passed to it""" return s def Quit(self): """removes this object from the DBUS connection and exits""" loop.quit() bus = SessionBus() bus.publish("net.lew21.pydbus.ClientServerExample", MyDBUSService()) loop.run()
self._timer = threading.Timer(self.next_call - time.time(), self._run) self._timer.start() self.is_running = True def stop(self): self._timer.cancel() self.is_running = False if __name__ == "__main__": # Launch the server # Use pydbus to establish a session gdbus. Rather than system gdbus # TODO: Use try/except, etc. in case bus already exists. e.g. bus.get(BUS) bus = SessionBus() bus.publish(BUS, DBusService()) # Start the repeating timer. It auto-starts, no need of rt.start() # RepeatedTimer(period between function calls, function()) rt = RepeatedTimer(period, timer_event) # Enable R-Pi channel to perform callbacks on detection of a pulse. if not simulated_pulse: #GPIO.add_event_detect(channel, GPIO.RISING, callback=pulse_callback, # bouncetime=1) GPIO.add_event_detect(channel, GPIO.FALLING, callback=pulse_callback, bouncetime=1) print("server running...") try:
class GlibT: receive_queue = attr.ib() send_queue = attr.ib() data_dir = attr.ib() server_list = attr.ib() config = attr.ib() loop = attr.ib(init=False) store = attr.ib(init=False) users = attr.ib(init=False) devices = attr.ib(init=False) bus = attr.ib(init=False) control_if = attr.ib(init=False) device_if = attr.ib(init=False) notifications = attr.ib(type=bool, default=False, init=False) def __attrs_post_init__(self): self.loop = None id_counter = IdCounter() self.control_if = Control(self.send_queue, self.server_list, id_counter) self.device_if = Devices(self.send_queue, id_counter) self.bus = SessionBus() self.bus.publish("org.pantalaimon1", self.control_if, self.device_if) def unverified_notification(self, message): notificaton = notify2.Notification( "Unverified devices.", message=(f"There are unverified devices in the room " f"{message.room_display_name}."), ) notificaton.set_category("im") def send_cb(notification, action_key, user_data): message = user_data self.control_if.SendAnyways(message.pan_user, message.room_id) def cancel_cb(notification, action_key, user_data): message = user_data self.control_if.CancelSending(message.pan_user, message.room_id) if "actions" in notify2.get_server_caps(): notificaton.add_action("send", "Send anyways", send_cb, message) notificaton.add_action("cancel", "Cancel sending", cancel_cb, message) notificaton.show() def sas_invite_notification(self, message): notificaton = notify2.Notification( "Key verification invite", message=( f"{message.user_id} via {message.device_id} has started " f"a key verification process."), ) notificaton.set_category("im") def accept_cb(notification, action_key, user_data): message = user_data self.device_if.AcceptKeyVerification(message.pan_user, message.user_id, message.device_id) def cancel_cb(notification, action_key, user_data): message = user_data self.device_if.CancelKeyVerification(message.pan_user, message.user_id, message.device_id) if "actions" in notify2.get_server_caps(): notificaton.add_action("accept", "Accept", accept_cb, message) notificaton.add_action("cancel", "Cancel", cancel_cb, message) notificaton.show() def sas_show_notification(self, message): emojis = [x[0] for x in message.emoji] emoji_str = " ".join(emojis) notificaton = notify2.Notification( "Short authentication string", message=( f"Short authentication string for the key verification of" f" {message.user_id} via {message.device_id}:\n" f"{emoji_str}"), ) notificaton.set_category("im") def confirm_cb(notification, action_key, user_data): message = user_data self.device_if.ConfirmKeyVerification(message.pan_user, message.user_id, message.device_id) def cancel_cb(notification, action_key, user_data): message = user_data self.device_if.CancelKeyVerification(message.pan_user, message.user_id, message.device_id) if "actions" in notify2.get_server_caps(): notificaton.add_action("confirm", "Confirm", confirm_cb, message) notificaton.add_action("cancel", "Cancel", cancel_cb, message) notificaton.show() def sas_done_notification(self, message): notificaton = notify2.Notification( "Device successfully verified.", message=( f"Device {message.device_id} of user {message.user_id} " f"successfully verified."), ) notificaton.set_category("im") notificaton.show() def message_callback(self): try: message = self.receive_queue.get_nowait() except Empty: return True logger.debug(f"UI loop received message {message}") if isinstance(message, UpdateDevicesMessage): self.device_if.update_devices(message) elif isinstance(message, UpdateUsersMessage): self.control_if.update_users(message) elif isinstance(message, UnverifiedDevicesSignal): self.control_if.UnverifiedDevices(message.pan_user, message.room_id, message.room_display_name) if self.notifications: self.unverified_notification(message) elif isinstance(message, InviteSasSignal): self.device_if.VerificationInvite( message.pan_user, message.user_id, message.device_id, message.transaction_id, ) if self.notifications: self.sas_invite_notification(message) elif isinstance(message, ShowSasSignal): self.device_if.VerificationString( message.pan_user, message.user_id, message.device_id, message.transaction_id, message.emoji, ) if self.notifications: self.sas_show_notification(message) elif isinstance(message, SasDoneSignal): self.device_if.VerificationDone( message.pan_user, message.user_id, message.device_id, message.transaction_id, ) if self.notifications: self.sas_done_notification(message) elif isinstance(message, DaemonResponse): self.control_if.Response( message.message_id, message.pan_user, { "code": message.code, "message": message.message }, ) elif isinstance(message, KeyRequestMessage): self.device_if.update_key_requests(message) self.receive_queue.task_done() return True def run(self): self.loop = GLib.MainLoop() if self.config.notifications: try: notify2.init("pantalaimon", mainloop=self.loop) self.notifications = True except dbus.DBusException: logger.error( "Notifications are enabled but no notification " "server could be found, disabling notifications.") self.notifications = False GLib.timeout_add(100, self.message_callback) if not self.loop: return self.loop.run() def stop(self): if self.loop: self.loop.quit() self.loop = None
class DeviceManagerAPI(object): """ <node> <interface name='org.chemlab.UChroma.DeviceManager'> <method name='GetDevices'> <arg direction='out' type='ao' /> </method> <signal name='DevicesChanged'> <arg direction='out' type='s' name='action' /> <arg direction='out' type='o' name='device' /> </signal> </interface> </node> """ def __init__(self, device_manager, logger): self._dm = device_manager self._logger = logger self._bus = None self._dm.callbacks.append(self._dm_callback) self._devs = OrderedDict() def GetDevices(self): """ Get the list of object paths associated with discovered devices """ if self._dm.devices is None: return [] return tuple([x.bus_path for x in self._devs.values()]) DevicesChanged = signal() def _publish_device(self, device): devapi = DeviceAPI(device, self._bus) devapi.publish() self._devs[device.key] = devapi return devapi.bus_path def _unpublish_device(self, device): devapi = self._devs.pop(device.key, None) if devapi is not None: devapi.unpublish() return devapi.bus_path return None async def _dm_callback(self, action, device): self._logger.info('%s: %s', action, device) path = None if action == 'add': path = self._publish_device(device) device.fire_restore_prefs() elif action == 'remove': path = self._unpublish_device(device) else: return if path is not None: self.DevicesChanged(action, path) def run(self): """ Publish the service """ self._bus = SessionBus() self._bus.publish('org.chemlab.UChroma', self)
player = Mpvplayer() player.start() class DBUSPlayerService(object): """ <node> <interface name='github.zhangn1985.dbplay'> <method name='play'> <arg type='s' name='playinfo' direction='in'/> </method> <method name='stop'/> <method name='exit'/> </interface> </node> """ def play(self, playinfo): player.play(playinfo) def stop(self): player.stop() def exit(self): player.exit() loop.quit() bus = SessionBus() bus.publish("github.zhangn1985.dbplay", DBUSPlayerService()) loop.run()
"From Cleint 3. Return Hello and the persons name" print("From Client 3: Hello {}".format(name)) return def get_time_stamp(self): "From Client 2. Return a Unix time. Seconds since epoch" return time.time() # 1511326564.8677926 def server_no_args(self): "From Client 1. No arguments, Server has a message on the console." global message_count print("From Client 1: This is message {}".format(message_count)) message_count += 1 return def timer(): "Emit a random integer each call." random_integer = random.randint(0, 100) print("Random integer emitted: {}".format(random_integer)) emit.integer_signal(random_integer) return True if __name__ == "__main__": emit = DBusService_XML() bus.publish(BUS, emit) GLib.timeout_add_seconds(interval=INTERVAL, function=timer) loop.run()
bus = SessionBus() # SystemBus BUS = "org.example.demo.test" loop = GLib.MainLoop() class DBusService_XML(): """ DBus Service XML definition. type="i" for integer, "s" string, "d" double, "as" list of string data. """ dbus = """ <node> <interface name="{}"> <method name="get_time_stamp"> <arg type="d" name="response" direction="out"> </arg> </method> </interface> </node> """.format(BUS) def get_time_stamp(self): "Return a Unix time. Seconds since epoch" return time.time() # 1511326564.8677926 if __name__ == "__main__": print("Starting Server Demo 2...") bus.publish(BUS, DBusService_XML()) loop.run()
self._who = "human" self._state = "good" def hello(self): return "Hello %s!" % self._who def quit(self): loop.quit() def whatsup(self): return "@!#$*&@!, %s!" % self._who @property def State(self): return self._state @property def Who(self): return self._who @Who.setter def Who(self, value): self._who = value self.PropertiesChanged("org.me.test1", {"Who": self._who}, []) PropertiesChanged = signal() bus = SessionBus() bus.publish("org.me.test", MyDBUSService()) loop.run()
""" <?xml version="1.0" encoding="UTF-8" ?> <node xmlns:doc="http://www.freedesktop.org/dbus/1.0/doc.dtd"> <interface name="com.lge.car.micom.can"> <method name="TriggerTest"/> <signal name="NotifyKeyFrontPannelEvent"> <arg name="front" direction="out" type="ay"/> </signal> </interface> </node> """ NotifyKeyFrontPannelEvent = signal() def TriggerTest(self): keyEvent = [0x16, 0x01] print( "LG AVN Can DBus Server - method name: TriggerTest, key value: " + str(keyEvent[0]) + ", type1: " + str(keyEvent[1])) self.NotifyKeyFrontPannelEvent(keyEvent) pass bus = SessionBus() bus.publish("com.lge.car.micom", LgAvnCanService(), ("/Can", LgAvnCanService())) loop = GLib.MainLoop() loop.run()
builder.connect_signals(Handler()) main_window = builder.get_object("main_window") # add_app_dialog = builder.get_object("add_app_dialog") # edit_app_dialog = builder.get_object("edit_app_dialog") # app_list_treeview = builder.get_object("app_list_treeview") server_status_label = builder.get_object("server_status_label") assistant_listbox = builder.get_object("assistant_listbox") # select = app_list_treeview.get_selection() # select.connect("changed", Handler.on_tree_selection_changed) # draw_table() client_bus = SessionBus() client_bus.publish("org.LinuxAssistantClient", DBusService()) server_bus = SessionBus() is_server_running = False try: server = server_bus.get("org.LinuxAssistantServer") is_server_running = server.client_init() except: print("Server is not running") if is_server_running is True: server_status_label.set_text("Server is running") else: server_status_label.set_text("Server is not running")
from playthread import Mpvplayer loop = GLib.MainLoop() player = Mpvplayer() player.start() class DBUSPlayerService(object): """ <node> <interface name='github.zhangn1985.dbplay'> <method name='play'> <arg type='s' name='playinfo' direction='in'/> </method> <method name='stop'/> <method name='exit'/> </interface> </node> """ def play(self, playinfo): player.play(playinfo) def stop(self): player.stop() def exit(self): player.exit() loop.quit() bus = SessionBus() bus.publish("github.zhangn1985.dbplay", DBUSPlayerService()) loop.run()
print('TestCharacteristic Read: ' + repr(self.Value)) return self.Value def WriteValue(self, value, options): valueString = "" for i in range(0, len(value)): valueString += str(value[i]) print('TestCharacteristic on was written : ' + valueString) self.Value = value self.ValueString = valueString sessionBus = SessionBus() sessionBus.publish( 'org.bluez.example.advertisement', Advertisement()) # we are only allowed to publish on the Session Bus sessionBus.publish('org.bluez.example.service0', Service()) sessionBus.publish('org.bluez.example.service0.characteristic0', Characteristic()) #sessionBus.request_name('org.bluez.example.application',"/") sessionBus.publish('org.bluez.example.application', Application()) appBus = systemBus.get('org.freedesktop.DBus', '/org/bluez/example/application') advBus = sessionBus.get('org.freedesktop.DBus', '/org/bluez/example/advertisement') # help(advBus)
if not self.is_running: self.next_call += self.interval self._timer = threading.Timer(self.next_call - time.time(), self._run) self._timer.start() self.is_running = True def stop(self): self._timer.cancel() self.is_running = False if __name__=="__main__": # Launch the server # Use pydbus to establish a session gdbus. Rather than system gdbus # TODO: Use try/except, etc. in case bus already exists. e.g. bus.get(BUS) bus = SessionBus() bus.publish(BUS, DBusService()) # Start the repeating timer. It auto-starts, no need of rt.start() # RepeatedTimer(period between function calls, function()) rt = RepeatedTimer(period, timer_event) # Enable R-Pi channel to perform callbacks on detection of a pulse. if not simulated_pulse: #GPIO.add_event_detect(channel, GPIO.RISING, callback=pulse_callback, # bouncetime=1) GPIO.add_event_detect(channel, GPIO.FALLING, callback=pulse_callback, bouncetime=1) print("server running...") try: loop.run() except KeyboardInterrupt:
<property name="Foo" type="s" access="read"/> <property name="Bar" type="s" access="write"/> <method name='Quit'/> </interface> </node> ''' def __init__(self): self.Foo = "foo" self.Foobar = "foobar" def Quit(self): loop.quit() bus = SessionBus() with bus.publish("net.lew21.pydbus.tests.publish_properties", TestObject()): remote = bus.get("net.lew21.pydbus.tests.publish_properties") remote_iface = remote['net.lew21.pydbus.tests.publish_properties'] def t1_func(): for obj in [remote, remote_iface]: assert(obj.Foo == "foo") assert(obj.Foobar == "foobar") obj.Foobar = "barfoo" assert(obj.Foobar == "barfoo") obj.Foobar = "foobar" assert(obj.Foobar == "foobar") obj.Bar = "rab" remote.Foobar = "barfoo"
''' def __init__(self, id): self.id = id def HelloWorld(self, a, b): res = self.id + ": " + a + str(b) global done done += 1 if done == 2: loop.quit() print(res) return res bus = SessionBus() with bus.publish("net.lew21.pydbus.Test", TestObject("Main"), ("Lol", TestObject("Lol"))): remoteMain = bus.get("net.lew21.pydbus.Test") remoteLol = bus.get("net.lew21.pydbus.Test", "Lol") def t1_func(): print(remoteMain.HelloWorld("t", 1)) def t2_func(): print(remoteLol.HelloWorld("t", 2)) t1 = Thread(None, t1_func) t2 = Thread(None, t2_func) t1.daemon = True t2.daemon = True def handle_timeout():
<arg type="n" name="connectionState" direction="out"/> </signal> <signal name="SourceNotification"> <arg type="q" name="sourceID" direction="out"/> <arg type="n" name="type" direction="out"/> <!-- am_notification_e type; int16_t value; --> <arg type="n" name="value" direction="out"/> <!-- am_notification_e type; int16_t value; --> </signal> </interface> </node> """ MainConnectionStateChanged = signal() SourceNotification = signal() def Connect(self, sourceId, sinkId): print("LG AVN DBus Server - method name: Connect, sourceId: " + str(sourceId) + ", sinkId: " + str(sinkId)) self.MainConnectionStateChanged(1, 1) self.SourceNotification(123, 0, 1) return (0, 1) def Disconnect(self, s): print("LG AVN DBus Server - method name: Disconnect" + ", parameters: " + s) return (0) bus = SessionBus() bus.publish("org.genivi.audiomanager", LgAvnAudioManagerService(), ("commandinterface", LgAvnAudioManagerService())) loop = GLib.MainLoop() loop.run()