sugar-toolkit-gtk3/services/presence/PresenceService.py

# Copyright (C) 2006, Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import avahi, dbus, dbus.glib, gobject
import Buddy
import Service
import Activity
import random
import logging
from sugar import util
from sugar import env
from sugar import profile
import BuddyIconCache


_SA_UNRESOLVED = 0
_SA_RESOLVE_PENDING = 1
_SA_RESOLVED = 2
class ServiceAdv(object):
    """Wrapper class to track services from Avahi."""
    def __init__(self, interface, protocol, name, stype, domain, local):
        self._interface = interface
        self._protocol = protocol
        if not isinstance(name, unicode):
            raise ValueError("service advertisement name must be unicode.")
        self._name = name
        if not isinstance(stype, unicode):
            raise ValueError("service advertisement type must be unicode.")
        self._stype = stype
        if not isinstance(domain, unicode):
            raise ValueError("service advertisement domain must be unicode.")
        self._domain = domain
        self._service = None
        if not isinstance(local, bool):
            raise ValueError("local must be a bool.")
        self._local = local
        self._state = _SA_UNRESOLVED
        self._resolver = None
        self._resolv_tries = 0

    def __del__(self):
        if self._resolver:
            del self._resolver

    def interface(self):
        return self._interface
    def protocol(self):
        return self._protocol
    def name(self):
        return self._name
    def stype(self):
        return self._stype
    def domain(self):
        return self._domain
    def is_local(self):
        return self._local
    def resolv_tries(self):
        return self._resolv_tries
    def inc_resolv_tries(self):
        self._resolv_tries += 1
    def service(self):
        return self._service
    def set_service(self, service):
        if not isinstance(service, Service.Service):
            raise ValueError("must be a valid service.")
        if service != self._service:
            self._service = service
    def resolver(self):
        return self._resolver
    def set_resolver(self, resolver):
        if resolver and not isinstance(resolver, dbus.Interface):
            raise ValueError("'resolver' must be a valid dbus object")
        if not resolver and self._resolver:
            del self._resolver
        self._resolver = resolver
    def state(self):
        return self._state
    def set_state(self, state):
        if state == _SA_RESOLVE_PENDING:
            if self._state == _SA_RESOLVED:
                raise ValueError("Can't reset to resolve pending from resolved.")
        if state == _SA_UNRESOLVED:
            self._resolv_tries = 0
        self._state = state

class RegisteredServiceType(object):
    def __init__(self, stype):
        self._stype = stype
        self._refcount = 1

    def get_type(self):
        return self._stype

    def ref(self):
        self._refcount += 1

    def unref(self):
        self._refcount -= 1
        return self._refcount

def _txt_to_dict(txt):
    """Convert an avahi-returned TXT record formatted
    as nested arrays of integers (from dbus) into a dict
    of key/value string pairs."""
    prop_dict = {}
    props = avahi.txt_array_to_string_array(txt)
    for item in props:
        key = value = None
        if '=' not in item:
            # No = means a boolean value of true
            key = item
            value = True
        else:
            (key, value) = item.split('=', 1)
        prop_dict[key] = value
    return prop_dict


_PRESENCE_SERVICE = "org.laptop.Presence"
_PRESENCE_DBUS_INTERFACE = "org.laptop.Presence"
_PRESENCE_OBJECT_PATH = "/org/laptop/Presence"

class NotFoundError(Exception):
    pass

class PresenceServiceDBusHelper(dbus.service.Object):
    def __init__(self, parent, bus_name):
        self._parent = parent
        self._bus_name = bus_name
        dbus.service.Object.__init__(self, bus_name, _PRESENCE_OBJECT_PATH)

    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
                        signature="o")
    def BuddyAppeared(self, object_path):
        pass

    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
                        signature="o")
    def BuddyDisappeared(self, object_path):
        pass

    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
                        signature="o")
    def ServiceAppeared(self, object_path):
        pass

    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
                        signature="o")
    def ServiceDisappeared(self, object_path):
        pass

    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
                        signature="o")
    def ActivityAppeared(self, object_path):
        pass

    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
                        signature="o")
    def ActivityDisappeared(self, object_path):
        pass

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="", out_signature="ao")
    def getServices(self):
        ret = []
        for serv in self._parent.get_services():
            ret.append(serv.object_path())
        return ret

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="s", out_signature="ao")
    def getServicesOfType(self, stype):
        ret = []
        for serv in self._parent.get_services_of_type(stype):
            ret.append(serv.object_path())
        return ret

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="", out_signature="ao")
    def getActivities(self):
        ret = []
        for act in self._parent.get_activities():
            ret.append(act.object_path())
        return ret

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="s", out_signature="o")
    def getActivity(self, actid):
        act = self._parent.get_activity(actid)
        if not act:
            raise NotFoundError("Not found")
        return act.object_path()

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="", out_signature="ao")
    def getBuddies(self):
        ret = []
        for buddy in self._parent.get_buddies():
            ret.append(buddy.object_path())
        return ret

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="s", out_signature="o")
    def getBuddyByName(self, name):
        buddy = self._parent.get_buddy_by_name(name)
        if not buddy:
            raise NotFoundError("Not found")
        return buddy.object_path()

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="s", out_signature="o")
    def getBuddyByAddress(self, addr):
        buddy = self._parent.get_buddy_by_address(addr)
        if not buddy:
            raise NotFoundError("Not found")
        return buddy.object_path()

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="", out_signature="o")
    def getOwner(self):
        owner = self._parent.get_owner()
        if not owner:
            raise NotFoundError("Not found")
        return owner.object_path()

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="os", out_signature="o",
                        sender_keyword="sender")
    def joinActivity(self, activity_op, stype, sender):
        found_activity = None
        acts = self._parent.get_activities()
        for act in acts:
            if act.object_path() == activity_op:
                found_activity = act
                break
        if not found_activity:
            raise NotFoundError("The activity %s was not found." % activity_op)
        return self._parent.join_activity(found_activity, stype, sender)

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="ssa{ss}sis", out_signature="o",
                        sender_keyword="sender")
    def shareActivity(self, activity_id, stype, properties, address, port,
            domain, sender=None):
        if not len(address):
            address = None
        service = self._parent.share_activity(activity_id, stype, properties, address,
                port, domain, sender)
        return service.object_path()

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="ssa{ss}sis", out_signature="o",
                        sender_keyword="sender")
    def registerService(self, name, stype, properties, address, port, domain,
            sender=None):
        if not len(address):
            address = None
        service = self._parent.register_service(name, stype, properties, address,
                port, domain, sender)
        return service.object_path()

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="o", out_signature="",
                        sender_keyword="sender")
    def unregisterService(self, service_op, sender):
        found_serv = None
        services = self._parent.get_services()
        for serv in services:
            if serv.object_path() == service_op:
                found_serv = serv
                break
        if not found_serv:
            raise NotFoundError("The service %s was not found." % service_op)
        return self._parent.unregister_service(found_serv, sender)

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="s", out_signature="")
    def registerServiceType(self, stype):
        self._parent.register_service_type(stype)

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
                        in_signature="s", out_signature="")
    def unregisterServiceType(self, stype):
        self._parent.unregister_service_type(stype)

    @dbus.service.method(_PRESENCE_DBUS_INTERFACE)
    def start(self):
        self._parent.start()

class PresenceService(object):
    def __init__(self):
        # interface -> IP address: interfaces we've gotten events on so far
        self._started = False
        self._local_addrs = {}

        self._next_object_id = 0

        self._buddies = {}         # nick -> Buddy
        self._services = {}        # (name, type) -> Service
        self._activities = {}    # activity id -> Activity

        # Keep track of stuff we're already browsing
        self._service_type_browsers = {}
        self._service_browsers = {}

        # Resolved service list
        self._service_advs = []

        # Service types we care about resolving
        self._registered_service_types = []

        # Set up the dbus service we provide
        self._session_bus = dbus.SessionBus()
        self._bus_name = dbus.service.BusName(_PRESENCE_SERVICE, bus=self._session_bus)        
        self._dbus_helper = PresenceServiceDBusHelper(self, self._bus_name)

        self._icon_cache = BuddyIconCache.BuddyIconCache()

        # Our owner object
        if profile.get_nick_name():
            objid = self._get_next_object_id()
            self._owner = Buddy.Owner(self, self._bus_name,
                                      objid, self._icon_cache)
            self._buddies[self._owner.get_name()] = self._owner
        else:
            self._owner = None

    def start(self):
        if self._started:
            return
        self._started = True

        # Connect to Avahi for mDNS stuff
        self._system_bus = dbus.SystemBus()
        self._mdns_service = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME,
                avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER)

        # Always browse .local
        self._new_domain_cb(avahi.IF_UNSPEC, avahi.PROTO_INET, "local")

        # Connect to Avahi and start looking for stuff
        domain_browser = self._mdns_service.DomainBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_INET,
                        "", avahi.DOMAIN_BROWSER_BROWSE, dbus.UInt32(0))
        db = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, domain_browser), avahi.DBUS_INTERFACE_DOMAIN_BROWSER)
        db.connect_to_signal('ItemNew', self._new_domain_cb_glue)

    def _get_next_object_id(self):
        """Increment and return the object ID counter."""
        self._next_object_id = self._next_object_id + 1
        return self._next_object_id

    def get_services(self):
        return self._services.values()

    def get_services_of_type(self, stype):
        ret = []
        for serv in self._services.values():
            if serv.get_type() == stype:
                ret.append(serv)
        return ret

    def get_activities(self):
        # Only return valid activities
        ret = []
        for act in self._activities.values():
            if act.is_valid():
                ret.append(act)
        return ret

    def get_activity(self, actid):
        if self._activities.has_key(actid):
            act = self._activities[actid]
            if act.is_valid():
                return act
        return None

    def get_buddies(self):
        buddies = []
        for buddy in self._buddies.values():
            if buddy.is_valid():
                buddies.append(buddy)
        return buddies

    def get_buddy_by_name(self, name):
        if self._buddies.has_key(name):
            if self._buddies[name].is_valid():
                return self._buddies[name]
        return None

    def get_buddy_by_address(self, address):
        for buddy in self._buddies.values():
            if buddy.get_address() == address and buddy.is_valid():
                return buddy
        return None

    def get_owner(self):
        return self._owner

    def _find_service_adv(self, interface=None, protocol=None, name=None,
            stype=None, domain=None, local=None):
        """Search a list of service advertisements for ones matching
        certain criteria."""
        adv_list = []
        for adv in self._service_advs:
            if interface and adv.interface() != interface:
                continue
            if protocol and adv.protocol() != protocol:
                continue
            if name and adv.name() != name:
                continue
            if stype and adv.stype() != stype:
                continue
            if domain and adv.domain() != domain:
                continue
            if local is not None and adv.is_local() != local:
                continue
            adv_list.append(adv)
        return adv_list

    def _find_registered_service_type(self, stype):
        for item in self._registered_service_types:
            if item.get_type() == stype:
                return item
        return None

    def _handle_new_service_for_buddy(self, service, local):
        """Deal with a new discovered service object."""
        # Once a service is resolved, we match it up to an existing buddy,
        # or create a new Buddy if this is the first service known about the buddy
        buddy_was_valid = False
        name = service.get_name()
        buddy = None
        try:
            buddy = self._buddies[name]
            buddy_was_valid = buddy.is_valid()
            service_added = buddy.add_service(service)
            if service_added:
                self._dbus_helper.ServiceAppeared(service.object_path())
        except KeyError:
            source_addr = service.get_source_address()
            objid = self._get_next_object_id()
            buddy = Buddy.Buddy(self._bus_name, objid, service, self._icon_cache)
            self._buddies[name] = buddy
            self._dbus_helper.ServiceAppeared(service.object_path())
        if not buddy_was_valid and buddy.is_valid():
            self._dbus_helper.BuddyAppeared(buddy.object_path())
        return buddy

    def _handle_new_activity_service(self, service):
        # If the serivce is an activity service, merge it into our activities list
        actid = service.get_activity_id()
        if not actid:
            return
        activity = None
        was_valid = False
        if not self._activities.has_key(actid):
            objid = self._get_next_object_id()
            activity = Activity.Activity(self._bus_name, objid, service)
            self._activities[actid] = activity
        else:
            activity = self._activities[actid]
            was_valid = activity.is_valid()

        if activity:
            activity.add_service(service)

            # Add the activity to its buddy
            # FIXME: use something other than name to attribute to buddy
            try:
                buddy = self._buddies[service.get_name()]
                buddy.add_activity(activity)
            except KeyError:
                pass        

        if not was_valid and activity.is_valid():
            self._dbus_helper.ActivityAppeared(activity.object_path())

    def _handle_remove_activity_service(self, service):
        actid = service.get_activity_id()
        if not actid:
            return
        if not self._activities.has_key(actid):
            return

        activity = self._activities[actid]

        activity.remove_service(service)
        if len(activity.get_services()) == 0:
            # Remove the activity from its buddy
            # FIXME: use something other than name to attribute to buddy
            try:
                buddy = self._buddies[service.get_name()]
                buddy.remove_activity(activity)
            except KeyError:
                pass        

            # Kill the activity
            self._dbus_helper.ActivityDisappeared(activity.object_path())
            del self._activities[actid]

    def _service_resolved_cb(self, adv, interface, protocol, full_name,
            stype, domain, host, aprotocol, address, port, txt, flags,
            updated):
        """When the service discovery finally gets here, we've got enough
        information about the service to assign it to a buddy."""
        if updated == False:
            logging.debug("Resolved service '%s' type '%s' domain '%s' to " \
                    " %s:%s" % (full_name, stype, domain, address, port))

        if not adv in self._service_advs:
            return False
        if adv.state() != _SA_RESOLVED:
            return False

        # See if we know about this service already
        service = None
        key = (full_name, stype)
        props = _txt_to_dict(txt)
        if not self._services.has_key(key):
            objid = self._get_next_object_id()
            service = Service.Service(self._bus_name, objid, name=full_name,
                    stype=stype, domain=domain, address=address, port=port,
                    properties=props, source_address=address)
            self._services[key] = service
        else:
            # Already tracking this service; either:
            # a) we were the one that shared it in the first place,
            #     and therefore the source address would not have
            #     been set yet
            # b) the service has been updated
            service = self._services[key]
            if not service.get_source_address():
                service.set_source_address(address)
            if not service.get_address():
                service.set_address(address)

        adv.set_service(service)

        if service and updated:
            service.set_properties(props, from_network=True)
            return False

        # Merge the service into our buddy and activity lists, if needed
        buddy = self._handle_new_service_for_buddy(service, adv.is_local())
        if buddy and service.get_activity_id():
            self._handle_new_activity_service(service)

        return False

    def _service_resolved_cb_glue(self, adv, interface, protocol, name,
            stype, domain, host, aprotocol, address, port, txt, flags):
        # Avahi doesn't flag updates to existing services, so we have
        # to determine that here
        updated = False
        if adv.state() == _SA_RESOLVED:
            updated = True

        adv.set_state(_SA_RESOLVED)
        gobject.idle_add(self._service_resolved_cb, adv, interface,
                protocol, name, stype, domain, host, aprotocol, address,
                port, txt, flags, updated)

    def _service_resolved_failure_cb(self, adv, err):
        retried = False
        adv.set_resolver(None)
        if adv.stype() == Buddy.PRESENCE_SERVICE_TYPE:
            # Retry the presence service type a few times
            if adv.resolv_tries() < 4:
                adv.set_state(_SA_RESOLVE_PENDING)
                gobject.timeout_add(250, self._resolve_service, adv)
                retried = True
                logging.error("Retrying resolution of service %s.%s: %s" % (adv.name(),
                    adv.stype(), err))

        if not retried:
            logging.error("Error resolving service %s.%s: %s" % (adv.name(),
                    adv.stype(), err))
            adv.set_state(_SA_UNRESOLVED)

    def _resolve_service(self, adv):
        """Resolve and lookup a ZeroConf service to obtain its address and TXT records."""
        # Ask avahi to resolve this particular service
        path = self._mdns_service.ServiceResolverNew(dbus.Int32(adv.interface()),
                dbus.Int32(adv.protocol()), adv.name(), adv.stype(), adv.domain(),
                avahi.PROTO_INET, dbus.UInt32(0))
        resolver = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, path),
                            avahi.DBUS_INTERFACE_SERVICE_RESOLVER)
        resolver.connect_to_signal('Found', lambda *args: self._service_resolved_cb_glue(adv, *args))
        resolver.connect_to_signal('Failure', lambda *args: self._service_resolved_failure_cb(adv, *args))
        adv.inc_resolv_tries()
        adv.set_resolver(resolver)
        return False

    def _service_appeared_cb(self, interface, protocol, full_name, stype, domain, flags):
        local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
        adv_list = self._find_service_adv(interface=interface, protocol=protocol,
                name=full_name, stype=stype, domain=domain, local=local)
        adv = None
        if not adv_list:
            adv = ServiceAdv(interface=interface, protocol=protocol, name=full_name,
                    stype=stype, domain=domain, local=local)
            self._service_advs.append(adv)
        else:
            adv = adv_list[0]

        # Decompose service name if we can
        (actid, buddy_name) = Service.decompose_service_name(full_name)

        # If we care about the service right now, resolve it
        resolve = False
        item = self._find_registered_service_type(stype)
        if actid is not None or item is not None:
            resolve = True
        if resolve and adv.state() == _SA_UNRESOLVED:
            logging.debug("Found '%s' (%d) of type '%s' in domain" \
                    " '%s' on %i.%i; will resolve." % (full_name, flags, stype,
                    domain, interface, protocol))
            adv.set_state(_SA_RESOLVE_PENDING)
            gobject.idle_add(self._resolve_service, adv)
            
        return False

    def _service_appeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
        gobject.idle_add(self._service_appeared_cb, interface, protocol, name, stype, domain, flags)

    def _service_disappeared_cb(self, interface, protocol, full_name, stype, domain, flags):
        local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
        # If it's an unresolved service, remove it from our unresolved list
        adv_list = self._find_service_adv(interface=interface, protocol=protocol,
                name=full_name, stype=stype, domain=domain, local=local)
        if not adv_list:
            return False

        # Get the service object; if none, we have nothing left to do
        adv = adv_list[0]
        service = adv.service()
        self._service_advs.remove(adv)
        del adv
        if not service:
            return False

        logging.debug("Service %s.%s in domain %s on %i.%i disappeared." % (full_name,
                stype, domain, interface, protocol))

        self._dbus_helper.ServiceDisappeared(service.object_path())
        self._handle_remove_activity_service(service)

        # Decompose service name if we can
        (actid, buddy_name) = Service.decompose_service_name(full_name)

        # Remove the service from the buddy
        try:
            buddy = self._buddies[buddy_name]
        except KeyError:
            pass
        else:
            buddy.remove_service(service)
            if not buddy.is_valid():
                self._dbus_helper.BuddyDisappeared(buddy.object_path())
                del self._buddies[buddy_name]
        key = (service.get_full_name(), service.get_type())
        del self._services[key]
        return False

    def _service_disappeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
        gobject.idle_add(self._service_disappeared_cb, interface, protocol, name, stype, domain, flags)

    def _new_service_type_cb(self, interface, protocol, stype, domain, flags):
        # Are we already browsing this domain for this type? 
        if self._service_browsers.has_key((interface, protocol, stype, domain)):
            return

        # Start browsing for all services of this type in this domain
        try:
            s_browser = self._mdns_service.ServiceBrowserNew(interface,
                    protocol, stype, domain, dbus.UInt32(0))
            browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, s_browser),
                            avahi.DBUS_INTERFACE_SERVICE_BROWSER)
            browser_obj.connect_to_signal('ItemNew', self._service_appeared_cb_glue)
            browser_obj.connect_to_signal('ItemRemove', self._service_disappeared_cb_glue)

            self._service_browsers[(interface, protocol, stype, domain)] = browser_obj
        except dbus.DBusException:
            logging.debug("Error browsing service type '%s'" % stype)
        return False

    def _new_service_type_cb_glue(self, interface, protocol, stype, domain, flags):
        if len(stype) > 0:
            gobject.idle_add(self._new_service_type_cb, interface, protocol,
                    stype, domain, flags)

    def _new_domain_cb(self, interface, protocol, domain, flags=0):
        """Callback from Avahi when a new domain has been found.  Start
        browsing the new domain."""
        # Only use .local for now...
        if domain != "local":
            return

        # Are we already browsing this domain?
        if self._service_type_browsers.has_key((interface, protocol, domain)):
            return

        # Start browsing this domain for the services its members offer
        try:
            st_browser = self._mdns_service.ServiceTypeBrowserNew(interface, protocol, domain, dbus.UInt32(0))
            browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, st_browser),
                            avahi.DBUS_INTERFACE_SERVICE_TYPE_BROWSER)
        except dbus.DBusException, exc:
            str_exc = str(exc)
            logging.error("got exception %s while attempting to browse domain %s on %i.%i" % (str_exc, domain, interface, protocol))
            if str_exc.find("The name org.freedesktop.Avahi was not provided by any .service files") >= 0:
                raise Exception("Avahi does not appear to be running.  '%s'" % str_exc)
            else:
                raise exc
        logging.debug("Browsing domain '%s' on %i.%i ..." % (domain, interface, protocol))
        browser_obj.connect_to_signal('ItemNew', self._new_service_type_cb_glue)
        self._service_type_browsers[(interface, protocol, domain)] = browser_obj
        return False

    def _new_domain_cb_glue(self, interface, protocol, domain, flags=0):
        gobject.idle_add(self._new_domain_cb, interface, protocol, domain, flags)

    def join_activity(self, activity, stype, sender):
        services = activity.get_services_of_type(stype)
        if not len(services):
            raise NotFoundError("The service type %s was not present within " \
                    "the activity %s" % (stype, activity.object_path()))
        act_service = services[0]
        props = act_service.get_properties()
        color = activity.get_color()
        if color:
            props['color'] = color
        return self._share_activity(activity.get_id(), stype, properties,
                act_service.get_address(), act_service.get_port(),
                act_service.get_domain(), sender)

    def share_activity(self, activity_id, stype, properties=None, address=None,
            port=-1, domain=u"local", sender=None):
        """Convenience function to share an activity with other buddies."""
        if not util.validate_activity_id(activity_id):
            raise ValueError("invalid activity id")
        owner_nick = self._owner.get_name()
        real_name = Service.compose_service_name(owner_nick, activity_id)
        if address and not isinstance(address, unicode):
            raise ValueError("address must be a unicode string.")
        if address == None and stype.endswith('_udp'):
            # Use random currently unassigned multicast address
            address = u"232.%d.%d.%d" % (random.randint(0, 254), random.randint(1, 254),
                    random.randint(1, 254))
            properties['address'] = address
            properties['port'] = port
        if port and port != -1 and (not isinstance(port, int) or port <= 1024 or port >= 65535):
            raise ValueError("port must be a number between 1024 and 65535")
        
        color = self._owner.get_color()
        if color:
            properties['color'] = color

        logging.debug('Share activity %s, type %s, address %s, port %d, " \
                "properties %s' % (activity_id, stype, address, port,
                properties))
        return self.register_service(real_name, stype, properties, address,
                port, domain, sender)

    def register_service(self, name, stype, properties={}, address=None,
            port=-1, domain=u"local", sender=None):
        """Register a new service, advertising it to other Buddies on the network."""
        # Refuse to register if we can't get the dbus connection this request
        # came from for some reason
        if not sender:
            raise RuntimeError("Service registration request must have a sender.")

        (actid, person_name) = Service.decompose_service_name(name)
        if self.get_owner() and person_name != self.get_owner().get_name():
            raise RuntimeError("Tried to register a service that didn't have" \
                    " Owner nick as the service name!")
        if not domain or not len(domain):
            domain = u"local"
        if not port or port == -1:
            port = random.randint(4000, 65000)

        objid = self._get_next_object_id()
        service = Service.Service(self._bus_name, objid, name=name,
                stype=stype, domain=domain, address=address, port=port,
                properties=properties, source_address=None,
                local_publisher=sender)
        self._services[(name, stype)] = service
        self.register_service_type(stype)
        service.register(self._system_bus, self._mdns_service)        
        return service

    def unregister_service(self, service, sender=None):
        service.unregister(sender)

    def register_service_type(self, stype):
        """Requests that the Presence service look for and recognize
        a certain mDNS service types."""
        if not isinstance(stype, unicode):
            raise ValueError("service type must be a unicode string.")

        # If we've already registered it as a service type, ref it and return
        item = self._find_registered_service_type(stype)
        if item is not None:
            item.ref()
            return

        # Otherwise track this type now
        obj = RegisteredServiceType(stype)
        self._registered_service_types.append(obj)

        # Find unresolved services that match the service type
        # we're now interested in, and resolve them
        resolv_list = []

        # Find services of this type
        resolv_list = self._find_service_adv(stype=stype)
        # Request resolution for them if they aren't in-process already
        for adv in resolv_list:
            if adv.state() == _SA_UNRESOLVED:
                adv.set_state(_SA_RESOLVE_PENDING)
                gobject.idle_add(self._resolve_service, adv)

    def unregister_service_type(self, stype):
        """Stop tracking a certain mDNS service."""
        if not isinstance(stype, unicode):
            raise ValueError("service type must be a unicode string.")

        # if it was found, unref it and possibly remove it
        item = self._find_registered_service_type(stype)
        if not item:
            return
        if item.unref() <= 0:
            self._registered_service_types.remove(item)
            del item


def main():
    from sugar import TracebackUtils
    loop = gobject.MainLoop()
    ps = PresenceService()
    tbh = TracebackUtils.TracebackHelper()
    try:
        loop.run()
    except KeyboardInterrupt:
        print 'Ctrl+C pressed, exiting...'

    del tbh


if __name__ == "__main__":
    main()