You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
360 lines
12 KiB
Python
360 lines
12 KiB
Python
# Copyright (C) 2007, Red Hat, Inc.
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2 of the License, or (at your option) any later version.
|
|
#
|
|
# This library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with this library; if not, write to the
|
|
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
# Boston, MA 02111-1307, USA.
|
|
|
|
"""UI interface to a buddy in the presence service
|
|
|
|
STABLE.
|
|
"""
|
|
|
|
import logging
|
|
from functools import partial
|
|
|
|
import gobject
|
|
import gtk
|
|
import dbus
|
|
import gconf
|
|
from telepathy.interfaces import ACCOUNT, \
|
|
CONNECTION, \
|
|
CONNECTION_INTERFACE_ALIASING, \
|
|
CONNECTION_INTERFACE_CONTACTS
|
|
from telepathy.constants import HANDLE_TYPE_CONTACT
|
|
|
|
from sugar.presence.util import get_connection_manager
|
|
|
|
ACCOUNT_MANAGER_SERVICE = 'org.freedesktop.Telepathy.AccountManager'
|
|
CONN_INTERFACE_BUDDY_INFO = 'org.laptop.Telepathy.BuddyInfo'
|
|
|
|
_logger = logging.getLogger('sugar.presence.buddy')
|
|
|
|
|
|
class BaseBuddy(gobject.GObject):
|
|
"""UI interface for a Buddy in the presence service
|
|
|
|
Each buddy interface tracks a set of activities and properties
|
|
that can be queried to provide UI controls for manipulating
|
|
the presence interface.
|
|
|
|
Properties Dictionary:
|
|
'key': public key,
|
|
'nick': nickname ,
|
|
'color': color (XXX what format),
|
|
'current-activity': (XXX dbus path?),
|
|
'owner': (XXX dbus path?),
|
|
'icon': (XXX pixel data for an icon?)
|
|
See __gproperties__
|
|
"""
|
|
|
|
__gtype_name__ = 'PresenceBaseBuddy'
|
|
|
|
__gsignals__ = {
|
|
'icon-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
|
|
'joined-activity': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
|
|
([gobject.TYPE_PYOBJECT])),
|
|
'left-activity': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
|
|
([gobject.TYPE_PYOBJECT])),
|
|
'property-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
|
|
([gobject.TYPE_PYOBJECT])),
|
|
}
|
|
|
|
def __init__(self):
|
|
gobject.GObject.__init__(self)
|
|
|
|
self._key = None
|
|
self._icon = None
|
|
self._nick = None
|
|
self._color = None
|
|
self._current_activity = None
|
|
self._owner = False
|
|
self._ip4_address = None
|
|
self._tags = None
|
|
|
|
def destroy(self):
|
|
self._icon_changed_signal.remove()
|
|
self._joined_activity_signal.remove()
|
|
self._left_activity_signal.remove()
|
|
self._property_changed_signal.remove()
|
|
|
|
def _get_properties_helper(self):
|
|
"""Retrieve the Buddy's property dictionary from the service object
|
|
"""
|
|
props = self._buddy.GetProperties(byte_arrays=True)
|
|
if not props:
|
|
return {}
|
|
return props
|
|
|
|
def get_key(self):
|
|
return self._key
|
|
|
|
def set_key(self, key):
|
|
self._key = key
|
|
|
|
key = gobject.property(type=str, getter=get_key, setter=set_key)
|
|
|
|
def get_icon(self):
|
|
raise NotImplementedError()
|
|
|
|
icon = gobject.property(type=str, getter=get_icon)
|
|
|
|
def get_nick(self):
|
|
return self._nick
|
|
|
|
def set_nick(self, nick):
|
|
self._nick = nick
|
|
|
|
nick = gobject.property(type=str, getter=get_nick, setter=set_nick)
|
|
|
|
def get_color(self):
|
|
return self._color
|
|
|
|
def set_color(self, color):
|
|
self._color = color
|
|
|
|
color = gobject.property(type=str, getter=get_color, setter=set_color)
|
|
|
|
def get_current_activity(self):
|
|
if self._current_activity is None:
|
|
return None
|
|
for activity in self._activities.values():
|
|
if activity.props.id == self._current_activity:
|
|
return activity
|
|
return None
|
|
|
|
current_activity = gobject.property(type=object, getter=get_current_activity)
|
|
|
|
def get_owner(self):
|
|
return self._owner
|
|
|
|
def set_owner(self, owner):
|
|
self._owner = owner
|
|
|
|
owner = gobject.property(type=bool, getter=get_owner, setter=set_owner, default=False)
|
|
|
|
def get_ip4_address(self):
|
|
return self._ip4_address
|
|
|
|
def set_ip4_address(self, ip4_address):
|
|
self._ip4_address = ip4_address
|
|
|
|
ip4_address = gobject.property(type=str, getter=get_ip4_address, setter=set_ip4_address)
|
|
|
|
def get_tags(self):
|
|
return self._tags
|
|
|
|
def set_tags(self, tags):
|
|
self._tags = tags
|
|
|
|
tags = gobject.property(type=str, getter=get_tags, setter=set_tags)
|
|
|
|
def object_path(self):
|
|
"""Retrieve our dbus object path"""
|
|
return None
|
|
|
|
def _emit_icon_changed_signal(self, icon_data):
|
|
"""Emit GObject signal when icon has changed"""
|
|
self._icon = str(icon_data)
|
|
self.emit('icon-changed')
|
|
return False
|
|
|
|
def __icon_changed_cb(self, icon_data):
|
|
"""Handle dbus signal by emitting a GObject signal"""
|
|
gobject.idle_add(self._emit_icon_changed_signal, icon_data)
|
|
|
|
def __emit_joined_activity_signal(self, object_path):
|
|
"""Emit activity joined signal with Activity object"""
|
|
self.emit('joined-activity', self._ps_new_object(object_path))
|
|
return False
|
|
|
|
def __joined_activity_cb(self, object_path):
|
|
"""Handle dbus signal by emitting a GObject signal
|
|
|
|
Stores the activity in activities dictionary as well
|
|
"""
|
|
if not self._activities.has_key(object_path):
|
|
self._activities[object_path] = self._ps_new_object(object_path)
|
|
gobject.idle_add(self._emit_joined_activity_signal, object_path)
|
|
|
|
def _emit_left_activity_signal(self, object_path):
|
|
"""Emit activity left signal with Activity object
|
|
|
|
XXX this calls self._ps_new_object instead of self._ps_del_object,
|
|
which would seem to be the incorrect callback?
|
|
"""
|
|
self.emit('left-activity', self._ps_new_object(object_path))
|
|
return False
|
|
|
|
def __left_activity_cb(self, object_path):
|
|
"""Handle dbus signal by emitting a GObject signal
|
|
|
|
Also removes from the activities dictionary
|
|
"""
|
|
if self._activities.has_key(object_path):
|
|
del self._activities[object_path]
|
|
gobject.idle_add(self._emit_left_activity_signal, object_path)
|
|
|
|
def _handle_property_changed_signal(self, prop_list):
|
|
"""Emit property-changed signal with property dictionary
|
|
|
|
Generates a property-changed signal with the results of
|
|
_get_properties_helper()
|
|
"""
|
|
self._properties = self._get_properties_helper()
|
|
# FIXME: don't leak unexposed property names
|
|
self.emit('property-changed', prop_list)
|
|
return False
|
|
|
|
def __property_changed_cb(self, prop_list):
|
|
"""Handle dbus signal by emitting a GObject signal"""
|
|
gobject.idle_add(self._handle_property_changed_signal, prop_list)
|
|
|
|
def get_icon_pixbuf(self):
|
|
"""Retrieve Buddy's icon as a GTK pixel buffer
|
|
|
|
XXX Why aren't the icons coming in as SVG?
|
|
"""
|
|
if self.props.icon and len(self.props.icon):
|
|
pbl = gtk.gdk.PixbufLoader()
|
|
pbl.write(self.props.icon)
|
|
pbl.close()
|
|
return pbl.get_pixbuf()
|
|
else:
|
|
return None
|
|
|
|
def get_joined_activities(self):
|
|
"""Retrieve the set of all activities which this buddy has joined
|
|
|
|
Uses the GetJoinedActivities method on the service
|
|
object to produce object paths, wraps each in an
|
|
Activity object.
|
|
|
|
returns list of presence Activity objects
|
|
"""
|
|
try:
|
|
resp = self._buddy.GetJoinedActivities()
|
|
except dbus.exceptions.DBusException:
|
|
return []
|
|
acts = []
|
|
for item in resp:
|
|
acts.append(self._ps_new_object(item))
|
|
return acts
|
|
|
|
|
|
class Buddy(BaseBuddy):
|
|
__gtype_name__ = 'PresenceBuddy'
|
|
def __init__(self, account_path, contact_id):
|
|
_logger.debug('Buddy.__init__')
|
|
BaseBuddy.__init__(self)
|
|
|
|
self._account_path = account_path
|
|
self.contact_id = contact_id
|
|
self.contact_handle = None
|
|
|
|
_logger.info('KILL_PS Handle the connection going away and coming back')
|
|
connection_manager = get_connection_manager()
|
|
connection = connection_manager.get_connection(account_path)
|
|
|
|
connection_name = connection.object_path.replace('/', '.')[1:]
|
|
|
|
bus = dbus.SessionBus()
|
|
obj = bus.get_object(connection_name, connection.object_path)
|
|
handles = obj.RequestHandles(HANDLE_TYPE_CONTACT, [self.contact_id],
|
|
dbus_interface=CONNECTION)
|
|
self.contact_handle = handles[0]
|
|
|
|
self._get_properties_call = bus.call_async(
|
|
connection_name,
|
|
connection.object_path,
|
|
CONN_INTERFACE_BUDDY_INFO,
|
|
'GetProperties',
|
|
'u',
|
|
(self.contact_handle,),
|
|
reply_handler=self.__got_properties_cb,
|
|
error_handler=self.__error_handler_cb,
|
|
utf8_strings=True,
|
|
byte_arrays=True)
|
|
|
|
self._get_attributes_call = bus.call_async(
|
|
connection_name,
|
|
connection.object_path,
|
|
CONNECTION_INTERFACE_CONTACTS,
|
|
'GetContactAttributes',
|
|
'auasb',
|
|
([self.contact_handle], [CONNECTION_INTERFACE_ALIASING], False),
|
|
reply_handler=self.__got_attributes_cb,
|
|
error_handler=self.__error_handler_cb)
|
|
|
|
def __got_properties_cb(self, properties):
|
|
_logger.debug('__got_properties_cb %r', properties)
|
|
self._get_properties_call = None
|
|
self._update_properties(properties)
|
|
|
|
def __got_attributes_cb(self, attributes):
|
|
_logger.debug('__got_attributes_cb %r', attributes)
|
|
self._get_attributes_call = None
|
|
self._update_attributes(attributes[self.contact_handle])
|
|
|
|
def __error_handler_cb(self, error):
|
|
_logger.debug('__error_handler_cb %r', error)
|
|
|
|
def __properties_changed_cb(self, new_props):
|
|
_logger.debug('%r: Buddy properties changed to %r', self, new_props)
|
|
self._update_properties(new_props)
|
|
|
|
def _update_properties(self, properties):
|
|
if 'key' in properties:
|
|
self.props.key = properties['key']
|
|
if 'icon' in properties:
|
|
self.props.icon = properties['icon']
|
|
if 'color' in properties:
|
|
self.props.color = properties['color']
|
|
if 'current-activity' in properties:
|
|
self.props.current_activity = properties['current-activity']
|
|
if 'owner' in properties:
|
|
self.props.owner = properties['owner']
|
|
if 'ip4-address' in properties:
|
|
self.props.ip4_address = properties['ip4-address']
|
|
if 'tags' in properties:
|
|
self.props.tags = properties['tags']
|
|
|
|
def _update_attributes(self, attributes):
|
|
nick_key = CONNECTION_INTERFACE_ALIASING + '/alias'
|
|
if nick_key in attributes:
|
|
self.props.nick = attributes[nick_key]
|
|
|
|
def do_get_property(self, pspec):
|
|
if pspec.name == 'nick' and self._get_attributes_call is not None:
|
|
_logger.debug('%r: Blocking on GetContactAttributes() because someone '
|
|
'wants property nick', self)
|
|
self._get_attributes_call.block()
|
|
elif pspec.name != 'nick' and self._get_properties_call is not None:
|
|
_logger.debug('%r: Blocking on GetProperties() because someone '
|
|
'wants property %s', self, pspec.name)
|
|
self._get_properties_call.block()
|
|
|
|
return BaseBuddy.do_get_property(self, pspec)
|
|
|
|
|
|
class Owner(BaseBuddy):
|
|
|
|
__gtype_name__ = 'PresenceOwner'
|
|
|
|
def __init__(self):
|
|
BaseBuddy.__init__(self)
|
|
|
|
client = gconf.client_get_default()
|
|
self.props.nick = client.get_string("/desktop/sugar/user/nick")
|
|
self.props.color = client.get_string("/desktop/sugar/user/color")
|