Get rid of default type from the activity definition.

Modify code to use activity type id instead, except
from mapping service to activity.

activities/browser/BrowserActivity.py

@@ -51,8 +51,7 @@ class BrowserActivity(Activity):
 
 		activity_ps.connect('service-appeared', self._service_appeared_cb)
 
-		default_type = self.get_default_type()
+		services = activity_ps.get_services_of_type(self._default_type)
-		services = activity_ps.get_services_of_type(default_type)
 		if len(services) > 0:
 			self._notif_service = services[0]
 

activities/browser/browser.activity

@@ -3,5 +3,4 @@ name = Web
 id = com.redhat.Sugar.BrowserActivity
 icon = activity-web
 python_module = browser.BrowserActivity.BrowserActivity
-default_type = _web_olpc._udp
 show_launcher = yes

shell/ActivityHost.py

@@ -18,11 +18,11 @@ class ActivityHost:
 
 		self._activity = dbus.Interface(proxy_obj, Activity.ACTIVITY_INTERFACE)
 		self._id = self._activity.get_id()
-		self._default_type = self._activity.get_default_type()
+		self._type = self._activity.get_type()
 		self._gdk_window = gtk.gdk.window_foreign_new(self._xid)
 
 		registry = conf.get_activity_registry()
-		info = registry.get_activity(self._default_type)
+		info = registry.get_activity(self._type)
 		self._icon_name = info.get_icon()
 
 	def get_id(self):
@@ -45,8 +45,8 @@ class ActivityHost:
 	def get_shared(self):
 		return self._activity.get_shared()
 
-	def get_default_type(self):
+	def get_type(self):
-		return self._default_type
+		return self._type
 
 	def present(self):
 		self._window.activate(gtk.get_current_event_time())

shell/Shell.py

@@ -155,12 +155,12 @@ class Shell(gobject.GObject):
 		activity = self.get_current_activity()
 		if activity:
 			registry = conf.get_activity_registry()
-			module = registry.get_activity(activity.get_default_type())
+			module = registry.get_activity(activity.get_type())
 			self._console.set_page(module.get_id())
 
 	def join_activity(self, service):
 		registry = conf.get_activity_registry()
-		info = registry.get_activity(service.get_type())
+		info = registry.get_activity_from_type(service.get_type())
 		
 		activity_id = service.get_activity_id()
 
@@ -172,24 +172,14 @@ class Shell(gobject.GObject):
 
 			if activity_ps:
 				activity = ActivityFactory.create(info.get_id())
-				activity.set_default_type(service.get_type())
 				activity.join(activity_ps.object_path())
 			else:
 				logging.error('Cannot start activity.')
 
-	def start_activity(self, activity_name):
+	def start_activity(self, activity_type):
-		activity = ActivityFactory.create(activity_name)
+		activity = ActivityFactory.create(activity_type)
-		registry = conf.get_activity_registry()
+		activity.execute('test', [])
-		info = registry.get_activity_from_id(activity_name)
+		return activity
-		if info:
-			default_type = info.get_default_type()
-			if default_type != None:
-				activity.set_default_type(default_type)
-				activity.execute('test', [])
-			return activity
-		else:
-			logging.error('No such activity in the directory')
-			return None
 
 	def get_chat_controller(self):
 		return self._chat_controller

shell/frame/BottomPanel.py

@@ -11,7 +11,7 @@ class ActivityItem(IconItem):
 	def __init__(self, activity, size):
 		icon_name = activity.get_icon()
 		if not icon_name:
-			act_type = activity.get_default_type()
+			act_type = activity.get_type()
 			raise RuntimeError("Activity %s did not have an icon!" % act_type)
 		IconItem.__init__(self, icon_name=icon_name,
 						  color=IconColor('white'), size=size)

shell/home/MeshGroup.py

@@ -21,7 +21,7 @@ class ActivityItem(IconItem):
 		
 	def get_icon_name(self):
 		registry = conf.get_activity_registry()
-		info = registry.get_activity(self._service.get_type())
+		info = registry.get_activity_from_type(self._service.get_type())
 
 		return info.get_icon()
 	
@@ -62,7 +62,7 @@ class MeshGroup(goocanvas.Group):
 
 	def __check_service(self, service):
 		registry = conf.get_activity_registry()
-		if registry.get_activity(service.get_type()) != None:
+		if registry.get_activity_from_type(service.get_type()) != None:
 			if not self.has_activity(service.get_activity_id()):
 				self.add_activity(service)
 

sugar/activity/Activity.py

@@ -7,6 +7,7 @@ import gtk
 import gobject
 
 from sugar.presence.PresenceService import PresenceService
+from sugar.conf import ActivityRegistry
 import sugar.util
 
 ACTIVITY_SERVICE_NAME = "org.laptop.Activity"
@@ -47,14 +48,14 @@ class ActivityDbusService(dbus.service.Object):
 		return self._activity.get_id()
 
 	@dbus.service.method(ACTIVITY_INTERFACE)
-	def get_default_type(self):
+	def get_type(self):
-		"""Get the activity default type"""
+		"""Get the activity type"""
-		return self._activity.get_default_type()
+		return self._activity.get_type()
 
 	@dbus.service.method(ACTIVITY_INTERFACE)
-	def set_default_type(self, default_type):
+	def set_type(self, activity_type):
-		"""Set the activity default type"""
+		"""Set the activity type"""
-		self._activity.set_default_type(default_type)
+		self._activity.set_type(activity_type)
 
 	@dbus.service.method(ACTIVITY_INTERFACE)
 	def get_shared(self):
@@ -92,16 +93,14 @@ class Activity(gtk.Window):
 		self._bus = ActivityDbusService(bus_name, get_object_path(xid))
 		self._bus.start(self._pservice, self)
 
-	def set_default_type(self, default_type):
+	def set_type(self, activity_type):
-		"""Set the activity default type.
+		"""Sets the activity type."""
+		self._activity_type = activity_type
+		self._default_type = ActivityRegistry.get_default_type(activity_type)
 
-		It's the type of the main network service which tracks presence
+	def get_type(self):
-		and provides info about the activity, for example the title."""
+		"""Gets the activity type."""
-		self._default_type = default_type
+		return self._activity_type
-
-	def get_default_type(self):
-		"""Get the activity default type."""
-		return self._default_type
 
 	def get_shared(self):
 		"""Returns TRUE if the activity is shared on the mesh."""

sugar/activity/ActivityFactory.py

@@ -19,7 +19,9 @@ def _get_factory(activity_name):
 class ActivityFactory(dbus.service.Object):
 	"""Dbus service that takes care of creating new instances of an activity"""
 
-	def __init__(self, name, activity_class):
+	def __init__(self, activity_type, activity_class):
+		self._activity_type = activity_type
+
 		splitted_module = activity_class.rsplit('.', 1)
 		module_name = splitted_module[0]
 		class_name = splitted_module[1]
@@ -31,13 +33,14 @@ class ActivityFactory(dbus.service.Object):
 		self._class = getattr(module, class_name)
 	
 		bus = dbus.SessionBus()
-		factory = _get_factory(name)
+		factory = _get_factory(activity_type)
 		bus_name = dbus.service.BusName(factory, bus = bus) 
 		dbus.service.Object.__init__(self, bus_name, get_path(factory))
 
 	@dbus.service.method("com.redhat.Sugar.ActivityFactory")
 	def create(self):
 		activity = self._class()
+		activity.set_type(self._activity_type)
 		return activity.window.xid
 
 def create(activity_name):

sugar/conf/ActivityRegistry.py

@@ -5,6 +5,15 @@ from ConfigParser import NoOptionError
 
 from sugar import env
 
+def get_default_type(activity_type):
+	"""Get the activity default type.
+
+	   It's the type of the main network service which tracks presence
+       and provides info about the activity, for example the title."""
+	splitted_id = activity_type.split('.')
+	splitted_id.reverse()
+	return '_' + '_'.join(splitted_id) + '._udp'
+
 class ActivityModule:
 	"""Info about an activity module. Wraps a .activity file."""
 	
@@ -37,7 +46,7 @@ class ActivityModule:
 		
 	def get_default_type(self):
 		"""Get the the type of the default activity service."""
-		return self._default_type
+		return get_default_type(self._id)
 
 	def set_default_type(self, default_type):
 		"""Set the the type of the default activity service."""
@@ -51,21 +60,21 @@ class ActivityModule:
 		"""Set whether there should be a visible launcher for the activity"""
 		self._show_launcher = show_launcher
 
-class ActivityRegistry:
+class _ActivityRegistry:
 	"""Service that tracks the available activities"""
 
 	def __init__(self):
 		self._activities = []
 		self.scan_directory(env.get_activities_dir())
 
-	def get_activity_from_id(self, activity_id):
+	def get_activity(self, activity_id):
 		"""Returns an activity given his identifier"""
 		for activity in self._activities:
 			if activity.get_id() == activity_id:
 				return activity
 		return None
 	
-	def get_activity(self, default_type):
+	def get_activity_from_type(self, default_type):
 		"""Returns an activity given his default type"""
 		for activity in self._activities:
 			if activity.get_default_type() == default_type:
@@ -98,11 +107,6 @@ class ActivityRegistry:
 			logging.error('%s miss the required name option' % (path))
 			return False
 
-		if cp.has_option('Activity', 'default_type'):
-			default_type = cp.get('Activity', 'default_type')
-		else:
-			default_type = None
-
 		module = ActivityModule(name, activity_id, directory)
 		self._activities.append(module)
 
@@ -112,8 +116,6 @@ class ActivityRegistry:
 		if cp.has_option('Activity', 'icon'):
 			module.set_icon(cp.get('Activity', 'icon'))
 
-		module.set_default_type(default_type)
-
 		return True
 
 	def list_activities(self):

sugar/conf/__init__.py

@@ -1,7 +1,7 @@
-from sugar.conf.ActivityRegistry import ActivityRegistry
+from sugar.conf.ActivityRegistry import _ActivityRegistry
 from sugar.conf.Profile import Profile
 
-__registry = ActivityRegistry()
+__registry = _ActivityRegistry()
 __profile = Profile()
 
 def get_activity_registry():