def __jabber_server_changed_cb(self, settings, key): logging.debug('__jabber_server_changed_cb') bus = dbus.Bus() account = bus.get_object(ACCOUNT_MANAGER_SERVICE, self._server_account.object_path) server = settings.get_string('jabber-server') account_id = self._get_jabber_account_id() params_needing_reconnect = account.UpdateParameters( { 'server': server, 'account': account_id, 'register': True }, dbus.Array([], 's'), dbus_interface=ACCOUNT) if params_needing_reconnect: account.Reconnect() self._update_jid()
def __init__(self, bus=None): GObject.GObject.__init__(self) if bus is None: self.bus = dbus.Bus() else: self.bus = bus # D-Bus path -> Connection self._connections = {} self.bus.add_signal_receiver(self._status_changed_cb, dbus_interface=CONN_INTERFACE, signal_name='StatusChanged', path_keyword='path') bus_object = self.bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus') bus_object.ListNames(dbus_interface='org.freedesktop.DBus', reply_handler=self.__get_services_reply_cb, error_handler=self.__error_handler_cb)
def _ensure_server_account(self, account_paths): bus = dbus.Bus() for account_path in account_paths: if 'gabble' in account_path: obj_acct_mgr = bus.get_object(ACCOUNT_MANAGER_SERVICE, account_path) properties = obj_acct_mgr.Get(ACCOUNT, 'Parameters') if properties.has_key( "server") and properties["server"] == self._server: print("Enabiling account_path = %s, server = %s", account_path, self._server) account = _Account(account_path) account.enable() return account params = { 'account': self._get_jabber_account_id(), 'password': self._password, 'server': self._server, 'resource': 'sugar', 'require-encryption': True, 'ignore-ssl-errors': True, 'register': self._register, 'old-ssl': True, 'port': dbus.UInt32(self._port), } properties = { ACCOUNT + '.Enabled': True, ACCOUNT + '.Nickname': self._nickname, ACCOUNT + '.ConnectAutomatically': True, } obj = bus.get_object(ACCOUNT_MANAGER_SERVICE, ACCOUNT_MANAGER_PATH) account_manager = dbus.Interface(obj, ACCOUNT_MANAGER) account_path = account_manager.CreateAccount('gabble', 'jabber', 'jabber', params, properties) return _Account(account_path)
def testBusNameCreation(self): print('\n******** Testing BusName creation ********') test = [('org.freedesktop.DBus.Python.TestName', True), ('org.freedesktop.DBus.Python.TestName', True), ('org.freedesktop.DBus.Python.InvalidName&^*%$', False)] # Do some more intelligent handling/testing of queueing vs success? # ('org.freedesktop.DBus.TestSuitePythonService', False)] # For some reason this actually succeeds # ('org.freedesktop.DBus', False)] # make a method call to ensure the test service is active self.iface.Echo("foo") names = {} for (name, succeed) in test: try: print("requesting %s" % name) busname = dbus.service.BusName(name, dbus.SessionBus()) except Exception as e: print("%s:\n%s" % (e.__class__, e)) self.assertTrue(not succeed, 'did not expect registering bus name %s to fail' % name) else: print(busname) self.assertTrue(succeed, 'expected registering bus name %s to fail'% name) if name in names: self.assertTrue(names[name] == busname, 'got a new instance for same name %s' % name) print("instance of %s re-used, good!" % name) else: names[name] = busname del busname print() del names bus = dbus.Bus() ret = bus.name_has_owner('org.freedesktop.DBus.Python.TestName') self.assertTrue(not ret, 'deleting reference failed to release BusName org.freedesktop.DBus.Python.TestName')
def _ensure_server_account(self, account_paths): for account_path in account_paths: if 'gabble' in account_path: logging.debug('Already have a Gabble account') account = _Account(account_path) account.enable() return account logging.debug('Still dont have a Gabble account, creating one') nick = self._settings_user.get_string('nick') server = self._settings_collaboration.get_string('jabber-server') key_hash = get_profile().privkey_hash params = { 'account': self._get_jabber_account_id(), 'password': key_hash, 'server': server, 'resource': 'sugar', 'require-encryption': True, 'ignore-ssl-errors': True, 'register': True, 'old-ssl': True, 'port': dbus.UInt32(5223), } properties = { ACCOUNT + '.Enabled': True, ACCOUNT + '.Nickname': nick, ACCOUNT + '.ConnectAutomatically': True, } bus = dbus.Bus() obj = bus.get_object(ACCOUNT_MANAGER_SERVICE, ACCOUNT_MANAGER_PATH) account_manager = dbus.Interface(obj, ACCOUNT_MANAGER) account_path = account_manager.CreateAccount('gabble', 'jabber', 'jabber', params, properties) return _Account(account_path)
def _create_channel(self, file_size): object_path, properties_ = self._conn.CreateChannel(dbus.Dictionary({ CHANNEL + '.ChannelType': CHANNEL_TYPE_FILE_TRANSFER, CHANNEL + '.TargetHandleType': CONNECTION_HANDLE_TYPE_CONTACT, CHANNEL + '.TargetHandle': self.buddy.contact_handle, CHANNEL_TYPE_FILE_TRANSFER + '.Filename': self._filename, CHANNEL_TYPE_FILE_TRANSFER + '.Description': self._description, CHANNEL_TYPE_FILE_TRANSFER + '.Size': file_size, CHANNEL_TYPE_FILE_TRANSFER + '.ContentType': self._mime, CHANNEL_TYPE_FILE_TRANSFER + '.InitialOffset': 0}, signature='sv')) channel = {} proxy = dbus.Bus().get_object(self._conn.bus_name, object_path) channel[PROPERTIES_IFACE] = dbus.Interface(proxy, PROPERTIES_IFACE) channel[CHANNEL] = dbus.Interface(proxy, CHANNEL) channel[CHANNEL_TYPE_FILE_TRANSFER] = dbus.Interface( proxy, CHANNEL_TYPE_FILE_TRANSFER) self.set_channel(channel) channel_file_transfer = self.channel[CHANNEL_TYPE_FILE_TRANSFER] self._socket_address = channel_file_transfer.ProvideFile( SOCKET_ADDRESS_TYPE_UNIX, SOCKET_ACCESS_CONTROL_LOCALHOST, '', byte_arrays=True)
def __nick_changed_cb(self, settings, key): logging.debug('__nick_changed_cb') nick = settings.get_string('nick') bus = dbus.Bus() server_obj = bus.get_object(ACCOUNT_MANAGER_SERVICE, self._server_account.object_path) server_obj.Set(ACCOUNT, 'Nickname', nick, dbus_interface=PROPERTIES_IFACE) link_local_obj = bus.get_object(ACCOUNT_MANAGER_SERVICE, self._link_local_account.object_path) link_local_obj.Set(ACCOUNT, 'Nickname', nick, dbus_interface=PROPERTIES_IFACE) params_needing_reconnect = link_local_obj.UpdateParameters( {'nickname': nick, 'published-name': self._get_published_name()}, dbus.Array([], 's'), dbus_interface=ACCOUNT) if params_needing_reconnect: link_local_obj.Reconnect() self._update_jid()
def __jabber_server_changed_cb(self, client, timestamp, entry, *extra): logging.debug('__jabber_server_changed_cb') bus = dbus.Bus() account = bus.get_object(ACCOUNT_MANAGER_SERVICE, self._server_account.object_path) server = client.get_string( '/desktop/sugar/collaboration/jabber_server') account_id = self._get_jabber_account_id() params_needing_reconnect = account.UpdateParameters( { 'server': server, 'account': account_id, 'register': True }, dbus.Array([], 's'), dbus_interface=ACCOUNT) if params_needing_reconnect: account.Reconnect() self._update_jid()
def __init__(self): self._interfaces = set([CLIENT, CLIENT_HANDLER, CLIENT_INTERFACE_REQUESTS, PROPERTIES_IFACE, CLIENT_APPROVER]) bus = dbus.Bus() bus_name = dbus.service.BusName(SUGAR_CLIENT_SERVICE, bus=bus) dbus.service.Object.__init__(self, bus_name, SUGAR_CLIENT_PATH) DBusProperties.__init__(self) self._implement_property_get(CLIENT, { 'Interfaces': lambda: list(self._interfaces), }) self._implement_property_get(CLIENT_HANDLER, { 'HandlerChannelFilter': self.__get_filters_handler_cb, }) self._implement_property_get(CLIENT_APPROVER, { 'ApproverChannelFilter': self.__get_filters_approver_cb, }) self.got_channel = dispatch.Signal() self.got_dispatch_operation = dispatch.Signal()
def get_plugin_service_obj(plugin_id, activate=True): """Return the dbus proxy object for our plugin if @activate, we will --exec-helper= the service """ plugin_id = plugin_id.split(".")[-1] service_name = "se.kaizer.kupfer.plugin.%s" % plugin_id interface_name = "se.kaizer.kupfer.plugin.%s" % plugin_id object_name = "/se/kaizer/kupfer/plugin/%s" % plugin_id try: bus = dbus.Bus() except dbus.DBusException: return None try: proxy_obj = bus.get_object(service_name, object_name) except dbus.DBusException as exc: if activate: service_id = "kupfer.plugin.%s.service" % plugin_id return utils.start_plugin_helper(service_id, True) return None proxy_iface = dbus.Interface(proxy_obj, interface_name) return proxy_iface
def main(): global bus, hal_service, hal_manager bus = dbus.Bus(dbus.Bus.TYPE_SYSTEM) hal_service = bus.get_service("org.freedesktop.Hal") hal_manager = hal_service.get_object("/org/freedesktop/Hal/Manager", "org.freedesktop.Hal.Manager") # gdl_changed will be invoked when the Global Device List is changed # per the hal spec bus.add_signal_receiver(gdl_changed, "org.freedesktop.Hal.Manager", "org.freedesktop.Hal", "/org/freedesktop/Hal/Manager") # Add listeners for all devices device_names = hal_manager.GetAllDevices() for name in device_names: bus.add_signal_receiver(device_changed, "org.freedesktop.Hal.Device", "org.freedesktop.Hal", name) print_devices() gtk.main()
def _one_to_one_connection_ready_cb(self, bus_name, channel, conn): '''Callback for Connection for one to one connection''' text_channel = {} text_proxy = dbus.Bus().get_object(bus_name, channel) text_channel[TelepathyGLib.IFACE_CHANNEL] = \ dbus.Interface(text_proxy, TelepathyGLib.IFACE_CHANNEL) text_channel[TelepathyGLib.IFACE_CHANNEL_TYPE_TEXT] = \ dbus.Interface(text_proxy, TelepathyGLib.IFACE_CHANNEL_TYPE_TEXT) text_channel[TelepathyGLib.IFACE_CHANNEL_INTERFACE_GROUP] = \ dbus.Interface( text_proxy, TelepathyGLib.IFACE_CHANNEL_INTERFACE_GROUP) self.text_channel = TextChannelWrapper(text_channel, conn) self.text_channel.set_received_callback(self._received_cb) self.text_channel.handle_pending_messages() self.text_channel.set_closed_callback( self._one_to_one_connection_closed_cb) self._chat_is_room = False self._alert(_('On-line'), _('Private chat.')) # XXX How do we detect the sender going offline? self._entry.set_sensitive(True) self._entry.props.placeholder_text = None self._entry.grab_focus()
def __init__(self): Gtk.HBox.__init__(self) self.set_border_width(int(style.DEFAULT_SPACING / 2.0)) self.set_spacing(style.DEFAULT_SPACING * 4) self._completion_level = 0 self._progressbar = None self._icon = None self._battery_props = None try: bus = dbus.Bus(dbus.Bus.TYPE_SYSTEM) up_proxy = bus.get_object('org.freedesktop.UPower', '/org/freedesktop/UPower') upower = dbus.Interface(up_proxy, 'org.freedesktop.UPower') for device_path in upower.EnumerateDevices(): device = bus.get_object('org.freedesktop.UPower', device_path) device_prop_iface = dbus.Interface(device, dbus.PROPERTIES_IFACE) device_type = device_prop_iface.Get(_UP_DEVICE_IFACE, 'Type') if device_type != _UP_TYPE_BATTERY: continue device.connect_to_signal('Changed', self.__battery_properties_changed_cb, dbus_interface=_UP_DEVICE_IFACE) self._battery_props = dbus.Interface(device, dbus.PROPERTIES_IFACE) break except dbus.DBusException: logging.warning("Could not connect to UPower, won't show battery" "level.") self._setup()
def __connection_ready_cb(self, connection): requests = connection[CONNECTION_INTERFACE_REQUESTS] object_path, properties_ = requests.CreateChannel({ CHANNEL + '.ChannelType': CHANNEL_TYPE_FILE_TRANSFER, CHANNEL + '.TargetHandleType': CONNECTION_HANDLE_TYPE_CONTACT, CHANNEL + '.TargetHandle': self.buddy.handle, CHANNEL_TYPE_FILE_TRANSFER + '.ContentType': self.mime_type, CHANNEL_TYPE_FILE_TRANSFER + '.Filename': self.title, CHANNEL_TYPE_FILE_TRANSFER + '.Size': self.file_size, CHANNEL_TYPE_FILE_TRANSFER + '.Description': self.description, CHANNEL_TYPE_FILE_TRANSFER + '.InitialOffset': 0 }) channel = {} text_proxy = dbus.Bus().get_object(self._service_name, object_path) channel[dbus.PROPERTIES_IFACE] = \ dbus.Interface(text_proxy, dbus.PROPERTIES_IFACE) channel[CHANNEL_TYPE_FILE_TRANSFER] = \ dbus.Interface(text_proxy, CHANNEL_TYPE_FILE_TRANSFER) channel[CHANNEL] = dbus.Interface(text_proxy, CHANNEL) self.set_channel(channel) channel_file_transfer = self.channel[CHANNEL_TYPE_FILE_TRANSFER] self._socket_address = channel_file_transfer.ProvideFile( SOCKET_ADDRESS_TYPE_UNIX, SOCKET_ACCESS_CONTROL_LOCALHOST, '', byte_arrays=True)
def __update_interface(self): """If __interface is None, set a proxy interface object and connect to the key pressed signal.""" if self.__interface: return self.__interface bus = dbus.Bus(dbus.Bus.TYPE_SESSION) for desc in self.DBUS_IFACES: try: obj = bus.get_object(self.DBUS_NAME, desc["path"]) iface = dbus.Interface(obj, desc["interface"]) # try to call a method to test the interface iface.ReleaseMediaPlayerKeys(self.__name) except dbus.DBusException: pass else: self.__key_pressed_sig = iface.connect_to_signal( "MediaPlayerKeyPressed", self.__key_pressed) self.__interface = iface break return self.__interface
def __init__(self): GObject.GObject.__init__(self) self._buddies = {None: get_owner_instance()} self._activities = {} self._link_local_account = None self._server_account = None self._shell_model = shell.get_model() self._settings_collaboration = \ Gio.Settings('org.sugarlabs.collaboration') self._settings_collaboration.connect('changed::jabber-server', self.__jabber_server_changed_cb) self._settings_user = Gio.Settings('org.sugarlabs.user') self._settings_user.connect('changed::nick', self.__nick_changed_cb) bus = dbus.Bus() obj = bus.get_object(ACCOUNT_MANAGER_SERVICE, ACCOUNT_MANAGER_PATH) account_manager = dbus.Interface(obj, ACCOUNT_MANAGER) account_manager.Get(ACCOUNT_MANAGER, 'ValidAccounts', dbus_interface=PROPERTIES_IFACE, reply_handler=self.__got_accounts_cb, error_handler=self.__error_handler_cb)
def __got_dispatch_operation_cb(self, **kwargs): logging.debug('__got_dispatch_operation_cb') dispatch_operation_path = kwargs['dispatch_operation_path'] channel_path, channel_properties = kwargs['channels'][0] properties = kwargs['properties'] channel_type = channel_properties[CHANNEL + '.ChannelType'] handle_type = channel_properties[CHANNEL + '.TargetHandleType'] handle = channel_properties[CHANNEL + '.TargetHandle'] if handle_type == HANDLE_TYPE_ROOM and \ channel_type == CHANNEL_TYPE_TEXT: logging.debug('May be an activity, checking its properties') connection_path = properties[CHANNEL_DISPATCH_OPERATION + '.Connection'] connection_name = connection_path.replace('/', '.')[1:] bus = dbus.Bus() connection = bus.get_object(connection_name, connection_path) connection.GetProperties( channel_properties[CHANNEL + '.TargetHandle'], dbus_interface=CONNECTION_INTERFACE_ACTIVITY_PROPERTIES, reply_handler=partial(self.__get_properties_cb, handle, dispatch_operation_path), error_handler=partial(self.__error_handler_cb, handle, channel_properties, dispatch_operation_path, channel_path, properties)) else: self._dispatch_non_sugar_invitation(handle, channel_properties, dispatch_operation_path, channel_path, properties)
def __init__(self, spotifyNotify, debugger): self.SN = spotifyNotify self.debug = debugger self.keys = { "Play": "PlayPause", "Stop": "Pause", "Pause": "Pause", "Next": "Next", "Previous": "Previous", } self.bus = dbus.Bus(dbus.Bus.TYPE_SESSION) self.bus_object = self.bus.get_object( 'org.gnome.SettingsDaemon', '/org/gnome/SettingsDaemon/MediaKeys') try: self.bus_object.GrabMediaPlayerKeys( "Spotify", 0, dbus_interface='org.gnome.SettingsDaemon.MediaKeys') except: pass self.bus_object.connect_to_signal('MediaPlayerKeyPressed', self.handle_mediakey)
def __init__(self, name): """ Initialise the connection manager. """ bus_name = 'org.freedesktop.Telepathy.ConnectionManager.%s' % name object_path = '/org/freedesktop/Telepathy/ConnectionManager/%s' % name _ConnectionManager.__init__( self, dbus.service.BusName(bus_name, dbus.Bus(), do_not_queue=True), object_path) self._interfaces = set() self._connections = set() self._protos = {} # proto name => Connection constructor self._protocols = {} # proto name => Protocol object DBusProperties.__init__(self) self._implement_property_get( CONN_MGR_INTERFACE, { 'Interfaces': lambda: dbus.Array(self._interfaces, signature='s'), 'Protocols': lambda: dbus.Dictionary(self._protocol_properties, signature='sa{sv}') })
def testClosePrivateBus(self): # fd.o #12096 dbus.Bus(private=True).close()
def dbus_close(nid): dbus.Bus().call_blocking("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "CloseNotification", "u", (nid, ))
def __name_owner_changed_cb(self, name, old, new): if name.startswith(CONNECTION + '.') and not old and new: path = '/' + name.replace('.', '/') self.conn_proxy = dbus.Bus().get_object(name, path) self._prepare_conn(path, self.conn_proxy)
def get_filename(self, uid, sender=None): logging.debug('datastore.get_filename %r', uid) user_id = dbus.Bus().get_unix_user(sender) extension = self._get_extension(uid) return self._file_store.retrieve(uid, user_id, extension)
def bus_proxy(bus=None): target_bus = bus or dbus.Bus() return target_bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
from __future__ import absolute_import import dbus import time import sys from six.moves import range if __name__ == '__main__': session = dbus.Bus() for i in range(20): for name in session.list_names(): if name == "org.freedesktop.ScreenSaver": sys.exit(0) time.sleep(0.05) sys.exit(1)
""" from gi.repository import GObject try: import dbus from dbus.mainloop.glib import DBusGMainLoop DBusGMainLoop(set_as_default=True) import dbus.service from dbus.gi_service import ExportedGObject dbus.mainloop.glib.threads_init() # if dbus unavailable print the exception here # but further actions (register) will fail without warning session_bus = dbus.Bus() except (ImportError, dbus.exceptions.DBusException) as exc: session_bus = None print(exc) from kupfer.ui import uievents class AlreadyRunningError (Exception): """Service already available on the bus Exception""" pass class NoConnectionError (Exception): """Not possible to establish connection for callbacks""" pass
def main(self): import dbus import dbus.service import dbus.mainloop.glib prefs = self.tauon.prefs gui = self.tauon.gui pctl = self.tauon.pctl tauon = self.tauon def on_mediakey(comes_from, what): if what == 'Play': self.tauon.input.media_key = 'Play' elif what == 'Pause': self.tauon.input.media_key = 'Pause' elif what == 'Stop': self.tauon.input.media_key = 'Stop' elif what == 'Next': self.tauon.input.media_key = 'Next' elif what == 'Previous': self.tauon.input.media_key = 'Previous' elif what == 'Rewind': self.tauon.input.media_key = 'Rewind' elif what == 'FastForward': self.tauon.input.media_key = 'FastForward' elif what == 'Repeat': self.tauon.input.media_key = 'Repeat' elif what == 'Shuffle': self.tauon.input.media_key = 'Shuffle' if self.tauon.input.media_key: gui.update = 1 # set up the glib main loop. dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) if prefs.mkey: try: bus = dbus.Bus(dbus.Bus.TYPE_SESSION) bus_object = bus.get_object( 'org.gnome.SettingsDaemon.MediaKeys', '/org/gnome/SettingsDaemon/MediaKeys') self.bus_object = bus_object # this is what gives us the multi media keys. dbus_interface = 'org.gnome.SettingsDaemon.MediaKeys' bus_object.GrabMediaPlayerKeys("TauonMusicBox", 0, dbus_interface=dbus_interface) # connect_to_signal registers our callback function. bus_object.connect_to_signal('MediaPlayerKeyPressed', on_mediakey) except: print("Could not connect to gnome media keys") # ---------- if prefs.enable_mpris: try: bus = dbus.Bus(dbus.Bus.TYPE_SESSION) bus_name = dbus.service.BusName( 'org.mpris.MediaPlayer2.tauon', bus) # This object must be kept alive class MPRIS(dbus.service.Object): def update(self, force=False): changed = {} if pctl.playing_state == 1 or pctl.playing_state == 3: if self.player_properties[ 'PlaybackStatus'] != 'Playing': self.player_properties[ 'PlaybackStatus'] = 'Playing' changed[ 'PlaybackStatus'] = self.player_properties[ 'PlaybackStatus'] elif pctl.playing_state == 0: if self.player_properties[ 'PlaybackStatus'] != 'Stopped': self.player_properties[ 'PlaybackStatus'] = 'Stopped' changed[ 'PlaybackStatus'] = self.player_properties[ 'PlaybackStatus'] elif pctl.playing_state == 2: if self.player_properties[ 'PlaybackStatus'] != 'Paused': self.player_properties[ 'PlaybackStatus'] = 'Paused' changed[ 'PlaybackStatus'] = self.player_properties[ 'PlaybackStatus'] if pctl.player_volume / 100 != self.player_properties[ 'Volume']: self.player_properties[ 'Volume'] = pctl.player_volume / 100 changed['Volume'] = self.player_properties[ 'Volume'] if pctl.playing_object() is not None and ( pctl.playing_object().index != self.playing_index or force): track = pctl.playing_object() self.playing_index = track.index id = f"/com/tauon/{track.index}/{pctl.playlist_playing_position}" d = { 'mpris:trackid': id, 'mpris:length': dbus.Int64(int(pctl.playing_length * 1000000)), 'xesam:album': track.album, 'xesam:albumArtist': dbus.Array([track.album_artist]), 'xesam:artist': dbus.Array([track.artist]), 'xesam:title': track.title, 'xesam:url': "file://" + urllib.parse.quote(track.fullpath), 'xesam:asText': track.lyrics, 'xesam:autoRating': star_count2(tauon.star_store.get(track.index)), 'xesam:composer': dbus.Array([track.composer]), 'tauon:loved': tauon.love(False, track.index), # added by msmafra 'xesam:comment': dbus.Array([track.comment]), 'xesam:genre': dbus.Array([track.genre]) } try: i_path = tauon.thumb_tracks.path(track) if i_path is not None: d['mpris:artUrl'] = 'file://' + urllib.parse.quote( i_path) except Exception as e: print(str(e)) print("Thumbnail error") print(track.fullpath) self.update_progress() self.player_properties[ 'Metadata'] = dbus.Dictionary(d, signature='sv') changed['Metadata'] = self.player_properties[ 'Metadata'] if pctl.playing_state == 3 and self.player_properties[ 'CanPause'] is True: self.player_properties['CanPause'] = False self.player_properties['CanSeek'] = False changed['CanPause'] = self.player_properties[ 'CanPause'] changed['CanSeek'] = self.player_properties[ 'CanSeek'] elif pctl.playing_state == 1 and self.player_properties[ 'CanPause'] is False: self.player_properties['CanPause'] = True self.player_properties['CanSeek'] = True changed['CanPause'] = self.player_properties[ 'CanPause'] changed['CanSeek'] = self.player_properties[ 'CanSeek'] if len(changed) > 0: self.PropertiesChanged( 'org.mpris.MediaPlayer2.Player', changed, []) def update_progress(self): self.player_properties['Position'] = dbus.Int64( int(pctl.playing_time * 1000000)) def update_shuffle(self): self.player_properties['Shuffle'] = pctl.random_mode self.PropertiesChanged('org.mpris.MediaPlayer2.Player', {"Shuffle": pctl.random_mode}, []) def update_loop(self): self.player_properties[ 'LoopStatus'] = self.get_loop_status() self.PropertiesChanged( 'org.mpris.MediaPlayer2.Player', {"LoopStatus": self.get_loop_status()}, []) def __init__(self, object_path): # dbus.service.Object.__init__(self, bus_name, object_path) dbus.service.Object.__init__(self, bus, object_path, bus_name=bus_name) self.playing_index = -1 self.root_properties = { 'CanQuit': True, #'Fullscreen' #'CanSetFullscreen' 'CanRaise': True, 'HasTrackList': False, 'Identity': tauon.t_title, 'DesktopEntry': tauon.t_id, 'SupportedUriSchemes': dbus.Array([dbus.String("file")]), 'SupportedMimeTypes': dbus.Array([ dbus.String("audio/mpeg"), dbus.String("audio/flac"), dbus.String("audio/ogg"), dbus.String("audio/m4a"), ]) } self.player_properties = { 'PlaybackStatus': 'Stopped', 'LoopStatus': self.get_loop_status(), 'Rate': 1.0, 'Shuffle': pctl.random_mode, 'Volume': pctl.player_volume / 100, 'Position': 0, 'MinimumRate': 1.0, 'MaximumRate': 1.0, 'CanGoNext': True, 'CanGoPrevious': True, 'CanPlay': True, 'CanPause': True, 'CanSeek': True, 'CanControl': True } def get_loop_status(self): if pctl.repeat_mode: if pctl.album_repeat_mode: return "Playlist" return "Track" return "None" @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2') def Raise(self): gui.request_raise = True @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2') def Quit(self): tauon.exit() @dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE, in_signature='ss', out_signature='v') def Get(self, interface_name, property_name): if interface_name == 'org.mpris.MediaPlayer2': #return self.GetAll(interface_name)[property_name] return self.root_properties[property_name] elif interface_name == 'org.mpris.MediaPlayer2.Player': return self.player_properties[property_name] @dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE, in_signature='s', out_signature='a{sv}') def GetAll(self, interface_name): if interface_name == 'org.mpris.MediaPlayer2': return self.root_properties elif interface_name == 'org.mpris.MediaPlayer2.Player': return self.player_properties else: return {} @dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE, in_signature='ssv', out_signature='') def Set(self, interface_name, property_name, value): if interface_name == 'org.mpris.MediaPlayer2.Player': if property_name == "Volume": pctl.player_volume = min( max(int(value * 100), 0), 100) pctl.set_volume() gui.update += 1 if property_name == "Shuffle": pctl.random_mode = bool(value) self.update_shuffle() gui.update += 1 if property_name == "LoopStatus": if value == "None": tauon.menu_repeat_off() elif value == "Track": tauon.menu_set_repeat() elif value == "Playlist": tauon.menu_album_repeat() gui.update += 1 if interface_name == 'org.mpris.MediaPlayer2': pass @dbus.service.signal(dbus_interface=dbus.PROPERTIES_IFACE, signature='sa{sv}as') def PropertiesChanged(self, interface_name, change, inval): pass @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def Next(self): pctl.advance() pass @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def Previous(self): pctl.back() pass @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def Pause(self): pctl.pause_only() @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def PlayPause(self): if pctl.playing_state == 3: pctl.stop() # Stop if playing radio else: pctl.play_pause() @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def Stop(self): pctl.stop() @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def Play(self): pctl.play() @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def Seek(self, offset): pctl.seek_time(pctl.playing_time + (offset / 1000000)) @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def SetPosition(self, id, position): pctl.seek_time(position / 1000000) self.player_properties['Position'] = dbus.Int64( int(position)) self.Seeked(pctl.playing_time) @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def OpenUri(self, uri): tauon.open_uri(uri) @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def LovePlaying(self): if not tauon.love(set=False): tauon.love(set=True, no_delay=True) self.update(True) gui.pl_update += 1 @dbus.service.method( dbus_interface='org.mpris.MediaPlayer2.Player') def UnLovePlaying(self): if tauon.love(set=False): tauon.love(set=True, no_delay=True) self.update(True) gui.pl_update += 1 @dbus.service.signal( dbus_interface='org.mpris.MediaPlayer2.Player') def Seeked(self, position): pass def seek_do(self, seconds): self.Seeked(dbus.Int64(int(seconds * 1000000))) pctl.mpris = MPRIS("/org/mpris/MediaPlayer2") except: print("MPRIS2 CONNECT FAILED") mainloop = GLib.MainLoop() mainloop.run()
# Python script for inhibiting Power Managment/suspend. I did not author this. # Obtained from http://trac.videolan.org/vlc/ticket/3313 import dbus import time #import os import signal, sys if len(sys.argv) != 3: sys.stderr.write('Usage: pm-inhibit.py <appname> <reason>\n') sys.exit(1) def sighandler(signum, frame): dev.UnInhibit(cookie) exit() bus = dbus.Bus(dbus.Bus.TYPE_SESSION) devobj = bus.get_object('org.freedesktop.PowerManagement', '/org/freedesktop/PowerManagement/Inhibit') dev = dbus.Interface(devobj, "org.freedesktop.PowerManagement.Inhibit") cookie = dev.Inhibit(sys.argv[1], sys.argv[2]) # going away from dbus when dieing should be enough, but be sure signal.signal(signal.SIGTERM, sighandler) print cookie while 1 == 1: time.sleep(30)
# Simple program to test locking; will acquire a lock on the hal device # object representing the computer. # # usage: locking.py <numsecs> import dbus import sys import time import os dev_udi = "/org/freedesktop/Hal/devices/computer" duration = int(sys.argv[1]) pid = os.getpid() reason = "locking.py pid %d" % pid bus = dbus.Bus(dbus.Bus.TYPE_SYSTEM) devobj = bus.get_object("org.freedesktop.Hal", dev_udi) dev = dbus.Interface(devobj, "org.freedesktop.Hal.Device") #hal_service = bus.get_service("org.freedesktop.Hal") #dev = hal_service.get_object (dev_udi, "org.freedesktop.Hal.Device") print "I am %s with pid %d" % (bus.get_connection().get_unique_name(), pid) print print "Attempting to lock %s for %d secs" % (dev_udi, duration) print "with reason '%s'" % reason print try: dev.Lock(reason)
def __get_self_handle_cb(self, self_handle): self._self_handle = self_handle if CONNECTION_INTERFACE_CONTACT_CAPABILITIES in self._connection: interface = CONNECTION_INTERFACE_CONTACT_CAPABILITIES connection = self._connection[interface] client_name = CLIENT + '.Sugar.FileTransfer' file_transfer_channel_class = { CHANNEL + '.ChannelType': CHANNEL_TYPE_FILE_TRANSFER, CHANNEL + '.TargetHandleType': HANDLE_TYPE_CONTACT} capabilities = [] connection.UpdateCapabilities( [(client_name, [file_transfer_channel_class], capabilities)], reply_handler=self.__update_capabilities_cb, error_handler=partial(self.__error_handler_cb, 'Connection.UpdateCapabilities')) connection = self._connection[CONNECTION_INTERFACE_ALIASING] connection.connect_to_signal('AliasesChanged', self.__aliases_changed_cb) connection = self._connection[CONNECTION_INTERFACE_SIMPLE_PRESENCE] connection.connect_to_signal('PresencesChanged', self.__presences_changed_cb) if CONNECTION_INTERFACE_BUDDY_INFO in self._connection: connection = self._connection[CONNECTION_INTERFACE_BUDDY_INFO] connection.connect_to_signal('PropertiesChanged', self.__buddy_info_updated_cb, byte_arrays=True) connection.connect_to_signal('ActivitiesChanged', self.__buddy_activities_changed_cb) connection.connect_to_signal('CurrentActivityChanged', self.__current_activity_changed_cb) if self._home_changed_hid is None: home_model = shell.get_model() self._home_changed_hid = home_model.connect( 'active-activity-changed', self.__active_activity_changed_cb) else: logging.warning('Connection %s does not support OLPC buddy ' 'properties', self._object_path) if CONNECTION_INTERFACE_ACTIVITY_PROPERTIES in self._connection: connection = self._connection[ CONNECTION_INTERFACE_ACTIVITY_PROPERTIES] connection.connect_to_signal( 'ActivityPropertiesChanged', self.__activity_properties_changed_cb) else: logging.warning('Connection %s does not support OLPC activity ' 'properties', self._object_path) properties = { CHANNEL + '.ChannelType': CHANNEL_TYPE_CONTACT_LIST, CHANNEL + '.TargetHandleType': HANDLE_TYPE_LIST, CHANNEL + '.TargetID': 'subscribe', } properties = dbus.Dictionary(properties, signature='sv') connection = self._connection[CONNECTION_INTERFACE_REQUESTS] is_ours, channel_path, properties = \ connection.EnsureChannel(properties) channel = {} service_name = self._object_path.replace('/', '.')[1:] text_proxy = dbus.Bus().get_object(service_name, channel_path) channel[PROPERTIES_IFACE] = dbus.Interface(text_proxy, PROPERTIES_IFACE) channel[CHANNEL_INTERFACE_GROUP] = \ dbus.Interface(text_proxy, CHANNEL_INTERFACE_GROUP) channel[CHANNEL_INTERFACE_GROUP].connect_to_signal( 'MembersChanged', self.__members_changed_cb) channel[PROPERTIES_IFACE].Get( CHANNEL_INTERFACE_GROUP, 'Members', reply_handler=self.__get_members_ready_cb, error_handler=partial( self.__error_handler_cb, 'Connection.GetMembers'))