Use a src directory consistently with base and shell.

9 files changed, 2023 insertions, 0 deletions

diff --git a/src/sugar/activity/Makefile.am b/src/sugar/activity/Makefile.am
new file mode 100644
index 0000000..9dfc8de
--- /dev/null
+++ b/src/sugar/activity/Makefile.am
@@ -0,0 +1,9 @@
+sugardir = $(pythondir)/sugar/activity
+sugar_PYTHON =				\
+	__init__.py			\
+	activity.py			\
+	activityfactory.py		\
+	activityhandle.py		\
+	activityservice.py		\
+	bundlebuilder.py		\
+	registry.py
diff --git a/src/sugar/activity/__init__.py b/src/sugar/activity/__init__.py
new file mode 100644
index 0000000..8a984ad
--- /dev/null
+++ b/src/sugar/activity/__init__.py
@@ -0,0 +1,58 @@
+# Copyright (C) 2006-2007, Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+"""Activity implementation code for Sugar-based activities
+
+Each activity within the OLPC environment must provide two
+dbus services.  The first, patterned after the 
+
+    sugar.activity.activityfactory.ActivityFactory
+
+class is responsible for providing a "create" method which 
+takes a small dictionary with values corresponding to a 
+
+    sugar.activity.activityhandle.ActivityHandle
+
+describing an individual instance of the activity.
+
+Each activity so registered is described by a
+
+    sugar.activity.bundle.Bundle
+
+instance, which parses a specially formatted activity.info 
+file (stored in the activity directory's ./activity 
+subdirectory).  The 
+
+    sugar.activity.bundlebuilder
+
+module provides facilities for the standard setup.py module 
+which produces and registers bundles from activity source 
+directories.
+
+Once instantiated by the ActivityFactory's create method,
+each activity must provide an introspection API patterned 
+after the
+
+    sugar.activity.activityservice.ActivityService
+
+class.  This class allows for querying the ID of the root 
+window, requesting sharing across the network, and basic
+"what type of application are you" queries.
+"""
+from sugar.activity.registry import ActivityRegistry
+from sugar.activity.registry import get_registry
+from sugar.activity.registry import ActivityInfo
diff --git a/src/sugar/activity/__init__py b/src/sugar/activity/__init__py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/sugar/activity/__init__py
diff --git a/src/sugar/activity/activity.py b/src/sugar/activity/activity.py
new file mode 100644
index 0000000..6204354
--- /dev/null
+++ b/src/sugar/activity/activity.py
@@ -0,0 +1,945 @@
+"""Base class for activities written in Python
+
+This is currently the only definitive reference for what an 
+activity must do to participate in the Sugar desktop.
+
+   A Basic Activity
+
+All activities must implement a class derived from 'Activity' in this class.
+The convention is to call it ActivitynameActivity, but this is not required as
+the activity.info file associated with your activity will tell the sugar-shell
+which class to start.
+
+For example the most minimal Activity: 
+
+ 
+   from sugar.activity import activity
+   
+   class ReadActivity(activity.Activity):
+        pass
+
+To get a real, working activity, you will at least have to implement:
+    __init__(), read_file() and write_file()
+
+Aditionally, you will probably need a at least a Toolbar so you can have some
+interesting buttons for the user, like for example 'exit activity'
+
+See the methods of the Activity class below for more information on what you
+will need for a real activity.
+"""
+# Copyright (C) 2006-2007 Red Hat, Inc.
+# Copyright (C) 2007-2008 One Laptop Per Child
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import gettext
+import logging
+import os
+import time
+import tempfile
+from hashlib import sha1
+import traceback
+
+import gtk, gobject
+import dbus
+import dbus.service
+import json
+
+from sugar import util        
+from sugar.presence import presenceservice
+from sugar.activity.activityservice import ActivityService
+from sugar.graphics import style
+from sugar.graphics.window import Window
+from sugar.graphics.toolbox import Toolbox
+from sugar.graphics.toolbutton import ToolButton
+from sugar.graphics.toolcombobox import ToolComboBox
+from sugar.graphics.alert import Alert
+from sugar.graphics.icon import Icon
+from sugar.datastore import datastore
+from sugar import wm
+from sugar import profile
+from sugar import _sugarext
+
+_ = lambda msg: gettext.dgettext('sugar', msg)
+
+SCOPE_PRIVATE = "private"
+SCOPE_INVITE_ONLY = "invite"  # shouldn't be shown in UI, it's implicit
+SCOPE_NEIGHBORHOOD = "public"
+
+J_DBUS_SERVICE = 'org.laptop.Journal'
+J_DBUS_PATH = '/org/laptop/Journal'
+J_DBUS_INTERFACE = 'org.laptop.Journal'
+
+class ActivityToolbar(gtk.Toolbar):
+    """The Activity toolbar with the Journal entry title, sharing,
+       Keep and Stop buttons
+    
+    All activities should have this toolbar. It is easiest to add it to your
+    Activity by using the ActivityToolbox.
+    """
+    def __init__(self, activity):
+        gtk.Toolbar.__init__(self)
+
+        self._activity = activity
+        self._updating_share = False
+
+        activity.connect('shared', self.__activity_shared_cb)
+        activity.connect('joined', self.__activity_shared_cb)
+        activity.connect('notify::max_participants',
+                         self.__max_participants_changed_cb)
+
+        if activity.metadata:
+            self.title = gtk.Entry()
+            self.title.set_size_request(int(gtk.gdk.screen_width() / 6), -1)
+            self.title.set_text(activity.metadata['title'])
+            self.title.connect('changed', self.__title_changed_cb)
+            self._add_widget(self.title)
+
+            activity.metadata.connect('updated', self.__jobject_updated_cb)
+
+        separator = gtk.SeparatorToolItem()
+        separator.props.draw = False
+        separator.set_expand(True)
+        self.insert(separator, -1)
+        separator.show()
+
+        self.share = ToolComboBox(label_text=_('Share with:'))
+        self.share.combo.connect('changed', self.__share_changed_cb)
+        self.share.combo.append_item(SCOPE_PRIVATE, _('Private'), 'zoom-home')
+        self.share.combo.append_item(SCOPE_NEIGHBORHOOD, _('My Neighborhood'),
+                                     'zoom-neighborhood')
+        self.insert(self.share, -1)
+        self.share.show()
+
+        self._update_share()
+
+        self.keep = ToolButton('document-save', tooltip=_('Keep'))
+        self.keep.props.accelerator = '<Ctrl>S'
+        self.keep.connect('clicked', self.__keep_clicked_cb)
+        self.insert(self.keep, -1)
+        self.keep.show()
+
+        self.stop = ToolButton('activity-stop', tooltip=_('Stop'))
+        self.stop.props.accelerator = '<Ctrl>Q'
+        self.stop.connect('clicked', self.__stop_clicked_cb)
+        self.insert(self.stop, -1)
+        self.stop.show()
+
+        self._update_title_sid = None
+
+    def _update_share(self):
+        self._updating_share = True
+
+        if self._activity.props.max_participants == 1:
+            self.share.hide()
+
+        if self._activity.get_shared():
+            self.share.set_sensitive(False)
+            self.share.combo.set_active(1)
+        else:
+            self.share.set_sensitive(True)
+            self.share.combo.set_active(0)
+
+        self._updating_share = False
+    
+    def __share_changed_cb(self, combo):
+        if self._updating_share:
+            return
+
+        model = self.share.combo.get_model()
+        it = self.share.combo.get_active_iter()
+        (scope, ) = model.get(it, 0)
+        if scope == SCOPE_NEIGHBORHOOD:
+            self._activity.share()
+
+    def __keep_clicked_cb(self, button):
+        self._activity.copy()
+
+    def __stop_clicked_cb(self, button):
+        self._activity.take_screenshot()
+        self._activity.close()
+
+    def __jobject_updated_cb(self, jobject):
+        self.title.set_text(jobject['title'])
+
+    def __title_changed_cb(self, entry):
+        if not self._update_title_sid:
+            self._update_title_sid = gobject.timeout_add(
+                                                1000, self.__update_title_cb)
+
+    def __update_title_cb(self):
+        title = self.title.get_text()
+
+        self._activity.metadata['title'] = title
+        self._activity.metadata['title_set_by_user'] = '1'
+        self._activity.save()
+
+        shared_activity = self._activity._shared_activity
+        if shared_activity:
+            shared_activity.props.name = title
+
+        self._update_title_sid = None
+        return False
+
+    def _add_widget(self, widget, expand=False):
+        tool_item = gtk.ToolItem()
+        tool_item.set_expand(expand)
+
+        tool_item.add(widget)
+        widget.show()
+
+        self.insert(tool_item, -1)
+        tool_item.show()
+
+    def __activity_shared_cb(self, activity):
+        self._update_share()
+
+    def __max_participants_changed_cb(self, activity, pspec):
+        self._update_share()
+
+class EditToolbar(gtk.Toolbar):
+    """Provides the standard edit toolbar for Activities.
+ 
+    Members:
+        undo  -- the undo button
+        redo  -- the redo button
+        copy  -- the copy button
+        paste -- the paste button
+        separator -- A separator between undo/redo and copy/paste
+    
+    This class only provides the 'edit' buttons in a standard layout,
+    your activity will need to either hide buttons which make no sense for your
+    Activity, or you need to connect the button events to your own callbacks:
+    
+        ## Example from Read.activity:
+        # Create the edit toolbar:
+        self._edit_toolbar = EditToolbar(self._view)
+        # Hide undo and redo, they're not needed
+        self._edit_toolbar.undo.props.visible = False
+        self._edit_toolbar.redo.props.visible = False
+        # Hide the separator too:
+        self._edit_toolbar.separator.props.visible = False
+        
+        # As long as nothing is selected, copy needs to be insensitive:
+        self._edit_toolbar.copy.set_sensitive(False)
+        # When the user clicks the button, call _edit_toolbar_copy_cb()
+        self._edit_toolbar.copy.connect('clicked', self._edit_toolbar_copy_cb)
+        
+        # Add the edit toolbar:
+        toolbox.add_toolbar(_('Edit'), self._edit_toolbar)
+        # And make it visible:
+        self._edit_toolbar.show()
+    """
+    def __init__(self):
+        gtk.Toolbar.__init__(self)
+
+        self.undo = ToolButton('edit-undo')
+        self.undo.set_tooltip(_('Undo'))
+        self.insert(self.undo, -1)
+        self.undo.show()
+
+        self.redo = ToolButton('edit-redo')
+        self.redo.set_tooltip(_('Redo'))
+        self.insert(self.redo, -1)
+        self.redo.show()
+
+        self.separator = gtk.SeparatorToolItem()
+        self.separator.set_draw(True)
+        self.insert(self.separator, -1)
+        self.separator.show()
+
+        self.copy = ToolButton('edit-copy')
+        self.copy.set_tooltip(_('Copy'))
+        self.insert(self.copy, -1)
+        self.copy.show()
+
+        self.paste = ToolButton('edit-paste')
+        self.paste.set_tooltip(_('Paste'))
+        self.insert(self.paste, -1)
+        self.paste.show()
+
+class ActivityToolbox(Toolbox):
+    """Creates the Toolbox for the Activity
+    
+    By default, the toolbox contains only the ActivityToolbar. After creating
+    the toolbox, you can add your activity specific toolbars, for example the
+    EditToolbar.
+    
+    To add the ActivityToolbox to your Activity in MyActivity.__init__() do:
+    
+        # Create the Toolbar with the ActivityToolbar: 
+        toolbox = activity.ActivityToolbox(self)
+        ... your code, inserting all other toolbars you need, like EditToolbar
+        
+        # Add the toolbox to the activity frame:
+        self.set_toolbox(toolbox)
+        # And make it visible:
+        toolbox.show()
+    """
+    def __init__(self, activity):
+        Toolbox.__init__(self)
+        
+        self._activity_toolbar = ActivityToolbar(activity)
+        self.add_toolbar(_('Activity'), self._activity_toolbar)
+        self._activity_toolbar.show()
+
+    def get_activity_toolbar(self):
+        return self._activity_toolbar
+
+class Activity(Window, gtk.Container):
+    """This is the base Activity class that all other Activities derive from.
+       This is where your activity starts.
+    
+    To get a working Activity:
+        0. Derive your Activity from this class:
+                class MyActivity(activity.Activity):
+                    ...
+                    
+        1. implement an __init__() method for your Activity class.
+        
+           Use your init method to create your own ActivityToolbar which will
+           contain some standard buttons: 
+                toolbox = activity.ActivityToolbox(self)
+           
+           Add extra Toolbars to your toolbox.
+           
+           You should setup Activity sharing here too.
+           
+           Finaly, your Activity may need some resources which you can claim
+           here too.
+           
+           The __init__() method is also used to make the distinction between
+           being resumed from the Journal, or starting with a blank document. 
+           
+        2. Implement read_file() and write_file()
+           Most activities revolve around creating and storing Journal entries.
+           For example, Write: You create a document, it is saved to the Journal
+           and then later you resume working on the document.
+           
+           read_file() and write_file() will be called by sugar to tell your
+           Activity that it should load or save the document the user is working
+           on.
+           
+        3. Implement our Activity Toolbars.
+           The Toolbars are added to your Activity in step 1 (the toolbox), but
+           you need to implement them somewhere. Now is a good time.
+           
+           There are a number of standard Toolbars. The most basic one, the one
+           your almost absolutely MUST have is the ActivityToolbar. Without
+           this, you're not really making a proper Sugar Activity (which may be
+           okay, but you should really stop and think about why not!) You do
+           this with the ActivityToolbox(self) call in step 1. 
+           
+           Usually, you will also need the standard EditToolbar. This is the one
+           which has the standard copy and paste buttons. You need to derive
+           your own EditToolbar class from sugar.EditToolbar:
+                class EditToolbar(activity.EditToolbar):
+                    ...
+                    
+           See EditToolbar for the methods you should implement in your class.
+           
+           Finaly, your Activity will very likely need some activity specific
+           buttons and options you can create your own toolbars by deriving a
+           class from gtk.Toolbar:
+                class MySpecialToolbar(gtk.Toolbar):
+                    ...
+                    
+        4. Use your creativity. Make your Activity something special and share
+           it with your friends!
+           
+    Read through the methods of the Activity class below, to learn more about
+    how to make an Activity work. 
+    
+    Hint: A good and simple Activity to learn from is the Read activity. To
+    create your own activity, you may want to copy it and use it as a template.
+    """
+    __gtype_name__ = 'SugarActivity'
+
+    __gsignals__ = {
+        'shared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
+        'joined': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([]))
+    }
+
+    __gproperties__ = {
+        'active'          : (bool, None, None, False,
+                             gobject.PARAM_READWRITE),
+        'max-participants': (int, None, None, 0, 1000, 0,
+                             gobject.PARAM_READWRITE)
+    }
+
+    def __init__(self, handle, create_jobject=True):
+        """Initialise the Activity 
+        
+        handle -- sugar.activity.activityhandle.ActivityHandle
+            instance providing the activity id and access to the 
+            presence service which *may* provide sharing for this 
+            application
+
+        create_jobject -- boolean
+            define if it should create a journal object if we are
+            not resuming
+
+        Side effects: 
+        
+            Sets the gdk screen DPI setting (resolution) to the 
+            Sugar screen resolution.
+            
+            Connects our "destroy" message to our _destroy_cb
+            method.
+        
+            Creates a base gtk.Window within this window.
+            
+            Creates an ActivityService (self._bus) servicing
+            this application.
+        
+        Usage:        
+            If your Activity implements __init__(), it should call
+            the base class __init()__ before doing Activity specific things.
+            
+        """
+        Window.__init__(self)
+
+        # process titles will only show 15 characters
+        # but they get truncated anyway so if more characters
+        # are supported in the future we will get a better view
+        # of the processes
+        proc_title = "%s <%s>" % (get_bundle_name(), handle.activity_id)
+        util.set_proc_title(proc_title)
+
+        self.connect('realize', self.__realize_cb)
+        self.connect('delete-event', self.__delete_event_cb)
+
+        self._active = False
+        self._activity_id = handle.activity_id
+        self._pservice = presenceservice.get_instance()
+        self._shared_activity = None
+        self._share_id = None
+        self._join_id = None
+        self._preview = _sugarext.Preview()
+        self._updating_jobject = False
+        self._closing = False
+        self._deleting = False
+        self._max_participants = 0
+        self._invites_queue = []
+
+        accel_group = gtk.AccelGroup()
+        self.set_data('sugar-accel-group', accel_group)
+        self.add_accel_group(accel_group)
+
+        self._bus = ActivityService(self)
+        self._owns_file = False
+
+        share_scope = SCOPE_PRIVATE
+
+        if handle.object_id:
+            self._jobject = datastore.get(handle.object_id)
+            # TODO: Don't create so many objects until we have versioning
+            # support in the datastore
+            #self._jobject.object_id = ''
+            #del self._jobject.metadata['ctime']
+            del self._jobject.metadata['mtime']
+            
+            self.set_title(self._jobject.metadata['title'])
+                
+            if self._jobject.metadata.has_key('share-scope'):
+                share_scope = self._jobject.metadata['share-scope']
+
+        elif create_jobject:
+            logging.debug('Creating a jobject.')
+            self._jobject = datastore.create()
+            title = _('%s Activity') % get_bundle_name()
+            self._jobject.metadata['title'] = title
+            self.set_title(self._jobject.metadata['title'])
+            self._jobject.metadata['title_set_by_user'] = '0'
+            self._jobject.metadata['activity'] = self.get_bundle_id()
+            self._jobject.metadata['activity_id'] = self.get_id()
+            self._jobject.metadata['keep'] = '0'
+            self._jobject.metadata['preview'] = ''
+            self._jobject.metadata['share-scope'] = SCOPE_PRIVATE
+
+            if self._shared_activity is not None:
+                icon_color = self._shared_activity.props.color
+            else:
+                icon_color = profile.get_color().to_string()
+
+            self._jobject.metadata['icon-color'] = icon_color
+
+            self._jobject.file_path = ''
+            # Cannot call datastore.write async for creates:
+            # https://dev.laptop.org/ticket/3071
+            datastore.write(self._jobject)
+        else:
+            self._jobject = None
+
+        # handle activity share/join
+        mesh_instance = self._pservice.get_activity(self._activity_id,
+                                                    warn_if_none=False)
+        logging.debug("*** Act %s, mesh instance %r, scope %s",
+                      self._activity_id, mesh_instance, share_scope)
+        if mesh_instance is not None:
+            # There's already an instance on the mesh, join it
+            logging.debug("*** Act %s joining existing mesh instance %r",
+                          self._activity_id, mesh_instance)
+            self._shared_activity = mesh_instance
+            self._shared_activity.connect('notify::private',
+                    self.__privacy_changed_cb)
+            self._join_id = self._shared_activity.connect(
+                                                    "joined", self.__joined_cb)
+            if not self._shared_activity.props.joined:
+                self._shared_activity.join()
+            else:
+                self.__joined_cb(self._shared_activity, True, None)
+        elif share_scope != SCOPE_PRIVATE:
+            logging.debug("*** Act %s no existing mesh instance, but used to " \
+                          "be shared, will share" % self._activity_id)
+            # no existing mesh instance, but activity used to be shared, so
+            # restart the share
+            if share_scope == SCOPE_INVITE_ONLY:
+                self.share(private=True)
+            elif share_scope == SCOPE_NEIGHBORHOOD:
+                self.share(private=False)
+            else:
+                logging.debug("Unknown share scope %r" % share_scope)
+
+    def do_set_property(self, pspec, value):
+        if pspec.name == 'active':
+            if self._active != value:
+                self._active = value
+                if not self._active and self._jobject:
+                    self.save()
+        elif pspec.name == 'max-participants':
+            self._max_participants = value
+        else:
+            Window.do_set_property(self, pspec, value)
+
+    def do_get_property(self, pspec):
+        if pspec.name == 'active':
+            return self._active
+        elif pspec.name == 'max-participants':
+            return self._max_participants
+        else:
+            return Window.do_get_property(self, pspec)
+
+    def get_id(self):
+        """Returns the activity id of the current instance of your activity.
+        
+        The activity id is sort-of-like the unix process id (PID). However,
+        unlike PIDs it is only different for each new instance (with
+        create_jobject = True set) and stays the same everytime a user
+        resumes an activity. This is also the identity of your Activity to other
+        XOs for use when sharing.
+        """
+        return self._activity_id
+
+    def get_bundle_id(self):
+        """Returns the bundle_id from the activity.info file"""
+        return os.environ['SUGAR_BUNDLE_ID']
+
+    def set_canvas(self, canvas):
+        """Sets the 'work area' of your activity with the canvas of your choice.
+        
+        One commonly used canvas is gtk.ScrolledWindow
+        """
+        Window.set_canvas(self, canvas)
+        canvas.connect('map', self.__canvas_map_cb)
+
+    def __canvas_map_cb(self, canvas):
+        if self._jobject and self._jobject.file_path:
+            self.read_file(self._jobject.file_path)
+
+    def __jobject_create_cb(self):
+        pass
+
+    def __jobject_error_cb(self, err):
+        logging.debug("Error creating activity datastore object: %s" % err)
+
+    def get_activity_root(self):
+        """ FIXME: Deprecated. This part of the API has been moved 
+        out of this class to the module itself
+
+        Returns a path for saving Activity specific preferences, etc.
+        
+        Returns a path to the location in the filesystem where the activity can
+        store activity related data that doesn't pertain to the current
+        execution of the activity and thus cannot go into the DataStore.
+        
+        Currently, this will return something like
+        ~/.sugar/default/MyActivityName/
+        
+        Activities should ONLY save settings, user preferences and other data
+        which isn't specific to a journal item here. If (meta-)data is in anyway
+        specific to a journal entry, it MUST be stored in the DataStore.        
+        """
+        if os.environ.has_key('SUGAR_ACTIVITY_ROOT') and \
+           os.environ['SUGAR_ACTIVITY_ROOT']:
+            return os.environ['SUGAR_ACTIVITY_ROOT']
+        else:
+            return '/'
+
+    def read_file(self, file_path):
+        """
+        Subclasses implement this method if they support resuming objects from
+        the journal. 'file_path' is the file to read from.
+        
+        You should immediately open the file from the file_path, because the
+        file_name will be deleted immediately after returning from read_file().
+        Once the file has been opened, you do not have to read it immediately:
+        After you have opened it, the file will only be really gone when you
+        close it.
+        
+        Although not required, this is also a good time to read all meta-data:
+        the file itself cannot be changed externally, but the title, description
+        and other metadata['tags'] may change. So if it is important for you to
+        notice changes, this is the time to record the originals.        
+        """
+        raise NotImplementedError
+
+    def write_file(self, file_path):
+        """
+        Subclasses implement this method if they support saving data to objects
+        in the journal. 'file_path' is the file to write to.
+        
+        If the user did make changes, you should create the file_path and save
+        all document data to it.
+        
+        Additionally, you should also write any metadata needed to resume your
+        activity. For example, the Read activity saves the current page and zoom
+        level, so it can display the page.
+        
+        Note: Currently, the file_path *WILL* be different from the one you
+        received in file_read(). Even if you kept the file_path from file_read()
+        open until now, you must still write the entire file to this file_path.     
+        """
+        raise NotImplementedError
+
+    def __save_cb(self):
+        logging.debug('Activity.__save_cb')
+        self._updating_jobject = False
+        if self._closing:
+            self._cleanup_jobject()
+            self.destroy()
+
+    def __save_error_cb(self, err):
+        logging.debug('Activity.__save_error_cb')
+        self._updating_jobject = False
+        if self._closing:
+            self._cleanup_jobject()
+            self.destroy()
+        logging.debug("Error saving activity object to datastore: %s" % err)
+
+    def _cleanup_jobject(self):
+        if self._jobject:
+            if self._owns_file and os.path.isfile(self._jobject.file_path):
+                logging.debug('_cleanup_jobject: removing %r' %
+                              self._jobject.file_path)
+                os.remove(self._jobject.file_path)
+            self._owns_file = False
+            self._jobject.destroy()
+            self._jobject = None
+
+    def _get_preview(self):
+        pixbuf = self._preview.get_pixbuf()
+        if pixbuf is None:
+            return None
+
+        pixbuf = pixbuf.scale_simple(style.zoom(300), style.zoom(225),
+                                     gtk.gdk.INTERP_BILINEAR)
+
+        # TODO: Find a way of taking a png out of the pixbuf without saving
+        # to a temp file. Impementing gtk.gdk.Pixbuf.save_to_buffer in pygtk
+        # would solve this.
+        fd, file_path = tempfile.mkstemp('.png')
+        os.close(fd)
+
+        pixbuf.save(file_path, 'png')
+        f = open(file_path)
+        try:
+            preview_data = f.read()
+        finally:
+            f.close()
+            os.remove(file_path)
+
+        self._preview.clear()
+
+        return preview_data
+
+    def _get_buddies(self):
+        if self._shared_activity is not None:
+            buddies = {}
+            for buddy in self._shared_activity.get_joined_buddies():
+                if not buddy.props.owner:
+                    buddy_id = sha1(buddy.props.key).hexdigest()
+                    buddies[buddy_id] = [buddy.props.nick, buddy.props.color]
+            return buddies
+        else:
+            return {}
+
+    def take_screenshot(self):
+        if self.canvas and self.canvas.window:
+            self._preview.take_screenshot(self.canvas.window)
+
+    def save(self):
+        """Request that the activity is saved to the Journal.
+        
+        This method is called by the close() method below. In general,
+        activities should not override this method. This method is part of the
+        public API of an Acivity, and should behave in standard ways. Use your
+        own implementation of write_file() to save your Activity specific data.        
+        """
+
+        logging.debug('Activity.save: %r' % self._jobject.object_id)
+
+        if self._updating_jobject:
+            logging.info('Activity.save: still processing a previous request.')
+            return
+
+        buddies_dict = self._get_buddies()
+        if buddies_dict:
+            self.metadata['buddies_id'] = json.write(buddies_dict.keys())
+            self.metadata['buddies'] = json.write(self._get_buddies())
+
+        preview = self._get_preview()
+        if self._preview:
+            self.metadata['preview'] = dbus.ByteArray(preview)
+
+        try:
+            file_path = os.path.join(self.get_activity_root(), 'instance',
+                                        '%i' % time.time())
+            self.write_file(file_path)
+            self._owns_file = True
+            self._jobject.file_path = file_path
+        except NotImplementedError:
+            logging.debug('Activity.write_file is not implemented.')
+
+        # Cannot call datastore.write async for creates:
+        # https://dev.laptop.org/ticket/3071
+        if self._jobject.object_id is None:
+            datastore.write(self._jobject, transfer_ownership=True)
+        else:
+            self._updating_jobject = True
+            datastore.write(self._jobject,
+                    transfer_ownership=True,
+                    reply_handler=self.__save_cb,
+                    error_handler=self.__save_error_cb)
+
+    def copy(self):
+        """Request that the activity 'Keep in Journal' the current state
+           of the activity.
+        
+        Activities should not override this method. Instead, like save() do any
+        copy work that needs to be done in write_file()
+        """
+        logging.debug('Activity.copy: %r' % self._jobject.object_id)
+        self.save()
+        self._jobject.object_id = None
+
+    def __privacy_changed_cb(self, shared_activity, param_spec):
+        if shared_activity.props.private:
+            self._jobject.metadata['share-scope'] = SCOPE_INVITE_ONLY
+        else:
+            self._jobject.metadata['share-scope'] = SCOPE_NEIGHBORHOOD
+
+    def __joined_cb(self, activity, success, err):
+        """Callback when join has finished"""
+        self._shared_activity.disconnect(self._join_id)
+        self._join_id = None
+        if not success:
+            logging.debug("Failed to join activity: %s" % err)
+            return
+
+        self.present()
+        self.emit('joined')
+        self.__privacy_changed_cb(self._shared_activity, None)
+
+    def get_shared(self):
+        """Returns TRUE if the activity is shared on the mesh."""
+        if not self._shared_activity:
+            return False
+        return self._shared_activity.props.joined
+
+    def __share_cb(self, ps, success, activity, err):
+        self._pservice.disconnect(self._share_id)
+        self._share_id = None
+        if not success:
+            logging.debug('Share of activity %s failed: %s.' %
+                          (self._activity_id, err))
+            return
+
+        logging.debug('Share of activity %s successful, PS activity is %r.',
+                      self._activity_id, activity)
+
+        activity.props.name = self._jobject.metadata['title']
+
+        self._shared_activity = activity
+        self._shared_activity.connect('notify::private',
+                self.__privacy_changed_cb)
+        self.emit('shared')
+        self.__privacy_changed_cb(self._shared_activity, None)
+
+        self._send_invites()
+
+    def _invite_response_cb(self, error):
+        if error:
+            logging.error('Invite failed: %s' % error)
+
+    def _send_invites(self):
+        while self._invites_queue:
+            buddy_key = self._invites_queue.pop()             
+            buddy = self._pservice.get_buddy(buddy_key)
+            if buddy:
+                self._shared_activity.invite(
+                            buddy, '', self._invite_response_cb)
+            else:
+                logging.error('Cannot invite %s, no such buddy.' % buddy_key)
+
+    def invite(self, buddy_key):
+        """Invite a buddy to join this Activity.
+        
+        Side Effects:
+            Calls self.share(True) to privately share the activity if it wasn't
+            shared before.            
+        """
+        self._invites_queue.append(buddy_key)
+
+        if (self._shared_activity is None
+            or not self._shared_activity.props.joined):
+            self.share(True)
+        else:
+            self._send_invites()
+
+    def share(self, private=False):
+        """Request that the activity be shared on the network.
+        
+        private -- bool: True to share by invitation only,
+            False to advertise as shared to everyone.
+
+        Once the activity is shared, its privacy can be changed by setting
+        its 'private' property.
+        """
+        if self._shared_activity and self._shared_activity.props.joined:
+            raise RuntimeError("Activity %s already shared." %
+                               self._activity_id)
+        verb = private and 'private' or 'public'
+        logging.debug('Requesting %s share of activity %s.' %
+                      (verb, self._activity_id))
+        self._share_id = self._pservice.connect("activity-shared", 
+                                                self.__share_cb)
+        self._pservice.share_activity(self, private=private)
+
+    def _display_keep_failed_dialog(self):
+        alert = Alert()
+        alert.props.title = _('Keep error')
+        alert.props.msg = _('Keep error: all changes will be lost')
+
+        cancel_icon = Icon(icon_name='dialog-cancel')
+        alert.add_button(gtk.RESPONSE_CANCEL, _('Don\'t stop'), cancel_icon)
+
+        stop_icon = Icon(icon_name='dialog-ok')
+        alert.add_button(gtk.RESPONSE_OK, _('Stop anyway'), stop_icon)
+
+        self.add_alert(alert)
+        alert.connect('response', self._keep_failed_dialog_response_cb)
+
+    def _keep_failed_dialog_response_cb(self, alert, response_id):
+        self.remove_alert(alert)
+        if response_id == gtk.RESPONSE_OK:
+            self.close(skip_save=True)
+
+    def can_close(self):
+        """Activities should override this function if they want to perform
+        extra checks before actually closing."""
+
+        return True
+
+    def close(self, force=False, skip_save=False):
+        """Request that the activity be stopped and saved to the Journal
+        
+        Activities should not override this method, but should implement
+        write_file() to do any state saving instead. If the application wants
+        to control wether it can close, it should override can_close().
+        """
+
+        if not force:
+            if not self.can_close():
+                return
+
+        try:
+            if not skip_save:
+                self.save()
+        except Exception:
+            logging.info(traceback.format_exc())
+            self._display_keep_failed_dialog()
+            return
+
+        if self._shared_activity:
+            self._shared_activity.leave()
+
+        if self._updating_jobject:
+            self._closing = True
+        else:
+            self.destroy()
+
+        # Make the exported object inaccessible
+        dbus.service.Object.remove_from_connection(self._bus)
+
+    def __realize_cb(self, window):
+        wm.set_bundle_id(window.window, self.get_bundle_id())
+        wm.set_activity_id(window.window, str(self._activity_id))
+
+    def __delete_event_cb(self, widget, event):
+        self.close()
+        return True
+
+    def get_metadata(self):
+        """Returns the jobject metadata or None if there is no jobject.
+        
+        Activities can set metadata in write_file() using:                    
+            self.metadata['MyKey'] = "Something"
+            
+        and retrieve metadata in read_file() using:        
+            self.metadata.get('MyKey', 'aDefaultValue')
+                
+        Note: Make sure your activity works properly if one or more of the
+        metadata items is missing. Never assume they will all be present.
+        """
+        if self._jobject:
+            return self._jobject.metadata
+        else:
+            return None
+
+    metadata = property(get_metadata, None)
+
+def get_bundle_name():
+    """Return the bundle name for the current process' bundle"""
+    return os.environ['SUGAR_BUNDLE_NAME']
+    
+def get_bundle_path():
+    """Return the bundle path for the current process' bundle"""
+    return os.environ['SUGAR_BUNDLE_PATH']
+
+def get_activity_root():
+    """Returns a path for saving Activity specific preferences, etc."""
+    if os.environ.has_key('SUGAR_ACTIVITY_ROOT') and \
+            os.environ['SUGAR_ACTIVITY_ROOT']:
+        return os.environ['SUGAR_ACTIVITY_ROOT']
+    else:
+        raise RuntimeError("No SUGAR_ACTIVITY_ROOT set.")
+
+def show_object_in_journal(object_id):
+    bus = dbus.SessionBus()
+    obj = bus.get_object(J_DBUS_SERVICE, J_DBUS_PATH)
+    journal = dbus.Interface(obj, J_DBUS_INTERFACE)
+    journal.ShowObject(object_id)
diff --git a/src/sugar/activity/activityfactory.py b/src/sugar/activity/activityfactory.py
new file mode 100644
index 0000000..42b8c40
--- /dev/null
+++ b/src/sugar/activity/activityfactory.py
@@ -0,0 +1,316 @@
+"""Shell side object which manages request to start activity"""
+# Copyright (C) 2006-2007 Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import logging
+import subprocess
+import signal
+
+import dbus
+import gobject
+
+from sugar.presence import presenceservice
+from sugar.activity.activityhandle import ActivityHandle
+from sugar.activity import registry
+from sugar import util
+from sugar import env
+
+from errno import EEXIST
+
+import os
+
+# #3903 - this constant can be removed and assumed to be 1 when dbus-python
+# 0.82.3 is the only version used
+if dbus.version >= (0, 82, 3):
+    DBUS_PYTHON_TIMEOUT_UNITS_PER_SECOND = 1
+else:
+    DBUS_PYTHON_TIMEOUT_UNITS_PER_SECOND = 1000
+
+_SHELL_SERVICE = "org.laptop.Shell"
+_SHELL_PATH = "/org/laptop/Shell"
+_SHELL_IFACE = "org.laptop.Shell"
+
+_DS_SERVICE = "org.laptop.sugar.DataStore"
+_DS_INTERFACE = "org.laptop.sugar.DataStore"
+_DS_PATH = "/org/laptop/sugar/DataStore"
+
+_ACTIVITY_FACTORY_INTERFACE = "org.laptop.ActivityFactory"
+
+_RAINBOW_SERVICE_NAME = "org.laptop.security.Rainbow"
+_RAINBOW_ACTIVITY_FACTORY_PATH = "/"
+_RAINBOW_ACTIVITY_FACTORY_INTERFACE = "org.laptop.security.Rainbow"
+
+_children_pid = []
+
+def _sigchild_handler(signum, frame):
+    for child_pid in _children_pid:
+        pid, status_ = os.waitpid(child_pid, os.WNOHANG)
+        if pid > 0:
+            _children_pid.remove(pid)
+
+signal.signal(signal.SIGCHLD, _sigchild_handler)
+
+def create_activity_id():
+    """Generate a new, unique ID for this activity"""
+    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.props.id:
+                found = True
+                break
+        if not found:
+            return act_id
+    raise RuntimeError("Cannot generate unique activity id.")
+
+def get_environment(activity):
+    environ = os.environ.copy()
+
+    bin_path = os.path.join(activity.path, 'bin')
+
+    activity_root = env.get_profile_path(activity.bundle_id)
+    if not os.path.exists(activity_root):
+        os.mkdir(activity_root)
+
+    data_dir = os.path.join(activity_root, 'instance')
+    if not os.path.exists(data_dir):
+        os.mkdir(data_dir)
+
+    data_dir = os.path.join(activity_root, 'data')
+    if not os.path.exists(data_dir):
+        os.mkdir(data_dir)
+
+    tmp_dir = os.path.join(activity_root, 'tmp')
+    if not os.path.exists(tmp_dir):
+        os.mkdir(tmp_dir)
+
+    environ['SUGAR_BUNDLE_PATH'] = activity.path
+    environ['SUGAR_BUNDLE_ID']   = activity.bundle_id
+    environ['SUGAR_ACTIVITY_ROOT'] = activity_root
+    environ['PATH'] = bin_path + ':' + environ['PATH']
+    #environ['RAINBOW_STRACE_LOG'] = '1'
+
+    if activity.bundle_id in [ 'org.laptop.WebActivity', 
+                               'org.laptop.GmailActivity',
+                               'org.laptop.WikiBrowseActivity'
+                               ]:
+        environ['RAINBOW_CONSTANT_UID'] = 'yes'
+
+    return environ
+
+def get_command(activity, activity_id=None, object_id=None, uri=None):
+    if not activity_id:
+        activity_id = create_activity_id()
+
+    command = activity.command.split(' ')
+    command.extend(['-b', activity.bundle_id])
+    command.extend(['-a', activity_id])
+
+    if object_id is not None:
+        command.extend(['-o', object_id])
+    if uri is not None:
+        command.extend(['-u', uri])
+
+    print command
+
+    return command
+
+def open_log_file(activity):
+    i = 1
+    while True:
+        path = env.get_logs_path('%s-%s.log' % (activity.bundle_id, i))
+        try:
+            fd = os.open(path, os.O_EXCL | os.O_CREAT \
+                             | os.O_SYNC | os.O_WRONLY, 0644)
+            f = os.fdopen(fd, 'w', 0)
+            return (path, f)
+        except OSError, e:
+            if e.errno == EEXIST:
+                i += 1
+            else:
+                raise e
+
+class ActivityCreationHandler(gobject.GObject):
+    """Sugar-side activity creation interface
+
+    This object uses a dbus method on the ActivityFactory
+    service to create the new activity.  It generates
+    GObject events in response to the success/failure of
+    activity startup using callbacks to the service's
+    create call.
+    """
+
+    def __init__(self, service_name, handle):
+        """Initialise the handler
+
+        service_name -- the service name of the bundle factory
+        activity_handle -- stores the values which are to
+            be passed to the service to uniquely identify
+            the activity to be created and the sharing
+            service that may or may not be connected with it
+
+            sugar.activity.activityhandle.ActivityHandle instance
+
+        calls the "create" method on the service for this
+        particular activity type and registers the
+        _reply_handler and _error_handler methods on that
+        call's results.
+
+        The specific service which creates new instances of this
+        particular type of activity is created during the activity
+        registration process in shell bundle registry which creates
+        service definition files for each registered bundle type.
+
+        If the file '/etc/olpc-security' exists, then activity launching
+        will be delegated to the prototype 'Rainbow' security service.
+        """
+        gobject.GObject.__init__(self)
+
+        self._service_name = service_name
+        self._handle = handle
+
+        self._use_rainbow = os.path.exists('/etc/olpc-security')
+        if service_name in [ 'org.laptop.JournalActivity',
+                             'org.laptop.Terminal',
+                             'org.laptop.LogViewer',
+                             'org.laptop.Analyze'
+                             ]:
+            self._use_rainbow = False                    
+    
+        bus = dbus.SessionBus()
+
+        bus_object = bus.get_object(_SHELL_SERVICE, _SHELL_PATH)
+        self._shell = dbus.Interface(bus_object, _SHELL_IFACE)
+
+        if handle.activity_id is not None and \
+           handle.object_id is None:
+            datastore = dbus.Interface(
+                    bus.get_object(_DS_SERVICE, _DS_PATH), _DS_INTERFACE)
+            datastore.find({ 'activity_id': self._handle.activity_id }, [],
+                           reply_handler=self._find_object_reply_handler,
+                           error_handler=self._find_object_error_handler)
+        else:
+            self._launch_activity()
+
+    def _launch_activity(self):
+        if self._handle.activity_id != None:
+            self._shell.ActivateActivity(self._handle.activity_id,
+                        reply_handler=self._activate_reply_handler,
+                        error_handler=self._activate_error_handler)
+        else:
+            self._create_activity()
+
+    def _create_activity(self):
+        if self._handle.activity_id is None:
+            self._handle.activity_id = create_activity_id()
+
+        self._shell.NotifyLaunch(
+                    self._service_name, self._handle.activity_id,
+                    reply_handler=self._no_reply_handler,
+                    error_handler=self._notify_launch_error_handler)
+
+        activity_registry = registry.get_registry()
+        activity = activity_registry.get_activity(self._service_name)
+        if activity:
+            environ = get_environment(activity)
+            (log_path, log_file) = open_log_file(activity)
+            command = get_command(activity, self._handle.activity_id,
+                                  self._handle.object_id,
+                                  self._handle.uri)
+
+            if not self._use_rainbow:
+                p = subprocess.Popen(command, env=environ, cwd=activity.path,
+                                     stdout=log_file, stderr=log_file)
+                _children_pid.append(p.pid)
+            else:
+                log_file.close()
+                system_bus = dbus.SystemBus()
+                factory = system_bus.get_object(_RAINBOW_SERVICE_NAME,
+                                                _RAINBOW_ACTIVITY_FACTORY_PATH)
+                factory.CreateActivity(
+                        log_path,
+                        environ,
+                        command,
+                        environ['SUGAR_BUNDLE_PATH'],
+                        environ['SUGAR_BUNDLE_ID'],
+                        timeout=30 * DBUS_PYTHON_TIMEOUT_UNITS_PER_SECOND,
+                        reply_handler=self._create_reply_handler,
+                        error_handler=self._create_error_handler,
+                        dbus_interface=_RAINBOW_ACTIVITY_FACTORY_INTERFACE)
+
+    def _no_reply_handler(self, *args):
+        pass
+
+    def _notify_launch_failure_error_handler(self, err):
+        logging.error('Notify launch failure failed %s' % err)
+
+    def _notify_launch_error_handler(self, err):
+        logging.debug('Notify launch failed %s' % err)
+
+    def _activate_reply_handler(self, activated):
+        if not activated:
+            self._create_activity()
+
+    def _activate_error_handler(self, err):
+        logging.error("Activity activation request failed %s" % err)
+
+    def _create_reply_handler(self):
+        logging.debug("Activity created %s (%s)." %
+            (self._handle.activity_id, self._service_name))
+
+    def _create_error_handler(self, err):
+        logging.error("Couldn't create activity %s (%s): %s" %
+            (self._handle.activity_id, self._service_name, err))
+        self._shell.NotifyLaunchFailure(
+            self._handle.activity_id, reply_handler=self._no_reply_handler,
+            error_handler=self._notify_launch_failure_error_handler)
+
+    def _find_object_reply_handler(self, jobjects, count):
+        if count > 0:
+            if count > 1:
+                logging.debug("Multiple objects has the same activity_id.")
+            self._handle.object_id = jobjects[0]['uid']
+        self._create_activity()
+
+    def _find_object_error_handler(self, err):
+        logging.error("Datastore find failed %s" % err)
+        self._create_activity()
+
+def create(service_name, activity_handle=None):
+    """Create a new activity from its name."""
+    if not activity_handle:
+        activity_handle = ActivityHandle()
+    return ActivityCreationHandler(service_name, activity_handle)
+
+def create_with_uri(service_name, uri):
+    """Create a new activity and pass the uri as handle."""
+    activity_handle = ActivityHandle(uri=uri)
+    return ActivityCreationHandler(service_name, activity_handle)
+
+def create_with_object_id(service_name, object_id):
+    """Create a new activity and pass the object id as handle."""
+    activity_handle = ActivityHandle(object_id=object_id)
+    return ActivityCreationHandler(service_name, activity_handle)
diff --git a/src/sugar/activity/activityhandle.py b/src/sugar/activity/activityhandle.py
new file mode 100644
index 0000000..3f4a44c
--- /dev/null
+++ b/src/sugar/activity/activityhandle.py
@@ -0,0 +1,66 @@
+# Copyright (C) 2006-2007 Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+class ActivityHandle(object):
+    """Data structure storing simple activity metadata"""
+    def __init__(
+        self, activity_id=None, object_id=None, uri=None
+    ):
+        """Initialise the handle from activity_id
+        
+        activity_id -- unique id for the activity to be
+            created
+        object_id -- identity of the journal object 
+            associated with the activity. It was used by 
+            the journal prototype implementation, might 
+            change when we do the real one. 
+            
+            When you resume an activity from the journal 
+            the object_id will be passed in. It's optional 
+            since new activities does not have an 
+            associated object (yet).
+            
+            XXX Not clear how this relates to the activity
+            id yet, i.e. not sure we really need both. TBF
+        uri -- URI associated with the activity. Used when 
+            opening an external file or resource in the 
+            activity, rather than a journal object 
+            (downloads stored on the file system for 
+            example or web pages)
+        """
+        self.activity_id = activity_id
+        self.object_id = object_id
+        self.uri = uri
+
+    def get_dict(self):
+        """Retrieve our settings as a dictionary"""
+        result = { 'activity_id' : self.activity_id }
+        if self.object_id:
+            result['object_id'] = self.object_id
+        if self.uri:
+            result['uri'] = self.uri
+
+        return result
+
+def create_from_dict(handle_dict):
+    """Create a handle from a dictionary of parameters"""
+    result = ActivityHandle(
+        handle_dict['activity_id'],
+        object_id = handle_dict.get('object_id'),
+        uri = handle_dict.get('uri'),
+    )
+    return result
diff --git a/src/sugar/activity/activityservice.py b/src/sugar/activity/activityservice.py
new file mode 100644
index 0000000..c884fcb
--- /dev/null
+++ b/src/sugar/activity/activityservice.py
@@ -0,0 +1,70 @@
+# Copyright (C) 2006-2007 Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import logging
+
+import dbus
+import dbus.service
+
+_ACTIVITY_SERVICE_NAME = "org.laptop.Activity"
+_ACTIVITY_SERVICE_PATH = "/org/laptop/Activity"
+_ACTIVITY_INTERFACE = "org.laptop.Activity"
+
+class ActivityService(dbus.service.Object):
+    """Base dbus service object that each Activity uses to export dbus methods.
+    
+    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, activity):
+        """Initialise the service for the given activity
+        
+        activity -- sugar.activity.activity.Activity instance
+        
+        Creates dbus services that use the instance's activity_id
+        as discriminants among all active services 
+        of this type.  That is, the services are all available 
+        as names/paths derived from the instance's activity_id.
+        
+        The various methods exposed on dbus are just forwarded
+        to the client Activity object's equally-named methods.
+        """
+        activity.realize()
+
+        activity_id = activity.get_id()
+        service_name = _ACTIVITY_SERVICE_NAME + activity_id
+        object_path  = _ACTIVITY_SERVICE_PATH + "/" + activity_id
+
+        bus = dbus.SessionBus()
+        bus_name = dbus.service.BusName(service_name, bus=bus)
+        dbus.service.Object.__init__(self, bus_name, object_path)
+
+        self._activity = activity
+
+    @dbus.service.method(_ACTIVITY_INTERFACE)
+    def SetActive(self, active):
+        logging.debug('ActivityService.set_active: %s.' % active)
+        self._activity.props.active = active
+
+    @dbus.service.method(_ACTIVITY_INTERFACE)
+    def Invite(self, buddy_key):
+        self._activity.invite(buddy_key)
+
+    @dbus.service.method(_ACTIVITY_INTERFACE)
+    def TakeScreenshot(self):
+        self._activity.take_screenshot()
+
diff --git a/src/sugar/activity/bundlebuilder.py b/src/sugar/activity/bundlebuilder.py
new file mode 100644
index 0000000..3e70b3c
--- /dev/null
+++ b/src/sugar/activity/bundlebuilder.py
@@ -0,0 +1,377 @@
+# Copyright (C) 2006-2007 Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import sys
+import os
+import zipfile
+import shutil
+import subprocess
+import re
+import gettext
+
+from sugar import env
+from sugar.bundle.activitybundle import ActivityBundle
+
+class _SvnFileList(list):
+    def __init__(self):
+        f = os.popen('svn list -R')
+        for line in f.readlines():
+            filename = line.strip()
+            if os.path.isfile(filename):
+                self.append(filename)
+        f.close()
+
+class _GitFileList(list):
+    def __init__(self):
+        f = os.popen('git-ls-files')
+        for line in f.readlines():
+            filename = line.strip()
+            if not filename.startswith('.'):
+                self.append(filename)
+        f.close()
+
+class _DefaultFileList(list):
+    def __init__(self):
+        for name in os.listdir('activity'):
+            if name.endswith('.svg'):
+                self.append(os.path.join('activity', name))
+
+        self.append('activity/activity.info')
+
+        if os.path.isfile(_get_source_path('NEWS')):
+            self.append('NEWS')
+
+class _ManifestFileList(_DefaultFileList):
+    def __init__(self, manifest):
+        _DefaultFileList.__init__(self)
+        self.append(manifest)
+
+        f = open(manifest,'r')
+        for line in f.readlines():
+            stripped_line = line.strip()
+            if stripped_line and not stripped_line in self:
+                self.append(stripped_line)
+        f.close()
+
+def _extract_bundle(source_file, dest_dir):
+    if not os.path.exists(dest_dir):
+        os.mkdir(dest_dir)
+
+    zf = zipfile.ZipFile(source_file)
+
+    for name in zf.namelist():
+        path = os.path.join(dest_dir, name)            
+        if not os.path.exists(os.path.dirname(path)):
+            os.makedirs(os.path.dirname(path))
+
+        outfile = open(path, 'wb')
+        outfile.write(zf.read(name))
+        outfile.flush()
+        outfile.close()
+
+def _get_source_path(path=None):
+    if path:
+        return os.path.join(os.getcwd(), path)
+    else:
+        return os.getcwd()
+
+def _get_bundle_dir():
+    bundle_name = os.path.basename(_get_source_path())
+    return bundle_name + '.activity'    
+
+def _get_package_name(bundle_name):
+    bundle = ActivityBundle(_get_source_path())
+    zipname = '%s-%d.xo' % (bundle_name, bundle.get_activity_version())
+    return zipname
+
+def _delete_backups(arg, dirname, names):
+    for name in names:
+        if name.endswith('~') or name.endswith('pyc'):
+            os.remove(os.path.join(dirname, name))
+
+def _get_bundle_id():
+    bundle = ActivityBundle(_get_source_path())
+    return bundle.get_bundle_id()
+
+def cmd_help():
+    print 'Usage: \n\
+setup.py dev                 - setup for development \n\
+setup.py dist                - create a bundle package \n\
+setup.py install   [dirname] - install the bundle \n\
+setup.py uninstall [dirname] - uninstall the bundle \n\
+setup.py genpot              - generate the gettext pot file \n\
+setup.py genl10n             - generate localization files \n\
+setup.py clean               - clean the directory \n\
+setup.py release             - do a new release of the bundle \n\
+setup.py help                - print this message \n\
+'
+
+def cmd_dev():
+    bundle_path = env.get_user_activities_path()
+    if not os.path.isdir(bundle_path):
+        os.mkdir(bundle_path)
+    bundle_path = os.path.join(bundle_path, _get_bundle_dir())
+    try:
+        os.symlink(_get_source_path(), bundle_path)
+    except OSError:
+        if os.path.islink(bundle_path):
+            print 'ERROR - The bundle has been already setup for development.'
+        else:
+            print 'ERROR - A bundle with the same name is already installed.'
+
+def _get_file_list(manifest):
+    if os.path.isfile(manifest):
+        return _ManifestFileList(manifest)
+    elif os.path.isdir('.git'):
+        return _GitFileList()
+    elif os.path.isdir('.svn'):
+        return _SvnFileList()
+    else:
+        return _DefaultFileList()
+
+def _get_po_list(manifest):
+    file_list = {}
+
+    po_regex = re.compile("po/(.*)\.po$")
+    for file_name in _get_file_list(manifest):
+        match = po_regex.match(file_name)
+        if match:
+            file_list[match.group(1)] = file_name
+
+    return file_list
+
+def _get_l10n_list(manifest):
+    l10n_list = []
+
+    for lang in _get_po_list(manifest).keys():
+        filename = _get_bundle_id() + '.mo'
+        l10n_list.append(os.path.join('locale', lang, 'LC_MESSAGES', filename))
+        l10n_list.append(os.path.join('locale', lang, 'activity.linfo'))
+
+    return l10n_list
+
+def _get_activity_name():
+    info_path = os.path.join(_get_source_path(), 'activity', 'activity.info')
+    f = open(info_path,'r')
+    info = f.read()
+    f.close()
+    match = re.search('^name\s*=\s*(.*)$', info, flags = re.MULTILINE)
+    return match.group(1)
+
+def cmd_dist(bundle_name, manifest):
+    cmd_genl10n(bundle_name, manifest)
+    file_list = _get_file_list(manifest)
+
+    zipname = _get_package_name(bundle_name)
+    bundle_zip = zipfile.ZipFile(zipname, 'w', zipfile.ZIP_DEFLATED)
+    base_dir = bundle_name + '.activity'
+    
+    for filename in file_list:
+        bundle_zip.write(filename, os.path.join(base_dir, filename))
+
+    for filename in _get_l10n_list(manifest):
+        bundle_zip.write(filename, os.path.join(base_dir, filename))
+
+    bundle_zip.close()
+
+def cmd_install(bundle_name, manifest, path):
+    cmd_dist(bundle_name, manifest)
+    cmd_uninstall(path)
+
+    _extract_bundle(_get_package_name(bundle_name), path)
+
+def cmd_uninstall(path):
+    path = os.path.join(path, _get_bundle_dir())
+    if os.path.isdir(path):
+        shutil.rmtree(path)
+
+def cmd_genpot(bundle_name, manifest):
+    po_path = os.path.join(_get_source_path(), 'po')
+    if not os.path.isdir(po_path):
+        os.mkdir(po_path)
+
+    python_files = []
+    file_list = _get_file_list(manifest)
+    for file_name in file_list:
+        if file_name.endswith('.py'):
+            python_files.append(file_name)
+
+    # First write out a stub .pot file containing just the translated
+    # activity name, then have xgettext merge the rest of the
+    # translations into that. (We can't just append the activity name
+    # to the end of the .pot file afterwards, because that might
+    # create a duplicate msgid.)
+    pot_file = os.path.join('po', '%s.pot' % bundle_name)
+    activity_name = _get_activity_name()
+    escaped_name = re.sub('([\\\\"])', '\\\\\\1', activity_name)
+    f = open(pot_file, 'w')
+    f.write('#: activity/activity.info:2\n')
+    f.write('msgid "%s"\n' % escaped_name)
+    f.write('msgstr ""\n')
+    f.close()
+
+    args = [ 'xgettext', '--join-existing', '--language=Python',
+             '--keyword=_', '--add-comments=TRANS:', '--output=%s' % pot_file ]
+
+    args += python_files
+    retcode = subprocess.call(args)
+    if retcode:
+        print 'ERROR - xgettext failed with return code %i.' % retcode
+
+
+def cmd_genl10n(bundle_name, manifest):
+    source_path = _get_source_path()
+    activity_name = _get_activity_name()
+
+    po_list = _get_po_list(manifest)
+    for lang in po_list.keys():
+        file_name = po_list[lang]
+
+        localedir = os.path.join(source_path, 'locale', lang)
+        mo_path = os.path.join(localedir, 'LC_MESSAGES')
+        if not os.path.isdir(mo_path):
+            os.makedirs(mo_path)
+
+        mo_file = os.path.join(mo_path, "%s.mo" % _get_bundle_id())
+        args = ["msgfmt", "--output-file=%s" % mo_file, file_name]
+        retcode = subprocess.call(args)
+        if retcode:
+            print 'ERROR - msgfmt failed with return code %i.' % retcode
+
+        cat = gettext.GNUTranslations(open(mo_file, 'r'))
+        translated_name = cat.gettext(activity_name)
+        linfo_file = os.path.join(localedir, 'activity.linfo')
+        f = open(linfo_file, 'w')
+        f.write('[Activity]\nname = %s\n' % translated_name)
+        f.close()
+
+def cmd_release(bundle_name, manifest):
+    if not os.path.isdir('.git'):
+        print 'ERROR - this command works only for git repositories'
+
+    retcode = subprocess.call(['git', 'pull'])
+    if retcode:
+        print 'ERROR - cannot pull from git'
+
+    print 'Bumping activity version...'
+
+    info_path = os.path.join(_get_source_path(), 'activity', 'activity.info')
+    f = open(info_path,'r')
+    info = f.read()
+    f.close()
+
+    exp = re.compile('activity_version\s?=\s?([0-9]*)')
+    match = re.search(exp, info)
+    version = int(match.group(1)) + 1
+    info = re.sub(exp, 'activity_version = %d' % version, info)
+
+    f = open(info_path, 'w')
+    f.write(info)
+    f.close()
+
+    news_path = os.path.join(_get_source_path(), 'NEWS')
+
+    if os.environ.has_key('SUGAR_NEWS'):
+        print 'Update NEWS.sugar...'
+
+        sugar_news_path = os.environ['SUGAR_NEWS']
+        if os.path.isfile(sugar_news_path):
+            f = open(sugar_news_path,'r')
+            sugar_news = f.read()
+            f.close()
+        else:
+            sugar_news = ''
+
+        sugar_news += '%s - %d\n\n' % (bundle_name, version)
+
+        f = open(news_path,'r')
+        for line in f.readlines():
+            if len(line.strip()) > 0:
+                sugar_news += line
+            else:
+                break
+        f.close()
+
+        sugar_news += '\n'
+
+        f = open(sugar_news_path, 'w')
+        f.write(sugar_news)
+        f.close()
+
+    print 'Update NEWS...'
+
+    f = open(news_path,'r')
+    news = f.read()
+    f.close()
+
+    news = '%d\n\n' % version + news
+
+    f = open(news_path, 'w')
+    f.write(news)
+    f.close()
+
+    print 'Committing to git...'
+
+    changelog = 'Release version %d.' % version
+    retcode = subprocess.call(['git', 'commit', '-a', '-m % s' % changelog])
+    if retcode:
+        print 'ERROR - cannot commit to git'
+
+    retcode = subprocess.call(['git', 'push'])
+    if retcode:
+        print 'ERROR - cannot push to git'
+
+    print 'Creating the bundle...'
+    cmd_dist(bundle_name, manifest)
+
+    print 'Done.'
+
+def cmd_clean():
+    os.path.walk('.', _delete_backups, None)
+
+def sanity_check():
+    if not os.path.isfile(_get_source_path('NEWS')):
+        print 'WARNING: NEWS file is missing.'
+
+def start(bundle_name, manifest='MANIFEST'):
+    sanity_check()
+
+    if len(sys.argv) < 2:
+        cmd_help()
+    elif sys.argv[1] == 'build':
+        pass
+    elif sys.argv[1] == 'dev':
+        cmd_dev()
+    elif sys.argv[1] == 'dist':
+        cmd_dist(bundle_name, manifest)
+    elif sys.argv[1] == 'install' and len(sys.argv) == 3:
+        cmd_install(bundle_name, manifest, sys.argv[2])
+    elif sys.argv[1] == 'uninstall' and len(sys.argv) == 3:
+        cmd_uninstall(sys.argv[2])
+    elif sys.argv[1] == 'genpot':
+        cmd_genpot(bundle_name, manifest)
+    elif sys.argv[1] == 'genl10n':
+        cmd_genl10n(bundle_name, manifest)
+    elif sys.argv[1] == 'clean':
+        cmd_clean()
+    elif sys.argv[1] == 'release':
+        cmd_release(bundle_name, manifest)
+    else:
+        cmd_help()
+        
+if __name__ == '__main__':
+    start()
diff --git a/src/sugar/activity/registry.py b/src/sugar/activity/registry.py
new file mode 100644
index 0000000..5f5aefc
--- /dev/null
+++ b/src/sugar/activity/registry.py
@@ -0,0 +1,182 @@
+# Copyright (C) 2006-2007 Red Hat, Inc.
+# Copyright (C) 2007 One Laptop Per Child
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import logging
+
+import dbus
+import gobject
+
+_ACTIVITY_REGISTRY_SERVICE_NAME = 'org.laptop.ActivityRegistry'
+_ACTIVITY_REGISTRY_IFACE = 'org.laptop.ActivityRegistry'
+_ACTIVITY_REGISTRY_PATH = '/org/laptop/ActivityRegistry'
+
+def _activity_info_from_dict(info_dict):
+    if not info_dict:
+        return None
+    return ActivityInfo(info_dict['name'], info_dict['icon'],
+                        info_dict['bundle_id'], info_dict['version'],
+                        info_dict['path'], info_dict['show_launcher'],
+                        info_dict['command'], info_dict['favorite'])
+
+class ActivityInfo(object):
+    def __init__(self, name, icon, bundle_id, version,
+                 path, show_launcher, command, favorite):
+        self.name = name
+        self.icon = icon
+        self.bundle_id = bundle_id
+        self.version = version
+        self.path = path
+        self.command = command
+        self.show_launcher = show_launcher
+        self.favorite = favorite
+
+class ActivityRegistry(gobject.GObject):
+    __gsignals__ = {
+        'activity-added':   (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                             ([gobject.TYPE_PYOBJECT])),
+        'activity-removed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                             ([gobject.TYPE_PYOBJECT])),
+        'activity-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                             ([gobject.TYPE_PYOBJECT]))
+    }
+    def __init__(self):
+        gobject.GObject.__init__(self)
+
+        bus = dbus.SessionBus()
+
+        # NOTE: We need to follow_name_owner_changes here
+        #       because we can not connect to a signal unless 
+        #       we follow the changes or we start the service
+        #       before we connect.  Starting the service here
+        #       causes a major bottleneck during startup
+        bus_object = bus.get_object(_ACTIVITY_REGISTRY_SERVICE_NAME,
+                                    _ACTIVITY_REGISTRY_PATH,
+                                    follow_name_owner_changes = True)
+        self._registry = dbus.Interface(bus_object, _ACTIVITY_REGISTRY_IFACE)
+        self._registry.connect_to_signal('ActivityAdded',
+                                         self._activity_added_cb)
+        self._registry.connect_to_signal('ActivityRemoved',
+                                         self._activity_removed_cb)
+        self._registry.connect_to_signal('ActivityChanged',
+                                         self._activity_changed_cb)
+
+        # Two caches fo saving some travel across dbus.
+        self._service_name_to_activity_info = {}
+        self._mime_type_to_activities = {}
+
+    def _convert_info_list(self, info_list):
+        result = []
+
+        for info_dict in info_list:
+            result.append(_activity_info_from_dict(info_dict))
+
+        return result
+
+    def get_activities(self):
+        info_list = self._registry.GetActivities()
+        return self._convert_info_list(info_list)
+
+    def _get_activities_cb(self, reply_handler, info_list):
+        result = []
+        for info_dict in info_list:
+            result.append(_activity_info_from_dict(info_dict))
+
+        reply_handler(result)
+
+    def _get_activities_error_cb(self, error_handler, e):
+        if error_handler:
+            error_handler(e)
+        else:
+            logging.error('Error getting activities async: %s' % str(e))
+
+    def get_activities_async(self, reply_handler=None, error_handler=None):
+        if not reply_handler:
+            logging.error('Function get_activities_async called' \
+                          'without a reply handler. Can not run.') 
+            return
+
+        self._registry.GetActivities(
+             reply_handler=lambda info_list: \
+                    self._get_activities_cb(reply_handler, info_list),
+             error_handler=lambda e: \
+                    self._get_activities_error_cb(error_handler, e))
+
+    def get_activity(self, service_name):
+        if self._service_name_to_activity_info.has_key(service_name):
+            return self._service_name_to_activity_info[service_name]
+
+        info_dict = self._registry.GetActivity(service_name)
+        activity_info = _activity_info_from_dict(info_dict)
+
+        self._service_name_to_activity_info[service_name] = activity_info
+        return activity_info
+
+    def find_activity(self, name):
+        info_list = self._registry.FindActivity(name)
+        return self._convert_info_list(info_list)
+
+    def get_activities_for_type(self, mime_type):
+        if self._mime_type_to_activities.has_key(mime_type):
+            return self._mime_type_to_activities[mime_type]
+
+        info_list = self._registry.GetActivitiesForType(mime_type)
+        activities = self._convert_info_list(info_list)
+
+        self._mime_type_to_activities[mime_type] = activities
+        return activities
+
+    def add_bundle(self, bundle_path):
+        result = self._registry.AddBundle(bundle_path)
+        # Need to invalidate here because get_activity could be called after
+        # add_bundle and before we receive activity-added, causing a race.
+        self._invalidate_cache()
+        return result
+
+    def _activity_added_cb(self, info_dict):
+        logging.debug('ActivityRegistry._activity_added_cb: invalidating cache')
+        self._invalidate_cache()
+        self.emit('activity-added', _activity_info_from_dict(info_dict))
+
+    def _invalidate_cache(self):
+        self._service_name_to_activity_info.clear()
+        self._mime_type_to_activities.clear()
+
+    def remove_bundle(self, bundle_path):
+        self._invalidate_cache()
+        return self._registry.RemoveBundle(bundle_path)
+
+    def _activity_removed_cb(self, info_dict):
+        logging.debug('ActivityRegistry._activity_removed_cb: flushing caches')
+        self._invalidate_cache()
+        self.emit('activity-removed', _activity_info_from_dict(info_dict))
+
+    def _activity_changed_cb(self, info_dict):
+        logging.debug('ActivityRegistry._activity_changed_cb: flushing caches')
+        self._invalidate_cache()
+        self.emit('activity-changed', _activity_info_from_dict(info_dict))
+
+    def set_activity_favorite(self, bundle_id, version, favorite):
+        self._registry.SetActivityFavorite(bundle_id, version, favorite)
+
+_registry = None
+
+def get_registry():
+    global _registry
+    if not _registry:
+        _registry = ActivityRegistry()
+    return _registry