def dbus_receiver(): """ Start Qt loop that loads messages from Pidgin. :return: [no return value] """ DBusQtMainLoop(set_as_default=True) bus = SessionBus() bus.add_signal_receiver(pidgin_to_rxm_queue, dbus_interface="im.pidgin.purple.PurpleInterface", signal_name="ReceivedImMsg")
class Vibra_Plugin(Plugin): def __init__(self): DBusGMainLoop(set_as_default=True) self.bus = SystemBus() self.sessionbus = SessionBus() try: self.mce = self.bus.get_object("com.nokia.mce", "/com/nokia/mce") except DBusException: warning("Nokia MCE not found. Vibra is disabled\n") return self.profiled = self.sessionbus.get_object("com.nokia.profiled", "/com/nokia/profiled") self.sessionbus.add_signal_receiver( self.profile_changed_handler, "profile_changed", "com.nokia.profiled", "com.nokia.profiled", "/com/nokia/profiled", ) profile = self.profiled.get_profile(dbus_interface="com.nokia.profiled") self.get_vibra_enabled(profile) self.register_plugin(PLUGIN_TYPE_VIBRA) def ready(self): self.notification = get_plugin_by_type(PLUGIN_TYPE_NOTIFICATION) sendfile = get_plugin_by_type(PLUGIN_TYPE_SEND_FILE) sendfile.receive_cb.append(self.file_receive) def get_vibra_enabled(self, profile): self.enabled = ( self.profiled.get_value(profile, "vibrating.alert.enabled", dbus_interface="com.nokia.profiled") == "On" ) debug("Vibra enabled: %s\n" % self.enabled) def profile_changed_handler(self, foo, bar, profile, *args): self.get_vibra_enabled(profile) def vibrate(self): if self.enabled: self.mce.req_vibrator_pattern_activate("PatternChatAndEmail", dbus_interface="com.nokia.mce.request") def file_receive(self, cb, user, fname): self.vibrate() def user_appears(self, user): if user.get("friend"): self.vibrate()
def run_client(self): bus = SessionBus() obj = bus.get_object(CROSS_TEST_BUS_NAME, CROSS_TEST_PATH) self.obj = obj self.run_synchronous_tests(obj) # Signal tests logger.info("Binding signal handler for Triggered") # FIXME: doesn't seem to work when going via the Interface method # FIXME: should be possible to ask the proxy object for its # bus name bus.add_signal_receiver(self.triggered_cb, 'Triggered', INTERFACE_SIGNAL_TESTS, CROSS_TEST_BUS_NAME, path_keyword='sender_path') logger.info("method/signal: Triggering signal") self.expected.add('%s.Trigger' % INTERFACE_TESTS) Interface(obj, INTERFACE_TESTS).Trigger(u'/Where/Ever', dbus.UInt64(42), reply_handler=self.trigger_returned_cb, error_handler=self.trigger_error_handler)
def run_client(self): bus = SessionBus() obj = bus.get_object(CROSS_TEST_BUS_NAME, CROSS_TEST_PATH) self.obj = obj self.run_synchronous_tests(obj) # Signal tests logger.info("Binding signal handler for Triggered") # FIXME: doesn't seem to work when going via the Interface method # FIXME: should be possible to ask the proxy object for its # bus name bus.add_signal_receiver(self.triggered_cb, 'Triggered', INTERFACE_SIGNAL_TESTS, CROSS_TEST_BUS_NAME, path_keyword='sender_path') logger.info("method/signal: Triggering signal") self.expected.add('%s.Trigger' % INTERFACE_TESTS) Interface(obj, INTERFACE_TESTS).Trigger( '/Where/Ever', dbus.UInt64(42), reply_handler=self.trigger_returned_cb, error_handler=self.trigger_error_handler)
class SSTrigger: def __init__(self): DBusGMainLoop(set_as_default=True) self.mem='ActiveChanged' self.dest='org.gnome.ScreenSaver' self.bus=SessionBus() self.loop=MainLoop() self.bus.add_signal_receiver(self.catch,self.mem,self.dest) def catch(self,ssOn): conn = mdb.connect('localhost', 'root','mysql_password', 'working_time'); cursor = conn.cursor() now = datetime.datetime.now() if ssOn == 1: #Screensaver turned on sql = "UPDATE working_time SET end='%s' WHERE date='%s' AND end='0:0'"\ %(now.strftime("%H:%M"),now.strftime("%Y-%m-%d")) #logging.info(" sql=%s "%sql) logging.info("end=%s" % str(now.strftime("%H:%M"))) res = cursor.execute(sql) if conn.affected_rows() != 1: cursor.execute("SELECT * from working_time") if cursor.rowcount != 1: # ignore error if it is a very first record in database logging.error("ERROR!!! It should be only one (the last) record with end=0:0") else: #Screensaver turned off sql = "INSERT INTO working_time (date, start, end) VALUES('%s','%s','%s')"\ %(now.strftime("%Y-%m-%d"),now.strftime("%H:%M"),"0:0") #logging.info(" sql=%s "%sql) res=cursor.execute(sql) logging.info("start=%s "%now.strftime("%H:%M")) os.system("xmessage -nearmouse 'If you were out then start: log_working_time.py break'") conn.commit() cursor.close() conn.close()
class _ISkypeAPI(_ISkypeAPIBase): def __init__(self, handler, opts): _ISkypeAPIBase.__init__(self, opts) self.RegisterHandler(handler) self.skype_in = self.skype_out = self.dbus_name_owner_watch = None self.bus = opts.pop('Bus', None) try: mainloop = opts.pop('MainLoop') if self.bus is not None: raise TypeError( 'Bus and MainLoop cannot be used at the same time!') except KeyError: if self.bus is None: import dbus.mainloop.glib import gobject gobject.threads_init() dbus.mainloop.glib.threads_init() mainloop = dbus.mainloop.glib.DBusGMainLoop() self.mainloop = gobject.MainLoop() if self.bus is None: from dbus import SessionBus self.bus = SessionBus(private=True, mainloop=mainloop) if opts: raise TypeError('Unexpected parameter(s): %s' % ', '.join(opts.keys())) def run(self): self.DebugPrint('thread started') if hasattr(self, 'mainloop'): self.mainloop.run() self.DebugPrint('thread finished') def Close(self): if hasattr(self, 'mainloop'): self.mainloop.quit() self.skype_in = self.skype_out = None if self.dbus_name_owner_watch is not None: self.bus.remove_signal_receiver(self.dbus_name_owner_watch) self.dbus_name_owner_watch = None self.DebugPrint('closed') def SetFriendlyName(self, FriendlyName): self.FriendlyName = FriendlyName if self.skype_out: self.SendCommand(ICommand(-1, 'NAME %s' % FriendlyName)) def StartWatcher(self): self.dbus_name_owner_watch = self.bus.add_signal_receiver( self.dbus_name_owner_changed, 'NameOwnerChanged', 'org.freedesktop.DBus', 'org.freedesktop.DBus', '/org/freedesktop/DBus', arg0='com.Skype.API') def __Attach_ftimeout(self): self.wait = False def Attach(self, Timeout=30000, Wait=True): try: if not self.isAlive(): self.StartWatcher() self.start() except AssertionError: pass try: self.wait = True t = threading.Timer(Timeout / 1000.0, self.__Attach_ftimeout) if Wait: t.start() while self.wait: if not Wait: self.wait = False try: if not self.skype_out: self.skype_out = self.bus.get_object( 'com.Skype.API', '/com/Skype') if not self.skype_in: self.skype_in = _SkypeNotifyCallback( self.bus, self.notify) except dbus.DBusException: if not Wait: break time.sleep(1.0) else: break else: raise ISkypeAPIError('Skype attach timeout') finally: t.cancel() c = ICommand(-1, 'NAME %s' % self.FriendlyName, '', True, Timeout) if self.skype_out: self.SendCommand(c) if c.Reply != 'OK': self.skype_out = None self.SetAttachmentStatus(apiAttachRefused) return self.SendCommand(ICommand(-1, 'PROTOCOL %s' % self.Protocol)) self.SetAttachmentStatus(apiAttachSuccess) def IsRunning(self): try: self.bus.get_object('com.Skype.API', '/com/Skype') return True except dbus.DBusException: return False def Start(self, Minimized=False, Nosplash=False): # options are not supported as of Skype 1.4 Beta for Linux if not self.IsRunning(): import os if os.fork() == 0: # we're child os.setsid() os.execlp('skype') def Shutdown(self): import os from signal import SIGINT fh = os.popen('ps -o %p --no-heading -C skype') pid = fh.readline().strip() fh.close() if pid: os.kill(int(pid), SIGINT) self.skype_in = self.skype_out = None def SendCommand(self, Command): if not self.skype_out: self.Attach(Command.Timeout) self.CommandsStackPush(Command) self.CallHandler('send', Command) com = u'#%d %s' % (Command.Id, Command.Command) self.DebugPrint('->', repr(com)) if Command.Blocking: Command._event = event = threading.Event() else: Command._timer = timer = threading.Timer(Command.Timeout / 1000.0, self.CommandsStackPop, (Command.Id, )) try: result = self.skype_out.Invoke(com) except dbus.DBusException, err: raise ISkypeAPIError(str(err)) if result.startswith(u'#%d ' % Command.Id): self.notify(result) if Command.Blocking: event.wait(Command.Timeout / 1000.0) if not event.isSet(): raise ISkypeAPIError('Skype command timeout') else: timer.start()
class Server(SingleTestsImpl, TestsImpl, SignalTestsImpl): def triggered_by_client(self, parameter1, parameter2, sender, sender_path): # Called when the client emits TestSignals.Trigger from any object. logger.info('signal/callback: Triggered by client (%s:%s): (%r,%r)', sender, sender_path, parameter1, parameter2) tested_things.add(INTERFACE_SIGNAL_TESTS + '.Trigger') dbus.Interface(dbus.SessionBus().get_object(sender, sender_path), INTERFACE_CALLBACK_TESTS).Response( parameter1, parameter2) logger.info('signal/callback: Sent Response') if __name__ == '__main__': bus = SessionBus() bus_name = BusName(CROSS_TEST_BUS_NAME, bus=bus) loop = gobject.MainLoop() obj = Server(bus_name, CROSS_TEST_PATH, loop.quit) objects[CROSS_TEST_PATH] = obj bus.add_signal_receiver(obj.triggered_by_client, signal_name='Trigger', dbus_interface=INTERFACE_SIGNAL_TESTS, named_service=None, path=None, sender_keyword='sender', path_keyword='sender_path', utf8_strings=True) logger.info("running...") loop.run() logger.info("main loop exited.")
class Server(SingleTestsImpl, TestsImpl, SignalTestsImpl): def triggered_by_client(self, parameter1, parameter2, sender, sender_path): # Called when the client emits TestSignals.Trigger from any object. logger.info('signal/callback: Triggered by client (%s:%s): (%r,%r)', sender, sender_path, parameter1, parameter2) tested_things.add(INTERFACE_SIGNAL_TESTS + '.Trigger') dbus.Interface(dbus.SessionBus().get_object(sender, sender_path), INTERFACE_CALLBACK_TESTS).Response(parameter1, parameter2) logger.info('signal/callback: Sent Response') if __name__ == '__main__': bus = SessionBus() bus_name = BusName(CROSS_TEST_BUS_NAME, bus=bus) loop = gobject.MainLoop() obj = Server(bus_name, CROSS_TEST_PATH, loop.quit) objects[CROSS_TEST_PATH] = obj bus.add_signal_receiver(obj.triggered_by_client, signal_name='Trigger', dbus_interface=INTERFACE_SIGNAL_TESTS, named_service=None, path=None, sender_keyword='sender', path_keyword='sender_path', utf8_strings=True) logger.info("running...") loop.run() logger.info("main loop exited.")
class _ISkypeAPI(_ISkypeAPIBase): def __init__(self, handler, opts): _ISkypeAPIBase.__init__(self, opts) self.RegisterHandler(handler) self.skype_in = self.skype_out = self.dbus_name_owner_watch = None self.bus = opts.pop('Bus', None) try: mainloop = opts.pop('MainLoop') if self.bus is not None: raise TypeError('Bus and MainLoop cannot be used at the same time!') except KeyError: if self.bus is None: import dbus.mainloop.glib import gobject gobject.threads_init() dbus.mainloop.glib.threads_init() mainloop = dbus.mainloop.glib.DBusGMainLoop() self.mainloop = gobject.MainLoop() if self.bus is None: from dbus import SessionBus self.bus = SessionBus(private=True, mainloop=mainloop) if opts: raise TypeError('Unexpected parameter(s): %s' % ', '.join(opts.keys())) def run(self): self.DebugPrint('thread started') if hasattr(self, 'mainloop'): self.mainloop.run() self.DebugPrint('thread finished') def Close(self): if hasattr(self, 'mainloop'): self.mainloop.quit() self.skype_in = self.skype_out = None if self.dbus_name_owner_watch is not None: self.bus.remove_signal_receiver(self.dbus_name_owner_watch) self.dbus_name_owner_watch = None self.DebugPrint('closed') def SetFriendlyName(self, FriendlyName): self.FriendlyName = FriendlyName if self.skype_out: self.SendCommand(ICommand(-1, 'NAME %s' % FriendlyName)) def StartWatcher(self): self.dbus_name_owner_watch = self.bus.add_signal_receiver(self.dbus_name_owner_changed, 'NameOwnerChanged', 'org.freedesktop.DBus', 'org.freedesktop.DBus', '/org/freedesktop/DBus', arg0='com.Skype.API') def __Attach_ftimeout(self): self.wait = False def Attach(self, Timeout=30000, Wait=True): try: if not self.isAlive(): self.StartWatcher() self.start() except AssertionError: pass try: self.wait = True t = threading.Timer(Timeout / 1000.0, self.__Attach_ftimeout) if Wait: t.start() while self.wait: if not Wait: self.wait = False try: if not self.skype_out: self.skype_out = self.bus.get_object('com.Skype.API', '/com/Skype') if not self.skype_in: self.skype_in = _SkypeNotifyCallback(self.bus, self.notify) except dbus.DBusException: if not Wait: break time.sleep(1.0) else: break else: raise ISkypeAPIError('Skype attach timeout') finally: t.cancel() c = ICommand(-1, 'NAME %s' % self.FriendlyName, '', True, Timeout) if self.skype_out: self.SendCommand(c) if c.Reply != 'OK': self.skype_out = None self.SetAttachmentStatus(apiAttachRefused) return self.SendCommand(ICommand(-1, 'PROTOCOL %s' % self.Protocol)) self.SetAttachmentStatus(apiAttachSuccess) def IsRunning(self): try: self.bus.get_object('com.Skype.API', '/com/Skype') return True except dbus.DBusException: return False def Start(self, Minimized=False, Nosplash=False): # options are not supported as of Skype 1.4 Beta for Linux if not self.IsRunning(): import os if os.fork() == 0: # we're child os.setsid() os.execlp('skype') def Shutdown(self): import os from signal import SIGINT fh = os.popen('ps -o %p --no-heading -C skype') pid = fh.readline().strip() fh.close() if pid: os.kill(int(pid), SIGINT) self.skype_in = self.skype_out = None def SendCommand(self, Command): if not self.skype_out: self.Attach(Command.Timeout) self.CommandsStackPush(Command) self.CallHandler('send', Command) com = u'#%d %s' % (Command.Id, Command.Command) self.DebugPrint('->', repr(com)) if Command.Blocking: Command._event = event = threading.Event() else: Command._timer = timer = threading.Timer(Command.Timeout / 1000.0, self.CommandsStackPop, (Command.Id,)) try: result = self.skype_out.Invoke(com) except dbus.DBusException, err: raise ISkypeAPIError(str(err)) if result.startswith(u'#%d ' % Command.Id): self.notify(result) if Command.Blocking: event.wait(Command.Timeout / 1000.0) if not event.isSet(): raise ISkypeAPIError('Skype command timeout') else: timer.start()
class Py3status: """ """ # available configuration parameters button_next = None button_next_player = None button_prev_player = None button_previous = None button_stop = None button_switch_to_top_player = None button_toggle = 1 cache_timeout = 0.5 format = "[{artist} - ][{title}] {previous} {toggle} {next}" format_none = "no player running" icon_next = "\u25b9" icon_pause = "\u25eb" icon_play = "\u25b7" icon_previous = "\u25c3" icon_stop = "\u25a1" max_width = None player_hide_non_canplay = [] player_priority = [] state_pause = "\u25eb" state_play = "\u25b7" state_stop = "\u25a1" def post_config_hook(self): if self.py3.is_gevent(): raise Exception(STRING_GEVENT) self._name_owner_change_match = None self._kill = False self._mpris_players: dict[Player] = {} self._identity_cache = {} self._identity_index = {} self._priority_cache = {} self._player: [Player, None] = None self._tries = 0 self._empty_response = { "album": None, "artist": None, "length": None, "title": None, "nowplaying": None, "time": None, "state": None, "player": None, # for debugging ;p "full_name": None, } self._states = { "pause": { "action": "Pause", "clickable": "CanPause", "icon": self.icon_pause, "inactive": [STATE.Stopped, STATE.Paused], }, "play": { "action": "Play", "clickable": "CanPlay", "icon": self.icon_play, "inactive": [STATE.Playing], }, "stop": { "action": "Stop", "clickable": "CanControl", "icon": self.icon_stop, "inactive": [STATE.Stopped], }, "next": { "action": "Next", "clickable": "CanGoNext", "icon": self.icon_next, }, "previous": { "action": "Previous", "clickable": "CanGoPrevious", "icon": self.icon_previous, }, "toggle": { "action": "PlayPause", "clickable": "CanPause", # Not used, but it will be set dynamically with player state map. "icon": None, }, } self._state_icon_color_map = { STATE.Playing: { "state_icon": self.state_play, "color": self.py3.COLOR_PLAYING or self.py3.COLOR_GOOD, "toggle_icon": self.state_pause, "cached_until": self.cache_timeout, }, STATE.Paused: { "state_icon": self.state_pause, "color": self.py3.COLOR_PAUSED or self.py3.COLOR_DEGRADED, "toggle_icon": self.state_play, "cached_until": self.py3.CACHE_FOREVER, }, STATE.Stopped: { "state_icon": self.state_stop, "color": self.py3.COLOR_STOPPED or self.py3.COLOR_BAD, "toggle_icon": self.state_play, "cached_until": self.py3.CACHE_FOREVER, }, } self._color_active = self.py3.COLOR_CONTROL_ACTIVE or self.py3.COLOR_GOOD self._color_inactive = self.py3.COLOR_CONTROL_INACTIVE or self.py3.COLOR_BAD self._format_contains_metadata = False self._metadata_keys = ["album", "artist", "title", "nowplaying", "length"] for key in self._metadata_keys: if self.py3.format_contains(self.format, key): self._format_contains_metadata = True break self._format_contains_control_buttons = False self._used_can_properties = [] for key, value in self._states.items(): if self.py3.format_contains(self.format, key): self._format_contains_control_buttons = True self._used_can_properties.append(value["clickable"]) if ( len(self.player_hide_non_canplay) and "CanPlay" not in self._used_can_properties ): self._used_can_properties.append("CanPlay") self._format_contains_time = self.py3.format_contains(self.format, "time") self._button_cache_flush = None if 2 not in [ self.button_next, self.button_next_player, self.button_prev_player, self.button_previous, self.button_stop, self.button_switch_to_top_player, self.button_toggle, ]: self._button_cache_flush = 2 if self.player_priority: try: self._random_player_priority = self.player_priority.index("*") except ValueError: self._random_player_priority = False else: self._random_player_priority = 0 # start last self._dbus_loop = DBusGMainLoop() self._dbus = SessionBus(mainloop=self._dbus_loop) self._start_listener() def _start_loop(self): self._loop = GLib.MainLoop() GLib.timeout_add(1000, self._timeout) try: self._loop.run() except KeyboardInterrupt: # This branch is only needed for the test mode self._kill = True @staticmethod def _is_mediaplayer_interface(player_id): return player_id.startswith(Interfaces.MEDIA_PLAYER) def _dbus_name_owner_changed(self, name, old_owner, new_owner): if not self._is_mediaplayer_interface(name): return if new_owner: self._add_player(name) if old_owner: self._remove_player(name) self._set_player() def _set_player(self, update=True): """ Sort the current players into priority order and set self._player Players are ordered by working state, then by preference supplied by user and finally by instance if a player has more than one running. """ players = [] for name, player in self._mpris_players.items(): player_priority_tuple = player.priority_tuple if player_priority_tuple: players.append(player_priority_tuple) new_top_player_id = None if players: new_top_player_id = sorted(players)[0][3] self._set_data_entry_point_by_name_key(new_top_player_id, update) def _player_on_change(self, interface_name, data, invalidated_properties, sender): """ Monitor a player and update its status. """ pass def _add_player(self, player_id): """ Add player to mpris_players """ player_id_parts_list = player_id.split(".") name_from_id = player_id_parts_list[3] identity = self._identity_cache.get(name_from_id) if not identity: dMediaPlayer = dMediaPlayer2(dbus_interface_info={"dbus_uri": player_id}) identity = str(dMediaPlayer.Identity) self._identity_cache[name_from_id] = identity if self.player_priority: # Expected value: numeric / False, None is cache miss. priority = self._priority_cache.get(name_from_id, None) if priority is None: for i, _player in enumerate(self.player_priority): if _player == name_from_id or _player == identity: priority = i break if priority is None: priority = self._random_player_priority self._priority_cache[identity] = priority if not isinstance(priority, int): return else: priority = 0 identity_index = self._identity_index.get(identity, 0) if identity_index: self._identity_index[identity] += 1 else: self._identity_index[identity] = 1 name_with_instance = ".".join(player_id_parts_list[3:]) player = Player( self, player_id=player_id, name_from_id=name_from_id, name_with_instance=name_with_instance, name_priority=priority, identity=identity, identity_index=identity_index, ) self._mpris_players[player_id] = player def _remove_player(self, player_id): """ Remove player from mpris_players """ if self._mpris_players.get(player_id): del self._mpris_players[player_id] def _get_players(self): for player in get_players_uri(): try: # str(player) helps avoid to use dbus.Str(*) as dict key self._add_player(str(player)) except DBusException: continue self._set_player() def _start_listener(self): self._get_players() self._name_owner_change_match = self._dbus.add_signal_receiver( handler_function=self._dbus_name_owner_changed, dbus_interface="org.freedesktop.DBus", signal_name="NameOwnerChanged", ) # Start listening things after initiating players. t = Thread(target=self._start_loop) t.daemon = True t.start() def _timeout(self): if self._kill: self._loop.quit() sys.exit(0) def _set_data_entry_point_by_name_key(self, new_active_player_key, update=True): if self._player is None or new_active_player_key != self._player.id: self._player = self._mpris_players.get(new_active_player_key, None) if self._player: self._player.prepare_output() if update: self.py3.update() def kill(self): self._kill = True if self._name_owner_change_match: self.parent._dbus._clean_up_signal_match(self._name_owner_change_match) def mpris(self): """ Get the current output format and return it. """ if self._kill: raise KeyboardInterrupt current_player = self._player cached_until = self.py3.CACHE_FOREVER color = self.py3.COLOR_BAD if current_player: current_player_id = str(current_player.id) current_state_map = current_player.state_map data = current_player.data if current_player_id == self._player.id: if self._format_contains_time: cached_until = self.py3.time_in( seconds=current_state_map.get("cached_until"), sync_to=0 ) placeholders = {"state": current_state_map["state_icon"]} color = current_state_map["color"] composite = self.py3.safe_format( self.format, dict(self._empty_response, **placeholders, **data), max_width=self.max_width, ) else: # The player changed during our processing # This is usually due to something like a player being killed # whilst we are checking its details # Retry but limit the number of attempts self._tries += 1 if self._tries < 3: return self.mpris() # Max retries hit we need to output something return { # Can't decide what is good time to restart 3 retry cycle "cached_until": self.py3.time_in(10), "color": self.py3.COLOR_BAD, "composite": [ { "full_text": "Something went wrong", "color": self.py3.COLOR_BAD, } ], } else: composite = [{"full_text": self.format_none, "color": color}] # we are outputting so reset tries self._tries = 0 response = { "cached_until": cached_until, "color": color, "composite": composite, } return response def on_click(self, event): """ Handles click events """ index = event["index"] button = event["button"] if not self._player: return if button == self._button_cache_flush: self._player.metadata = None self._player.state = None elif index not in self._states: if button == self.button_toggle: return self._player.send_mpris_action("toggle") elif button == self.button_stop: return self._player.send_mpris_action("stop") elif button == self.button_next: return self._player.send_mpris_action("next") elif button == self.button_previous: return self._player.send_mpris_action("previous") elif button == self.button_switch_to_top_player: return self._set_player(update=False) elif button == self.button_prev_player or button == self.button_next_player: switchable_players = [] order_asc = button == self.button_next_player current_player_index = False for key, player in self._mpris_players.items(): if player.state == self._player.state and not player.hide: if not current_player_index: if player.id == self._player.id: current_player_index = len(switchable_players) if order_asc: continue switchable_players.append(key) if current_player_index: if order_asc: break else: if current_player_index != 0: break if len(switchable_players): try: if order_asc: next_index = current_player_index % len(switchable_players) else: next_index = (current_player_index - 1) % len( switchable_players ) self._set_data_entry_point_by_name_key( switchable_players[next_index], update=False ) except KeyError: pass else: return elif button == 1: self._player.send_mpris_action(index)
from dbus import SessionBus, Interface import gobject from dbus.mainloop.glib import DBusGMainLoop def handler(*args, **kwargs): if 'RemoteVolumeMonitor' in kwargs[ 'dbus_interface'] and 'VolumeAdded' in kwargs['DriveChanged']: print "-" * 30 print kwargs print args lproperties = [] lproperties = args for prop in lproperties: print prop DBusGMainLoop(set_as_default=True) bus = SessionBus() bus.add_signal_receiver(handler_function=handler, interface_keyword="dbus_interface", member_keyword="DriveChanged", dbus_interface="org.gtk.Private.RemoteVolumeMonitor") # Start Loop loop = gobject.MainLoop() loop.run()
class SSTrigger: # FORMAT MESSAGE : [START/STOP] [X] [Y] MAIN_DIR = "/usr/bin/ProActiveScreenSaver" start = 'START' stop = 'STOP' #log path of proxy config_file = 'log/proxy.txt' #named pipe path pipe_path = "/tmp/ss.pipe" #Initialize dbus def __init__(self): DBusGMainLoop(set_as_default=True) self.mem='ActiveChanged' self.dest='org.gnome.ScreenSaver' self.bus=SessionBus() self.loop=MainLoop() self.bus.add_signal_receiver(self.catch,self.mem,self.dest) # log method def writeLOG(self, txt): f = open( self.MAIN_DIR + "/" + self.config_file ,'a') f.write( txt ) f.close() # receive signal and write message on dbus def catch(self,ssOn): screen = commands.getoutput("xrandr | grep \* | tr -s ' ' | cut -d' ' -f2") screen_res = screen.split('x') #Screensize length = screen_res[0] width = screen_res[1] if ssOn == 1: #Screensaver turned on data = self.start + " " + length + " " + width pipe = open(self.pipe_path, 'w') pipe.write(data) pipe.close() self.writeLOG(time.ctime() + "proxy has send : " + data + "\n") print "proxy has send : " + data else: #Screensaver turned off data = self.stop + " " + length + " " + width pipe = open(self.pipe_path, 'w') pipe.write(data) pipe.close() self.writeLOG(time.ctime() + "proxy has send : " + data + "\n") print "proxy has send : " + data
tested_things.add(INTERFACE_SIGNAL_TESTS + ".Trigger") dbus.Interface(dbus.SessionBus().get_object(sender, sender_path), INTERFACE_CALLBACK_TESTS).Response( parameter1, parameter2 ) logger.info("signal/callback: Sent Response") if __name__ == "__main__": bus = SessionBus() bus_name = BusName(CROSS_TEST_BUS_NAME, bus=bus) loop = gobject.MainLoop() obj = Server(bus_name, CROSS_TEST_PATH, loop.quit) objects[CROSS_TEST_PATH] = obj kwargs = {} if is_py2: kwargs["utf8_strings"] = True bus.add_signal_receiver( obj.triggered_by_client, signal_name="Trigger", dbus_interface=INTERFACE_SIGNAL_TESTS, named_service=None, path=None, sender_keyword="sender", path_keyword="sender_path", **kwargs ) logger.info("running...") loop.run() logger.info("main loop exited.")