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'))
