Setup the activity from the shell process, through dbus,

this simplifies things a lot...

shell/ActivityHost.py

@@ -10,11 +10,10 @@ class ActivityHost:
 		self._xid = xid
 		
 		bus = dbus.SessionBus()
-		service = Activity.ACTIVITY_SERVICE_NAME + "%s" % xid
 		path = Activity.ACTIVITY_SERVICE_PATH + "/%s" % xid
-		proxy_obj = bus.get_object(service, path)
+		proxy_obj = bus.get_object(Activity.ACTIVITY_SERVICE_NAME, path)
 
-		self._activity = dbus.Interface(proxy_obj, 'com.redhat.Sugar.Activity')
+		self._activity = dbus.Interface(proxy_obj, Activity.ACTIVITY_INTERFACE)
 		self._id = self._activity.get_id()
 		self._default_type = self._activity.get_default_type()
 		self._window = gtk.gdk.window_foreign_new(xid)

shell/ActivityRegistry.py

@@ -46,6 +46,13 @@ class ActivityRegistry:
 	def __init__(self):
 		self._activities = []
 
+	def get_activity_from_id(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):
 		"""Returns an activity given his default type"""
 		for activity in self._activities:

shell/HomeWindow.py

@@ -72,16 +72,7 @@ class ActivitiesGrid(gtk.VBox):
 		self._buttons[activity.get_id()] = button
 	
 	def __button_clicked_cb(self, button, info):
-		activity = self._shell.get_registry().get_activity(info.get_type())
+		self._shell.join_activity(info.get_service())
-		
-		activity_id = info.get_service().get_activity_id()
-		pservice = PresenceService()
-		activity_ps = pservice.get_activity(activity_id)
-
-		if activity_ps:
-			ActivityFactory.create(activity.get_id(), activity_ps)
-		else:
-			print 'Cannot start activity.'
 
 class TasksGrid(gtk.VBox):
 	def __init__(self, home):
@@ -168,7 +159,7 @@ class HomeWindow(gtk.Window):
 		return self._shell.get_registry().list_activities()
 
 	def create(self, activity_name):
-		ActivityFactory.create(activity_name)
+		self._shell.start_activity(activity_name)
 
 	def activate(self, activity_window):
 		activity_window.activate(gtk.get_current_event_time())

shell/Shell.py

@@ -1,4 +1,5 @@
 import os
+import logging
 
 import dbus
 import dbus.glib
@@ -12,9 +13,10 @@ from HomeWindow import HomeWindow
 from sugar import env
 from ConsoleWindow import ConsoleWindow
 from Owner import ShellOwner
-from PresenceService import PresenceService
+from sugar.presence.PresenceService import PresenceService
 from ActivityHost import ActivityHost
 from ChatListener import ChatListener
+from sugar.activity import ActivityFactory
 
 class ShellDbusService(dbus.service.Object):
 	def __init__(self, shell, bus_name):
@@ -107,6 +109,30 @@ class Shell:
 			console = self.get_console(module.get_id())
 			activity.show_dialog(console)
 
+	def join_activity(self, service):
+		info = self._registry.get_activity(service.get_type())
+		
+		activity_id = service.get_activity_id()
+		pservice = PresenceService()
+		activity_ps = pservice.get_activity(activity_id)
+
+		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):
+		activity = ActivityFactory.create(activity_name)
+		info = self._registry.get_activity_from_id(activity_name)
+		if info:
+			activity.set_default_type(info.get_default_type())
+			return activity
+		else:
+			logging.error('No such activity in the directory')
+			return None
+	
 	def log(self, module_id, message):
 		console = self.get_console(module_id)
 		console.log(message)

sugar/activity/Activity.py

@@ -6,8 +6,9 @@ import gobject
 from sugar.presence.PresenceService import PresenceService
 import sugar.util
 
-ACTIVITY_SERVICE_NAME = "com.redhat.Sugar.Activity"
+ACTIVITY_SERVICE_NAME = "org.laptop.Activity"
-ACTIVITY_SERVICE_PATH = "/com/redhat/Sugar/Activity"
+ACTIVITY_SERVICE_PATH = "/org/laptop/Activity"
+ACTIVITY_INTERFACE = "org.laptop.Activity"
 
 class ActivityDbusService(dbus.service.Object):
 	"""Base dbus service object that each Activity uses to export dbus methods.
@@ -15,31 +16,46 @@ class ActivityDbusService(dbus.service.Object):
 	The dbus service is separate from the actual Activity object so that we can
 	tightly control what stuff passes through the dbus python bindings."""
 
-	def __init__(self, xid, activity):
+	def __init__(self, pservice, xid, activity):
 		self._activity = activity
+		self._pservice = pservice		
 
 		bus = dbus.SessionBus()
-		service_name = ACTIVITY_SERVICE_NAME + "%s" % xid
+		service_name = ACTIVITY_SERVICE_NAME
-		object_path = ACTIVITY_SERVICE_PATH + "/%s" % xid
+		self._object_path = ACTIVITY_SERVICE_PATH + "/%s" % xid
 		service = dbus.service.BusName(service_name, bus=bus)
-		dbus.service.Object.__init__(self, service, object_path)
+		dbus.service.Object.__init__(self, service, self._object_path)
 
-	@dbus.service.method(ACTIVITY_SERVICE_NAME)
+	def get_object_path(self):
+		return self._object_path
+
+	@dbus.service.method(ACTIVITY_INTERFACE)
 	def share(self):
 		"""Called by the shell to request the activity to share itself on the network."""
 		self._activity.share()
 
-	@dbus.service.method(ACTIVITY_SERVICE_NAME)
+	@dbus.service.method(ACTIVITY_INTERFACE)
+	def join(self, activity_ps_path):
+		"""Join the activity specified by its presence service path"""
+		activity_ps = self._pservice.get(activity_ps_path)
+		return self._activity.join(activity_ps)
+
+	@dbus.service.method(ACTIVITY_INTERFACE)
 	def get_id(self):
 		"""Get the activity identifier"""
 		return self._activity.get_id()
 
-	@dbus.service.method(ACTIVITY_SERVICE_NAME)
+	@dbus.service.method(ACTIVITY_INTERFACE)
 	def get_default_type(self):
 		"""Get the activity default type"""
 		return self._activity.get_default_type()
 
-	@dbus.service.method(ACTIVITY_SERVICE_NAME)
+	@dbus.service.method(ACTIVITY_INTERFACE)
+	def set_default_type(self, default_type):
+		"""Set the activity default type"""
+		self._activity.set_default_type(default_type)
+
+	@dbus.service.method(ACTIVITY_INTERFACE)
 	def get_shared(self):
 		"""Returns True if the activity is shared on the mesh."""
 		return self._activity.get_shared()
@@ -61,12 +77,16 @@ class Activity(gtk.Window):
 		group.realize()
 		self.window.set_group(group.window)
 
-		self._dbus_service = ActivityDbusService(self.window.xid, self)
+		self._bus = ActivityDbusService(self._pservice, self.window.xid, self)
 
 	def __del__(self):
-		if self._dbus_service:
+		if self._bus:
-			del self._dbus_service
+			del self._bus
-			self._dbus_service = None
+			self._bus = None
+
+	def get_object_path(self):
+		"""Returns the path of the activity dbus service"""
+		return self._bus.get_object_path()
 
 	def set_default_type(self, default_type):
 		"""Set the activity default type.

sugar/activity/ActivityFactory.py

@@ -6,9 +6,7 @@ import dbus.service
 import gobject
 
 from sugar.presence.PresenceService import PresenceService
-
+from sugar.activity import Activity
-ACTIVITY_SERVICE_NAME = "com.redhat.Sugar.Activity"
-ACTIVITY_SERVICE_PATH = "/com/redhat/Sugar/Activity"
 
 def get_path(activity_name):
 	"""Returns the activity path"""
@@ -39,23 +37,13 @@ class ActivityFactory(dbus.service.Object):
 		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",
-						 in_signature="o", out_signature="")
-	def create_with_service(self, service_path):
-		pservice = PresenceService()
-		service = pservice.get(service_path)
-
-		activity = self._class()
-		activity.set_default_type(self._default_type)
-		activity.join(service)
-
 	@dbus.service.method("com.redhat.Sugar.ActivityFactory")
 	def create(self):
 		activity = self._class()
 		activity.set_default_type(self._default_type)
+		return activity.get_object_path()	
 
-
+def create(activity_name):
-def create(activity_name, service = None):
 	"""Create a new activity from his name."""
 	bus = dbus.SessionBus()
 
@@ -65,11 +53,13 @@ def create(activity_name, service = None):
 	proxy_obj = bus.get_object(factory_name, factory_path)
 	factory = dbus.Interface(proxy_obj, "com.redhat.Sugar.ActivityFactory")
 
-	if service:
+	activity_path = factory.create()
-		print service.object_path()
+
-		factory.create_with_service(service.object_path())
+	bus = dbus.SessionBus()
-	else:
+	proxy_obj = bus.get_object(Activity.ACTIVITY_SERVICE_NAME, activity_path)
-		factory.create()		
+	activity = dbus.Interface(proxy_obj, Activity.ACTIVITY_INTERFACE)
+
+	return activity
 
 def register_factory(name, activity_class, default_type=None):
 	"""Register the activity factory."""