def run(
write_pipe1=None, # write pipe to systemtray
write_pipe2=None, # write pipe to hpdio
read_pipe3=None): # read pipe from hpdio
global dbus_loop, main_loop
global system_bus, session_bus
global w1, w2, r3
log.set_module("hp-systray(hpssd)")
log.debug("PID=%d" % os.getpid())
w1, w2, r3 = write_pipe1, write_pipe2, read_pipe3
dbus_loop = DBusGMainLoop(set_as_default=True)
main_loop = MainLoop()
try:
system_bus = SystemBus(mainloop=dbus_loop)
except dbus.exceptions.DBusException as e:
log.error("Unable to connect to dbus system bus. Exiting.")
sys.exit(1)
try:
session_bus = dbus.SessionBus()
except dbus.exceptions.DBusException as e:
if os.getuid() != 0:
log.error("Unable to connect to dbus session bus. Exiting.")
sys.exit(1)
else:
log.error(
"Unable to connect to dbus session bus (running as root?)")
sys.exit(1)
# Receive events from the system bus
system_bus.add_signal_receiver(handle_system_signal,
sender_keyword='sender',
destination_keyword='dest',
interface_keyword='interface',
member_keyword='member',
path_keyword='path')
# Receive events from the session bus
session_bus.add_signal_receiver(handle_session_signal,
sender_keyword='sender',
destination_keyword='dest',
interface_keyword='interface',
member_keyword='member',
path_keyword='path')
# Export an object on the session bus
session_name = dbus.service.BusName("com.hplip.StatusService", session_bus)
status_service = StatusService(session_name, "/com/hplip/StatusService")
log.debug("Entering main dbus loop...")
try:
main_loop.run()
except KeyboardInterrupt:
log.debug("Ctrl-C: Exiting...")
def install_signal_handlers(self): """Hooks to some d-bus signals that are of interest to us""" bus = SystemBus() bus.add_signal_receiver( self.handle_incoming_message, 'IncomingMessage', 'org.freesmartphone.GSM.SIM' )
def run(write_pipe1=None, # write pipe to systemtray
write_pipe2=None, # write pipe to hpdio
read_pipe3=None): # read pipe from hpdio
global dbus_loop, main_loop
global system_bus, session_bus
global w1, w2, r3
log.set_module("hp-systray(hpssd)")
log.debug("PID=%d" % os.getpid())
w1, w2, r3 = write_pipe1, write_pipe2, read_pipe3
dbus_loop = DBusGMainLoop(set_as_default=True)
main_loop = MainLoop()
try:
system_bus = SystemBus(mainloop=dbus_loop)
except dbus.exceptions.DBusException as e:
log.error("Unable to connect to dbus system bus. Exiting.")
sys.exit(1)
try:
session_bus = dbus.SessionBus()
except dbus.exceptions.DBusException as e:
if os.getuid() != 0:
log.error("Unable to connect to dbus session bus. Exiting.")
sys.exit(1)
else:
log.error("Unable to connect to dbus session bus (running as root?)")
sys.exit(1)
# Receive events from the system bus
system_bus.add_signal_receiver(handle_system_signal, sender_keyword='sender',
destination_keyword='dest', interface_keyword='interface',
member_keyword='member', path_keyword='path')
# Receive events from the session bus
session_bus.add_signal_receiver(handle_session_signal, sender_keyword='sender',
destination_keyword='dest', interface_keyword='interface',
member_keyword='member', path_keyword='path')
# Export an object on the session bus
session_name = dbus.service.BusName("com.hplip.StatusService", session_bus)
status_service = StatusService(session_name, "/com/hplip/StatusService")
log.debug("Entering main dbus loop...")
try:
main_loop.run()
except KeyboardInterrupt:
log.debug("Ctrl-C: Exiting...")
def enable(self):
bus = SystemBus()
if not self.handler:
self.signal = bus.add_signal_receiver(
self.handle_call_status,
signal_name='CallStatus',
dbus_interface='org.freesmartphone.GSM.Call',
bus_name='org.freesmartphone.ogsmd')
self.handler = True
self._initialized = True
class AutoPlayer:
def __init__(self):
# Diccionario para evitar los dobles escaneos producto de la emisión
# de señales repetidas. Pasa porque Rhythmbox vuelve a escanear todos
# los dispositivos cuando levanta por primera vez.
self._already_scanned = {}
# Se obtiene una conexión al bus de sistema
self._system_bus = SystemBus()
# Se obtiene una conexión al bus de sesión
self._session_bus = SessionBus()
# Conectar a las señales que emite de UDisks
self._connect_to_udisks()
def _connect_to_udisks(self):
# Información de D-Bus para UDisks
udisks_bus_name = 'org.freedesktop.UDisks'
udisks_object_path = '/org/freedesktop/UDisks'
udisks_dbus_interface = 'org.freedesktop.UDisks'
# Se conecta la señal 'DeviceChanged' exportada por el objeto remoto
# al manejador local de señales '_onDeviceChanged'.
self._system_bus.add_signal_receiver(
self._onDeviceChanged,
signal_name='DeviceChanged',
dbus_interface=udisks_dbus_interface,
bus_name=udisks_bus_name,
path=udisks_object_path)
# Se conecta la señal 'DeviceRemoved' exportada por el objeto remoto
# al manejador local de señales '_onDeviceRemoved'.
self._system_bus.add_signal_receiver(
self._onDeviceRemoved,
signal_name='DeviceRemoved',
dbus_interface=udisks_dbus_interface,
bus_name=udisks_bus_name,
path=udisks_object_path)
def _onDeviceChanged(self, device_object_path):
" La señal 'DeviceChanged' es emitida cuando se cambia el estado de un"
" dispositivo (por ejemplo, cuando se monta o desmonta). UDisks envía "
" el camino del objeto remoto del dispositivo que cambió de estado. "
print u'Un dispositivo cambió: %s' % device_object_path
mount_path = self._get_device_mount_path(device_object_path)
# Si no está montado o ya fue escaneado, no hacer nada y retornar
if not mount_path:
return
playlist = self._get_playlist(mount_path)
# Si no hay música en el dispositivo, no hacer nada y retornar
if not playlist:
return
self._play(playlist)
def _onDeviceRemoved(self, device_object_path):
" La señal 'DeviceRemoved' es emitida cuando un dispositivo es "
" desconectado por hardware de la PC. UDisks envía el camino del "
" objeto remoto del dispositivo."
print u'Un dispositivo fue desconectado: %s' % device_object_path
if device_object_path in self._already_scanned:
del self._already_scanned[device_object_path]
def _get_device_mount_path(self, device_object_path):
# Información necesaria para procesar los dispositivos de UDisks
udisks_bus_name = 'org.freedesktop.UDisks'
device_dbus_interface = 'org.freedesktop.UDisks.Device'
# Se obtiene el objeto remoto del dispositivo insertado a través
# de la conexión al bus de sistema del demonio UDisks.
device_object = self._system_bus.get_object(udisks_bus_name,
device_object_path)
# Para acceder a las propiedades de un objeto FreeDesktop.org
# establece una interfaz estándar: 'org.freedesktop.DBus.Properties'
device = Interface(device_object, 'org.freedesktop.DBus.Properties')
# Con el método 'Get' de la interfaz 'org.freedesktop.DBus.Properties'
# se obtiene el valor de una propiedad en una interfaz determinada.
# La propiedad 'DeviceFile' devuelve el archivo de dispositivo en /dev
# En nuestro caso no lo necesitamos, se pone a modo de enseñanza.
dev_file = device.Get(device_dbus_interface, 'DeviceFile')
# La propiedad 'DeviceIsMounted' devuelve si está montado
is_mounted = device.Get(device_dbus_interface, 'DeviceIsMounted')
print u'¿Está montado %s? : %s' % (dev_file, str(bool(is_mounted)))
# Si el dispositivo ya fue escaneado y no está montado, significa que
# recién se desmontó, hay que olvidarlo.
mount_path = None
if device_object_path in self._already_scanned:
if not is_mounted:
del self._already_scanned[device_object_path]
# Si no ha sido escaneado y está montado, significa que recién se
# ha montado y hay que escanearlo y recordarlo, se devuelve el punto
# de montaje. En otros casos, no se hace nada y no se devuelve nada.
elif is_mounted:
self._already_scanned[device_object_path] = True
# La propiedad 'DeviceMountPaths' devuelve todos los directorios
# del sistema de archivos donde se ha montado este dispositivo.
mount_paths = device.Get(device_dbus_interface, 'DeviceMountPaths')
mount_path = mount_paths[0]
return mount_path
def _get_playlist(self, directory_path):
print u'Buscando música en el directorio %s' % directory_path
playlist = []
filenames = listdir(directory_path)
for filename in filenames:
path = join(directory_path, filename)
if isfile(path):
# Se obtiene el tipo MIME, ejemplo "audio/mpeg"
mime_type = guess_type(path)[0]
# Lo que interesa es la primera parte del tipo MIME
category = mime_type.split('/')[0]
if category == 'audio':
# El Playlist Manager de Rhythmbox espera URIs, por tanto..
uri = urljoin('file:', pathname2url(path))
playlist.append(uri)
return playlist
def _get_rhythmbox_playlist_manager(self):
# Para modificar la lista de reproducción no hay MPRIS que valga :-(
# Información de D-Bus para el Playlist Manager de Rhythmbox
rhythmbox_bus_name = 'org.gnome.Rhythmbox3'
playlist_mgr_object_path = '/org/gnome/Rhythmbox3/PlaylistManager'
playlist_mgr_dbus_interface = 'org.gnome.Rhythmbox3.PlaylistManager'
# Se obtiene el objeto remoto de Rhythmbox desde el bus de sesión
playlist_mgr_obj = self._session_bus.get_object(
rhythmbox_bus_name, playlist_mgr_object_path)
# Esperar a que levante Rhythmbox... sí, ok, ya sé que esto es una
# mala práctica. Lo correcto sería conectar a alguna señal remota que
# avise de que está listo el reproductor, pero mejor no complicarse :-P
sleep(5)
playlist_manager = Interface(playlist_mgr_obj,
playlist_mgr_dbus_interface)
return playlist_manager
def _get_rhythmbox_player(self):
# Para controlar el reproductor, usaremos la interfaz estándar que
# define FreeDestkop.org, es decir MPRIS
# Información de D-Bus para Rhythmbox usando interfaz estándar MPRIS
rhythmbox_bus_name = 'org.mpris.MediaPlayer2.rhythmbox'
rhythmbox_object_path = '/org/mpris/MediaPlayer2'
rhythmbox_dbus_interface_player = 'org.mpris.MediaPlayer2.Player'
rhythmbox_dbus_interface_playlists = 'org.mpris.MediaPlayer2.Playlists'
# Se obtiene el objeto remoto de Rhythmbox desde el bus de sesión
rhythmbox_object = self._session_bus.get_object(
rhythmbox_bus_name, rhythmbox_object_path)
# Se obtiene la interfaz Player del objeto remoto del reproductor
rhythmbox_player = Interface(rhythmbox_object,
rhythmbox_dbus_interface_player)
# Se obtiene la interfaz Playerlists del objeto remoto del reproductor
rhythmbox_playlists = Interface(rhythmbox_object,
rhythmbox_dbus_interface_playlists)
# Se necesita obtener la cantidad de listas de reproducción contenidas
# en el reproductor. Eso lo devuelve la propiedad "PlaylistCount"
playlists_properties = Interface(rhythmbox_object,
'org.freedesktop.DBus.Properties')
pl_count = playlists_properties.Get(rhythmbox_dbus_interface_playlists,
'PlaylistCount')
return rhythmbox_player, rhythmbox_playlists, pl_count
def _play(self, playlist):
# Obtener el Playlist Manager de Rhythmbox
playlist_manager = self._get_rhythmbox_playlist_manager()
# Nombre estático para la lista de reproducción,
# se llamará siempre "Autoplayer"
playlist_name = 'Autoplayer'
try:
# Borrar la lista de reproducción si ya existe
playlist_manager.DeletePlaylist(playlist_name)
except:
# Si no existe levanta excepción, la ignoramos
pass
# Crear una lista de reproducción nueva
playlist_manager.CreatePlaylist(playlist_name)
# Se adiciona cada archivo de música obtenido del dispositvo
# de almacenamiento a la nueva lista de reproducción
for uri in playlist:
playlist_manager.AddToPlaylist(playlist_name, uri)
# Obtenemos el reproductor y sus listas desde la interfaz MPRIS
(rhythmbox_player, playlists_interface,
playlists_count) = self._get_rhythmbox_player()
# En un mundo ideal, Rhythmbox sería buenito y ordenaría las listas de
# reproducción por fecha de creación en orden reverso como indica el
# API de MPRIS, pero desgraciadamente no soporta esta funcionalidad,
# así que hay que buscar a lo bestia... :-P :-(
playlists = playlists_interface.GetPlaylists(0, playlists_count,
'CreationDate', True)
# Buscando nuestra lista de reproducción a lo bestia... :-P
i = 0
while i < playlists_count and playlists[i][1] != playlist_name:
i += 1
if i < playlists_count:
playlist_id = playlists[i][0]
else:
print >> stderr, u'Rhythmbox no cargó la lista correctamente.'
return
# Si se llega aquí, es que se encontró nuestra lista de reproducción
# Detenemos cualquier reproducción previa para evitar mareadera :-P
rhythmbox_player.Stop()
# Activar la lista de reproducción como lista de reproducción actual
playlists_interface.ActivatePlaylist(playlist_id)
# Reproducir... :-)
rhythmbox_player.Play()
class MessagesFSO(object):
#----------------------------------------------------------------------------#
name = 'FSO-Messages-Handler'
_gsm_sim_iface = None
_UNAVAILABLE_PART = '<???>'
domain = None
#----------------------------------------------------------------------------#
def __init__(self, domain):
self.domain = domain
self.signals = False
self.ready_signal = False
self.enable()
def __repr__(self):
return self.name
def dbus_ok(self, *args, **kargs):
pass
def dbus_err(self, *args, **kargs):
pass
def process_single_entry(self, data):
(status, number, text, props) = data
entry = {}
#FIXME: removing status and sanitize this function remove seq/etc after getting second message
logger.debug("Processing entry \"%s\"...", text)
entry['New'] = 1
if status in ('read', 'unread'):
entry['Direction'] = 'in'
else:
entry['Direction'] = 'out'
if status in ('read', 'sent'):
entry['New'] = 0
entry['Peer'] = number
# TODO Handle text properly, i.e. make it on-demand if >1KiB
entry['Content'] = text
entry['Source'] = 'SMS'
entry['SMS-combined_message'] = 0
if props.has_key('timestamp'):
try:
timestamp = props['timestamp'][:len(props['timestamp']) - 6]
entry['Timezone'] = props['timestamp'][len(props['timestamp']
) - 5:]
entry['Timestamp'] = int(time.mktime(time.strptime(timestamp)))
except ValueError:
logger.error("Couldn't handle timestamp!")
if props.has_key('csm_seq'):
entry['SMS-combined_message'] = 1
entry['SMS-complete_message'] = 0
entry['SMS-csm_seq' + str(props['csm_seq']) + '_content'] = text
for field in props:
entry['SMS-' + field] = props[field]
logger.debug("Message is incoming!")
if entry['SMS-combined_message']:
logger.debug("It's CSM!")
register = 0
try:
path = self.domain.GetSingleEntrySingleField(
{
'Direction': 'in',
'SMS-combined_message': 1,
'SMS-complete_message': 0,
'SMS-csm_num': entry['SMS-csm_num'],
'SMS-csm_id': entry['SMS-csm_id'],
'Source': 'SMS'
}, 'Path')
if path:
id = self.domain.path_to_id(path)
result = self.domain.get_content(id)
new_content = ''
complete = 1
edit_data = {}
# Make the whole content
for i in range(1, entry['SMS-csm_num'] + 1):
if i == entry['SMS-csm_seq']:
new_content += entry['Content']
edit_data['SMS-csm_seq' + str(i) +
'_content'] = entry['Content']
else:
try:
new_content += result['SMS-csm_seq' + str(i) +
'_content']
except KeyError:
new_content += self._UNAVAILABLE_PART
complete = 0
if complete:
edit_data['SMS-complete_message'] = 1
edit_data['Content'] = new_content
edit_data['New'] = 1
self.domain.Update(edit_data, '/' + str(id))
else:
register = 1
if entry['SMS-csm_seq'] > 1:
entry['Content'] = self._UNAVAILABLE_PART + entry[
'Content']
if entry['SMS-csm_seq'] < entry['SMS-csm_num']:
entry['Content'] = entry[
'Content'] + self._UNAVAILABLE_PART
logger.debug('CSM: first part')
except:
register = 1
logger.error('%s: failed to handle CSM message!', self.name)
else:
register = 1
#If needed to add, add.
if register:
self.domain.AddIncoming(entry)
def disable(self):
if self.ready_signal:
self.readysignal.remove()
self.authsignal.remove()
self.ready_signal = False
if self.signals:
self.imsignal.remove()
self.ismsignal.remove()
self.imrsignal.remove()
self.imrsignal2.remove()
self.itmsignal.remove()
self.signals = False
def enable(self):
self.bus = SystemBus()
try:
self.gsm = self.bus.get_object('org.freesmartphone.ogsmd',
'/org/freesmartphone/GSM/Device',
True, True)
self.gsm_sim_iface = Interface(self.gsm,
'org.freesmartphone.GSM.SIM')
self.gsm_sms_iface = Interface(self.gsm,
'org.freesmartphone.GSM.SMS')
self.gsm_device_iface = Interface(self.gsm,
'org.freesmartphone.GSM.Device')
self.install_signal_handlers()
self._initialized = True
except DBusException, e:
logger.warning(
"%s: Could not request SIM messagebook from ogsmd (%s)",
self.name, e)
logger.info("%s: Waiting for SIM being ready...", self.name)
if not self.ready_signal:
try:
self.readysignal = self.bus.add_signal_receiver(
self.handle_sim_ready,
signal_name='ReadyStatus',
dbus_interface='org.freesmartphone.GSM.SIM',
bus_name='org.freesmartphone.ogsmd')
self.authsignal = self.bus.add_signal_receiver(
self.handle_auth_status,
signal_name='AuthStatus',
dbus_interface='org.freesmartphone.GSM.SIM',
bus_name='org.freesmartphone.ogsmd')
logger.info(
'%s: Signal listeners about SIM status installed',
self.name)
#self.gsm_sim_iface.connect_to_signal("ReadyStatus", self.handle_sim_ready)
self.ready_signal = True
except:
logger.error("%s: Could not install signal handler!",
self.name)
