Generate the id in ActivityFactory. I want it to be easy to

run activities without using the shell. Some regression in
the debug messages, which I'll fix as part of further
refactoring.

shell/view/Shell.py

@@ -105,13 +105,11 @@ class Shell(gobject.GObject):
     def get_popup_context(self):
         return self._popup_context
 
-    def _join_success_cb(self, handler, activity, activity_ps, activity_id, activity_type):
-        logging.debug("Joining activity %s (%s)" % (activity_id, activity_type))
+    def _join_success_cb(self, handler, activity, activity_ps):
         activity.join(activity_ps.object_path())
 
-    def _join_error_cb(self, handler, err, home_model, activity_id, activity_type):
-        logging.error("Couldn't launch activity %s (%s):\n%s" % (activity_id, activity_type, err))
-        home_mode.notify_activity_launch_failed(activity_id)
+    def _join_error_cb(self, handler, err, home_model):
+        home_mode.notify_activity_launch_failed(handler.get_activity_id())
 
     def join_activity(self, bundle_id, activity_id):
         activity = self.get_activity(activity_id)
@@ -138,61 +136,26 @@ class Shell(gobject.GObject):
         home_model.notify_activity_launch(activity_id, act_type)
 
         handler = activityfactory.create(act_type)
-        handler.connect('success', self._join_success_cb, activity_ps, activity_id, act_type)
-        handler.connect('error', self._join_error_cb, home_model, activity_id, act_type)
-
-    def _find_unique_activity_id(self):
-        # create a new unique activity ID
-        i = 0
-        act_id = None
-        while i < 10:
-            act_id = sugar.util.unique_id()
-            i += 1
-
-            # check through existing activities
-            found = False
-            for xid, act_host in self._hosts.items():
-                if act_host.get_id() == act_id:
-                    found = True
-                    break
-            if found:
-                act_id = None
-                continue
-
-            # check through network activities
-            activities = self._pservice.get_activities()
-            for act in activities:
-                if act_id == act.get_id():
-                    found = True
-                    break
-            if found:
-                act_id = None
-                continue
-
-        return act_id
-
-    def _start_success_cb(self, handler, activity, activity_id, activity_type):
-        logging.debug("Started activity %s (%s)" % (activity_id, activity_type))
-        activity.start(activity_id)
+        handler.connect('success', self._join_success_cb, activity_ps)
+        handler.connect('error', self._join_error_cb, home_model)
+
+    def _start_success_cb(self, handler, activity):
+        activity.start(handler.get_activity_id())
 
     def _start_error_cb(self, handler, err, home_model, activity_id, activity_type):
-        logging.error("Couldn't launch activity %s (%s):\n%s" % (activity_id, activity_type, err))
-        home_model.notify_activity_launch_failed(activity_id)
+        home_model.notify_activity_launch_failed(handler.get_activity_id())
 
     def start_activity(self, activity_type):
         logging.debug('Shell.start_activity')
-        act_id = self._find_unique_activity_id()
-        if not act_id:
-            logging.error("Couldn't find available activity ID.")
-            return None
+
+        handler = activityfactory.create(activity_type)
 
         home_model = self._model.get_home()
-        home_model.notify_activity_launch(act_id, activity_type)
+        home_model.notify_activity_launch(handler.get_activity_id(),
+                                          activity_type)
 
-        logging.debug("Shell.start_activity will start %s (%s)" % (act_id, activity_type))
-        handler = activityfactory.create(activity_type)
-        handler.connect('success', self._start_success_cb, act_id, activity_type)
-        handler.connect('error', self._start_error_cb, home_model, act_id, activity_type)
+        handler.connect('success', self._start_success_cb)
+        handler.connect('error', self._start_error_cb, home_model)
 
         # Zoom to Home for launch feedback
         self.set_zoom_level(sugar.ZOOM_HOME)

sugar/activity/activityfactory.py

@@ -21,8 +21,9 @@ import dbus
 import gobject
 import gtk
 
-from sugar.presence.PresenceService import PresenceService
+from sugar.presence import PresenceService
 from sugar.activity import bundleregistry
+from sugar import util
 
 _ACTIVITY_SERVICE_NAME = "org.laptop.Activity"
 _ACTIVITY_SERVICE_PATH = "/org/laptop/Activity"
@@ -42,6 +43,10 @@ class ActivityCreationHandler(gobject.GObject):
     def __init__(self, service_name):
         gobject.GObject.__init__(self)
 
+        self._activity_id = self._find_unique_activity_id()
+        if not self._activity_id:
+            raise RuntimeError("Cannot generate activity id.")
+
         registry = bundleregistry.get_registry()
         bundle = registry.get_bundle(service_name)
 
@@ -51,6 +56,32 @@ class ActivityCreationHandler(gobject.GObject):
 
         factory.create(reply_handler=self._reply_handler, error_handler=self._error_handler)
 
+    def get_activity_id(self):
+        return self._activity_id
+
+    def _find_unique_activity_id(self):
+        pservice = PresenceService.get_instance()
+
+        # create a new unique activity ID
+        i = 0
+        act_id = None
+        while i < 10:
+            act_id = util.unique_id()
+            i += 1
+
+            # check through network activities
+            found = False
+            activities = pservice.get_activities()
+            for act in activities:
+                if act_id == act.get_id():
+                    found = True
+                    break
+            if found:
+                act_id = None
+                continue
+
+        return act_id
+
     def _reply_handler(self, xid):
         bus = dbus.SessionBus()
         proxy_obj = bus.get_object(_ACTIVITY_SERVICE_NAME + '%d' % xid,