Merge branch 'master' of git+ssh://crank.laptop.org/git/sugar

Conflicts:

	sugar/presence/Buddy.py

3 files changed, 147 insertions, 176 deletions

diff --git a/sugar/presence/Buddy.py b/sugar/presence/Buddy.py
index c3dfae4..6bbd787 100644
--- a/sugar/presence/Buddy.py
+++ b/sugar/presence/Buddy.py
@@ -74,27 +74,27 @@ class Buddy(gobject.GObject):
 		if publisher_addr != self._address:
 			logging.error('Service publisher and buddy address doesnt match: %s %s' % (publisher_addr, self._address))
 			return False
-		full_type = service.get_full_type()
-		if full_type in self._services.keys():
+		stype = service.get_type()
+		if stype in self._services.keys():
 			return False
-		self._services[full_type] = service
+		self._services[stype] = service
 		if self._valid:
 			self.emit("service-added", service)
 
 		# If this is the first service we've seen that's owned  by
 		# a particular activity, send out the 'joined-activity' signal
-		(uid, short_stype) = Service._decompose_service_type(full_type)
-		if uid is not None:
+		actid = service.get_activity_id()
+		if actid is not None:
 			found = False
 			for serv in self._services.values():
-				if serv.get_activity_uid() == uid and serv.get_full_type() != full_type:
+				if serv.get_activity_id() == actid and serv.get_type() != stype:
 					found = True
 					break
 			if not found:
-				print "Buddy (%s) joined activity %s." % (self._nick_name, service.get_activity_uid())
+				print "Buddy (%s) joined activity %s." % (self._nick_name, actid)
 				self.emit("joined-activity", service)
 
-		if full_type == PRESENCE_SERVICE_TYPE:
+		if stype == PRESENCE_SERVICE_TYPE:
 			# A buddy isn't valid until its official presence
 			# service has been found and resolved
 			self._valid = True
@@ -109,47 +109,39 @@ class Buddy(gobject.GObject):
 			return
 		if service.get_name() != self._nick_name:
 			return
-		full_type = service.get_full_type()
-		if self._services.has_key(full_type):
+		stype = service.get_type()
+		if self._services.has_key(stype):
 			if self._valid:
 				self.emit("service-removed", service)
-			del self._services[full_type]
+			del self._services[stype]
 
 		# If this is the lase service owned  by a particular activity,
 		# and it's just been removed, send out the 'left-actvity' signal
-		(uid, short_stype) = Service._decompose_service_type(full_type)
-		if uid is not None:
+		actid = service.get_activity_id()
+		if actid is not None:
 			found = False
 			for serv in self._services.values():
-				if serv.get_activity_uid() == uid:
+				if serv.get_activity_id() == actid:
 					found = True
 					break
 			if not found:
-				print "Buddy (%s) left activity %s." % (self._nick_name, service.get_activity_uid())
+				print "Buddy (%s) left activity %s." % (self._nick_name, actid)
 				self.emit("left-activity", service)
 
-		if full_type == PRESENCE_SERVICE_TYPE:
+		if stype == PRESENCE_SERVICE_TYPE:
 			self._valid = False
 
 	def get_service_of_type(self, stype=None, activity=None):
 		"""Return a service of a certain type, or None if the buddy
 		doesn't provide that service."""
-		short_stype = stype
-		if not short_stype:
+		if not stype:
 			raise RuntimeError("Need to specify a service type.")
-		# Ensure we're only passed short service types
-		(dec_uid, dec_stype) = Service._decompose_service_type(short_stype)
-		if dec_uid:
-			raise RuntimeError("Use plain service types please!")
 
-		uid = None
 		if activity:
-			uid = activity.get_id()
-		if uid is not None:
+			actid = activity.get_id()
 			for service in self._services.values():
-				if service.get_type() == short_stype and service.get_activity_uid() == uid:
+				if service.get_type() == stype and service.get_activity_id() == actid:
 					return service
-		print self._services.keys()
 		if self._services.has_key(short_stype):
 			return self._services[short_stype]
 		return None
diff --git a/sugar/presence/PresenceService.py b/sugar/presence/PresenceService.py
index 6db6e80..a532954 100644
--- a/sugar/presence/PresenceService.py
+++ b/sugar/presence/PresenceService.py
@@ -104,7 +104,7 @@ class PresenceService(gobject.GObject):
 		# Our owner object
 		self._owner = None
 
-		# activity UID -> Service: services grouped by activity UID
+		# activity ID -> Service: services grouped by activity ID
 		self._activity_services = {}
 
 		# All the mdns service types we care about
@@ -122,26 +122,21 @@ class PresenceService(gobject.GObject):
 		self._server = dbus.Interface(self._bus.get_object(avahi.DBUS_NAME,
 				avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER)
 
-	def get_service(self, full_stype):
+	def get_service(self, stype):
 		"""Find a particular service by full service type."""
-		services = self._find_service_adv(stype = full_stype)
+		services = self._find_service_adv(stype=stype)
 		if len(services) > 0:
 			return services[0]
 		else:
 			return None
 
-	def get_activity_service(self, activity, short_stype):
+	def get_activity_service(self, activity, stype):
 		"""Find a particular service by activity and service type."""
-		# Decompose service type if we can
-		(uid, dec_stype) = Service._decompose_service_type(short_stype)
-		if uid:
-			raise RuntimeError("Can only track plain service types!")
-
-		uid = activity.get_id()
-		if self._activity_services.has_key(uid):
-			services = self._activity_services[uid]
+		actid = activity.get_id()
+		if self._activity_services.has_key(actid):
+			services = self._activity_services[actid]
 			for (buddy, service) in services:
-				if service.get_type() == short_stype:
+				if service.get_type() == stype:
 					return service
 		return None
 
@@ -169,7 +164,7 @@ class PresenceService(gobject.GObject):
 	def _resolve_service_error_handler(self, err):
 		logging.error("error resolving service: %s" % err)
 
-	def _find_service_adv(self, interface=None, protocol=None, name=None, stype=None, domain=None, is_short_stype=False):
+	def _find_service_adv(self, interface=None, protocol=None, name=None, stype=None, domain=None):
 		"""Search a list of service advertisements for ones matching certain criteria."""
 		adv_list = []
 		for adv in self._service_advs:
@@ -179,13 +174,8 @@ class PresenceService(gobject.GObject):
 				continue
 			if name and adv.name() != name:
 				continue
-			if is_short_stype:
-				(uid, dec_stype) = Service._decompose_service_type(adv.stype())
-				if uid is None or stype != dec_stype:
-					continue
-			else:
-				if stype and adv.stype() != stype:
-					continue
+			if stype and adv.stype() != stype:
+				continue
 			if domain and adv.domain() != domain:
 				continue
 			adv_list.append(adv)
@@ -229,31 +219,31 @@ class PresenceService(gobject.GObject):
 
 	def _handle_new_service_for_activity(self, service, buddy):
 		# If the serivce is a group service, merge it into our groups list
-		uid = service.get_activity_uid()
-		if not uid:
-			uid = "*"
-		if not self._activity_services.has_key(uid):
-			self._activity_services[uid] = []
-		self._activity_services[uid].append((buddy, service))
+		actid = service.get_activity_id()
+		if not actid:
+			actid = "*"
+		if not self._activity_services.has_key(actid):
+			self._activity_services[actid] = []
+		self._activity_services[actid].append((buddy, service))
 		self.emit('activity-announced', service, buddy)
 
 	def _handle_remove_service_for_activity(self, service, buddy):
-		uid = service.get_activity_uid()
-		if not uid:
-			uid = "*"
-		if self._activity_services.has_key(uid):
+		actid = service.get_activity_id()
+		if not actid:
+			actid = "*"
+		if self._activity_services.has_key(actid):
 			try:
 				self._activity_services.remove((buddy, service))
 			except:
 				pass
 
-	def _resolve_service_reply_cb(self, interface, protocol, name, full_stype, domain, host, aprotocol, address, port, txt, flags):
+	def _resolve_service_reply_cb(self, interface, protocol, full_name, stype, domain, host, aprotocol, address, port, txt, flags):
 		"""When the service discovery finally gets here, we've got enough information about the
 		service to assign it to a buddy."""
-		logging.debug("resolved service '%s' type '%s' domain '%s' to %s:%s" % (name, full_stype, domain, address, port))
+		logging.debug("resolved service '%s' type '%s' domain '%s' to %s:%s" % (full_name, stype, domain, address, port))
 
-		name = name.encode()
-		full_stype = full_stype.encode()
+		full_name = full_name.encode()
+		stype = stype.encode()
 		domain = domain.encode()
 		host = host.encode()
 		address = address.encode()
@@ -261,7 +251,7 @@ class PresenceService(gobject.GObject):
 		# If this service was previously unresolved, remove it from the
 		# unresolved list
 		adv_list = self._find_service_adv(interface=interface, protocol=protocol,
-				name=name, stype=full_stype, domain=domain)
+				name=full_name, stype=stype, domain=domain)
 		if not adv_list:
 			return False
 		adv = adv_list[0]
@@ -270,14 +260,13 @@ class PresenceService(gobject.GObject):
 			self._resolve_queue.remove(adv)
 
 		# Update the service now that it's been resolved
-		service = Service.Service(name=name, stype=full_stype, domain=domain,
+		service = Service.Service(name=full_name, stype=stype, domain=domain,
 				address=address, port=port, properties=txt)
 		adv.set_service(service)
 
 		# Merge the service into our buddy and group lists, if needed
 		buddy = self._handle_new_service_for_buddy(service)
-		uid = service.get_activity_uid()
-		if buddy and uid:
+		if buddy and service.get_activity_id():
 			self._handle_new_service_for_activity(service, buddy)
 
 		return False
@@ -296,16 +285,16 @@ class PresenceService(gobject.GObject):
 				error_handler=self._resolve_service_error_handler)
 		return False
 
-	def _service_appeared_cb(self, interface, protocol, name, full_stype, domain, flags):
-		logging.debug("found service '%s' (%d) of type '%s' in domain '%s' on %i.%i." % (name, flags, full_stype, domain, interface, protocol))
+	def _service_appeared_cb(self, interface, protocol, full_name, stype, domain, flags):
+		logging.debug("found service '%s' (%d) of type '%s' in domain '%s' on %i.%i." % (full_name, flags, stype, domain, interface, protocol))
 
 		# Add the service to our unresolved services list
 		adv_list = self._find_service_adv(interface=interface, protocol=protocol,
-				name=name.encode(), stype=full_stype.encode(), domain=domain.encode())
+				name=full_name.encode(), stype=stype.encode(), domain=domain.encode())
 		adv = None
 		if not adv_list:
-			adv = ServiceAdv(interface=interface, protocol=protocol, name=name.encode(),
-					stype=full_stype.encode(), domain=domain.encode())
+			adv = ServiceAdv(interface=interface, protocol=protocol, name=full_name.encode(),
+					stype=stype.encode(), domain=domain.encode())
 			self._service_advs.append(adv)
 		else:
 			adv = adv_list[0]
@@ -319,37 +308,37 @@ class PresenceService(gobject.GObject):
 					self._local_addrs[interface] = addr
 
 		# Decompose service type if we can
-		(uid, short_stype) = Service._decompose_service_type(full_stype.encode())
+		(actid, buddy_name) = Service._decompose_service_name(full_name.encode())
 
 		# FIXME: find a better way of letting the StartPage get everything
-		self.emit('new-service-adv', uid, short_stype)
+		self.emit('new-service-adv', actid, stype)
 
 		# If we care about the service right now, resolve it
 		resolve = False
-		if uid is not None or short_stype in self._allowed_service_types:
+		if actid is not None or stype in self._allowed_service_types:
 			resolve = True
-		if self._is_special_service_type(short_stype):
+		if self._is_special_service_type(stype):
 			resolve = True
 		if resolve and not adv in self._resolve_queue:
 			self._resolve_queue.append(adv)
 			gobject.idle_add(self._resolve_service, adv)
 		else:
-			logging.debug("Do not resolve service '%s' of type '%s', we don't care about it." % (name, full_stype))
+			logging.debug("Do not resolve service '%s' of type '%s', we don't care about it." % (full_name, stype))
 			
 		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, name, full_stype, domain, flags):
-		logging.debug("service '%s' of type '%s' in domain '%s' on %i.%i disappeared." % (name, full_stype, domain, interface, protocol))
-		name = name.encode()
-		full_stype = full_stype.encode()
+	def _service_disappeared_cb(self, interface, protocol, full_name, stype, domain, flags):
+		logging.debug("service '%s' of type '%s' in domain '%s' on %i.%i disappeared." % (full_name, stype, domain, interface, protocol))
+		full_name = full_name.encode()
+		stype = stype.encode()
 		domain = domain.encode()
 
 		# If it's an unresolved service, remove it from our unresolved list
 		adv_list = self._find_service_adv(interface=interface, protocol=protocol,
-				name=name, stype=full_stype, domain=domain)
+				name=full_name, stype=stype, domain=domain)
 		if not adv_list:
 			return False
 
@@ -361,9 +350,12 @@ class PresenceService(gobject.GObject):
 		if not service:
 			return False
 
+		# Decompose service type if we can
+		(actid, buddy_name) = Service._decompose_service_name(full_name)
+
 		# Remove the service from the buddy
 		try:
-			buddy = self._buddies[name]
+			buddy = self._buddies[buddy_name]
 		except KeyError:
 			pass
 		else:
@@ -371,7 +363,7 @@ class PresenceService(gobject.GObject):
 			self.emit('service-disappeared', buddy, service)
 			if not buddy.is_valid():
 				self.emit("buddy-disappeared", buddy)
-				del self._buddies[name]
+				del self._buddies[buddy_name]
 			self._handle_remove_service_for_activity(service, buddy)
 
 		return False
@@ -427,61 +419,48 @@ class PresenceService(gobject.GObject):
 	def _new_domain_cb_glue(self, interface, protocol, domain, flags=0):
 		gobject.idle_add(self._new_domain_cb, interface, protocol, domain, flags)
 
-	def track_service_type(self, short_stype):
+	def track_service_type(self, stype):
 		"""Requests that the Presence service look for and recognize
 		a certain mDNS service types."""
 		if not self._started:
 			raise RuntimeError("presence service must be started first.")
-		if type(short_stype) == type(u""):
+		if type(stype) == type(u""):
 			raise ValueError("service type should not be unicode.")
-		if type(short_stype) != type(""):
+		if type(stype) != type(""):
 			raise ValueError("service type must be a string.")
-		if self._is_special_service_type(short_stype):
+		if self._is_special_service_type(stype):
 			return
-		if short_stype in self._allowed_service_types:
+		if stype in self._allowed_service_types:
 			return
 
 		# Decompose service type if we can
-		(uid, dec_stype) = Service._decompose_service_type(short_stype)
-		if uid:
-			raise RuntimeError("Can only track plain service types!")
-		self._allowed_service_types.append(dec_stype)
-		self._check_and_resolve_service_advs(dec_stype)
-
-	def _check_and_resolve_service_advs(self, short_stype):
-		"""We should only get called with short service types (ie, not
-		service types that can be decomposed into a UID and a type)."""
+		self._allowed_service_types.append(stype)
+		self._check_and_resolve_service_advs(stype)
+
+	def _check_and_resolve_service_advs(self, stype):
 		# Find unresolved services that match the service type
 		# we're now interested in, and resolve them
 		resolv_list = []
 
-		# Find services of this type belonging to specific activities
-		resolv_list = self._find_service_adv(stype=short_stype, is_short_stype=True)
-		# And also just plain ones of this type
-		resolv_list = resolv_list + self._find_service_adv(stype=short_stype)
-
+		# 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 not in self._resolve_queue:
 				self._resolve_queue.append(adv)
 				gobject.idle_add(self._resolve_service, adv)
 
-	def untrack_service_type(self, short_stype):
+	def untrack_service_type(self, stype):
 		"""Stop tracking a certain mDNS service."""
 		if not self._started:
 			raise RuntimeError("presence service must be started first.")
-		if type(short_stype) == type(u""):
+		if type(stype) == type(u""):
 			raise ValueError("service type should not be unicode.")
-		if not type(short_stype) == type(""):
+		if not type(stype) == type(""):
 			raise ValueError("service type must be a string.")
 
-		# Decompose service type if we can
-		(uid, dec_stype) = Service._decompose_service_type(short_stype)
-		if uid:
-			raise RuntimeError("Can only untrack plain service types!")
-
-		if dec_stype in self._allowed_service_types:
-			self._allowed_service_types.remove(dec_stype)
+		if stype in self._allowed_service_types:
+			self._allowed_service_types.remove(stype)
 
 	def join_shared_activity(self, service):
 		"""Convenience function to join a group and notify other buddies
@@ -494,9 +473,9 @@ class PresenceService(gobject.GObject):
 		"""Convenience function to share an activity with other buddies."""
 		if not self._started:
 			raise RuntimeError("presence service must be started first.")
-		uid = activity.get_id()
+		actid = activity.get_id()
 		owner_nick = self._owner.get_nick_name()
-		real_stype = Service.compose_service_type(stype, uid)
+		real_name = Service.compose_service_name(owner_nick, actid)
 		if address and type(address) != type(""):
 			raise ValueError("address must be a valid string.")
 		if address == None:
@@ -509,8 +488,8 @@ class PresenceService(gobject.GObject):
 			# random port #
 			port = random.randint(5000, 65535)
 
-		logging.debug('Share activity %s, type %s, address %s, port %d, properties %s' % (uid, stype, address, port, properties))
-		service = Service.Service(name=owner_nick, stype=real_stype, domain="local",
+		logging.debug('Share activity %s, type %s, address %s, port %d, properties %s' % (actid, stype, address, port, properties))
+		service = Service.Service(name=real_name, stype=stype, domain="local",
 				address=address, port=port, properties=properties)
 		# Publish it to the world
 		self.register_service(service)
@@ -524,7 +503,10 @@ class PresenceService(gobject.GObject):
 		rs_name = service.get_name()
 		if self.get_owner() and rs_name != self.get_owner().get_nick_name():
 			raise RuntimeError("Tried to register a service that didn't have Owner nick as the service name!")
-		rs_stype = service.get_full_type()
+		actid = service.get_activity_id()
+		if actid:
+			rs_name = Service.compose_service_name(rs_name, actid)
+		rs_stype = service.get_type()
 		rs_port = service.get_port()
 		rs_props = service.get_properties()
 		rs_domain = service.get_domain()
diff --git a/sugar/presence/Service.py b/sugar/presence/Service.py
index 48cc930..56246bb 100644
--- a/sugar/presence/Service.py
+++ b/sugar/presence/Service.py
@@ -19,30 +19,35 @@ def _txt_to_dict(txt):
 		prop_dict[key] = value
 	return prop_dict
 
-def compose_service_type(stype, activity_uid):
-	if not activity_uid:
-		return stype
-	if type(stype) == type(u""):
-		raise ValueError("stype must not be in unicode.")
-	if not stype or type(stype) != type(""):
-		raise ValueError("stype must be a valid string.")
-	composed = "_%s_%s" % (activity_uid, stype)
+def compose_service_name(name, activity_id):
+	if not activity_id:
+		return name
+	if type(name) == type(u""):
+		raise ValueError("name must not be in unicode.")
+	if not name or type(name) != type(""):
+		raise ValueError("name must be a valid string.")
+	composed = "%s [%s]" % (name, activity_id)
 	return composed.encode()
 
-def _decompose_service_type(stype):
-	"""Break a service type into the UID and real service type, if we can."""
-	if len(stype) < util.ACTIVITY_UID_LEN + 5:
-		return (None, stype)
-	if stype[0] != "_":
-		return (None, stype)
-	start = 1
-	end = start + util.ACTIVITY_UID_LEN
-	if stype[end] != "_":
-		return (None, stype)
-	uid = stype[start:end]
-	if not util.validate_activity_uid(uid):
-		return (None, stype)
-	return (uid, stype[end+1:])
+def _decompose_service_name(name):
+	"""Break a service name into the name and activity ID, if we can."""
+	if type(name) != type(""):
+		raise ValueError("name must be a valid string.")
+	name_len = len(name)
+	if name_len < util.ACTIVITY_ID_LEN + 5:
+		return (None, name)
+	# check for activity id end marker
+	if name[name_len - 1] != "]":
+		return (None, name)
+	start = name_len - 1 - util.ACTIVITY_ID_LEN
+	end = name_len - 1
+	# check for activity id start marker
+	if name[start - 1] != "[" or name[start - 2] != " ":
+		return (None, name)
+	activity_id = name[start:end]
+	if not util.validate_activity_id(activity_id):
+		return (None, name)
+	return (activity_id, name[:start - 2])
 
 def is_multicast_address(address):
 	"""Simple numerical check for whether an IP4 address
@@ -61,12 +66,12 @@ def deserialize(sdict):
 		name = sdict['name']
 		if type(name) == type(u""):
 			name = name.encode()
-		full_stype = sdict['full_stype']
-		if type(full_stype) == type(u""):
-			full_stype = full_stype.encode()
-		activity_stype = sdict['activity_stype']
-		if type(activity_stype) == type(u""):
-			activity_stype = activity_stype.encode()
+		stype = sdict['stype']
+		if type(stype) == type(u""):
+			stype = stype.encode()
+		activity_id = sdict['activity_id']
+		if type(activity_id) == type(u""):
+			activity_id = activity_id.encode()
 		domain = sdict['domain']
 		if type(domain) == type(u""):
 			domain = domain.encode()
@@ -82,26 +87,26 @@ def deserialize(sdict):
 			address = address.encode()
 	except KeyError:
 		pass
-	return Service(name, full_stype, domain, address=address,
+	name = compose_service_name(name, activity_id)
+	return Service(name, stype, domain, address=address,
 		port=port, properties=properties)
 
 
-_ACTIVITY_UID_TAG = "ActivityUID"
+_ACTIVITY_ID_TAG = "ActivityID"
 
 class Service(object):
 	"""Encapsulates information about a specific ZeroConf/mDNS
 	service as advertised on the network."""
 	def __init__(self, name, stype, domain, address=None, port=-1, properties=None):
-		full_stype = stype
 		# Validate immutable options
 		if name and type(name) == type(u""):
 			raise ValueError("name must not be in unicode.")
 		if not name or type(name) != type("") or not len(name):
 			raise ValueError("must specify a valid service name.")
 
-		if full_stype and type(full_stype) == type(u""):
+		if stype and type(stype) == type(u""):
 			raise ValueError("service type must not be in unicode.")
-		if not full_stype or type(full_stype) != type("") or not len(full_stype):
+		if not stype or type(stype) != type("") or not len(stype):
 			raise ValueError("must specify a service type.")
 		if not stype.endswith("._tcp") and not stype.endswith("._udp"):
 			raise ValueError("must specify a TCP or UDP service type.")
@@ -113,13 +118,9 @@ class Service(object):
 		if len(domain) and domain != "local":
 			raise ValueError("must use the 'local' domain (for now).")
 
-		(uid, short_stype) = _decompose_service_type(full_stype)
-		if uid and not util.validate_activity_uid(uid):
-			raise ValueError("service type activity uid not a valid activity UID.")
-
-		self._name = name
-		self._full_stype = full_stype
-		self._activity_stype = short_stype
+		(actid, real_name) = _decompose_service_name(name)
+		self._name = real_name
+		self._stype = stype
 		self._domain = domain
 		self._port = -1
 		self.set_port(port)
@@ -134,15 +135,15 @@ class Service(object):
 		else:
 			self.set_address(address)
 
-		# Ensure that an ActivityUID tag, if given, matches
+		# Ensure that an ActivityID tag, if given, matches
 		# what we expect from the service type
-		if self._properties.has_key(_ACTIVITY_UID_TAG):
-			prop_uid = self._properties[_ACTIVITY_UID_TAG]
-			if (prop_uid and not uid) or (prop_uid != uid):
-				raise ValueError("ActivityUID property specified, but the service type's activity UID didn't match it: %s, %s" % (prop_uid, uid))
-		self._activity_uid = uid
-		if uid and not self._properties.has_key(_ACTIVITY_UID_TAG):
-			self._properties[_ACTIVITY_UID_TAG] = uid
+		if self._properties.has_key(_ACTIVITY_ID_TAG):
+			prop_actid = self._properties[_ACTIVITY_ID_TAG]
+			if (prop_actid and not actid) or (prop_actid != actid):
+				raise ValueError("ActivityID property specified, but the service names's activity ID didn't match it: %s, %s" % (prop_actid, actid))
+		self._activity_id = actid
+		if actid and not self._properties.has_key(_ACTIVITY_ID_TAG):
+			self._properties[_ACTIVITY_ID_TAG] = actid
 
 	def serialize(self, owner=None):
 		sdict = {}
@@ -150,8 +151,8 @@ class Service(object):
 			sdict['name'] = dbus.Variant(owner.get_nick_name())
 		else:
 			sdict['name'] = dbus.Variant(self._name)
-		sdict['full_stype'] = dbus.Variant(self._full_stype)
-		sdict['activity_stype'] = dbus.Variant(self._activity_stype)
+		sdict['stype'] = dbus.Variant(self._stype)
+		sdict['activity_id'] = dbus.Variant(self._activity_id)
 		sdict['domain'] = dbus.Variant(self._domain)
 		if self._address:
 			sdict['address'] = dbus.Variant(self._address)
@@ -207,16 +208,12 @@ class Service(object):
 			self._properties[tmp_key] = tmp_val
 
 	def get_type(self):
-		"""Return the service's service type without any activity identifiers."""
-		return self._activity_stype
-
-	def get_full_type(self):
-		"""Return the service's full service type as seen over the network."""
-		return self._full_stype
+		"""Return the service's service type."""
+		return self._stype
 
-	def get_activity_uid(self):
-		"""Return the activity UID this service is associated with, if any."""
-		return self._activity_uid
+	def get_activity_id(self):
+		"""Return the activity ID this service is associated with, if any."""
+		return self._activity_id
 
 	def get_port(self):
 		return self._port