2013-09-28 11:33:40 +02:00
|
|
|
#!/usr/bin/env python2
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
|
|
|
|
# Copyright (C) 2006-2008, Red Hat, Inc.
|
2008-08-27 11:04:54 +02:00
|
|
|
#
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU General Public License as published by
|
|
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
|
|
# (at your option) any later version.
|
2008-08-27 11:04:54 +02:00
|
|
|
#
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
# This program is distributed in the hope that it will be useful,
|
2008-08-27 11:04:54 +02:00
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
# GNU General Public License for more details.
|
2008-08-27 11:04:54 +02:00
|
|
|
#
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
# You should have received a copy of the GNU General Public License
|
|
|
|
# along with this program; if not, write to the Free Software
|
|
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2008-08-27 11:04:54 +02:00
|
|
|
|
|
|
|
import os
|
|
|
|
import sys
|
2012-08-27 16:09:23 +02:00
|
|
|
|
|
|
|
# Change the default encoding to avoid UnicodeDecodeError
|
|
|
|
# http://lists.sugarlabs.org/archive/sugar-devel/2012-August/038928.html
|
|
|
|
reload(sys)
|
|
|
|
sys.setdefaultencoding('utf-8')
|
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
import gettext
|
|
|
|
from optparse import OptionParser
|
|
|
|
|
|
|
|
import dbus
|
|
|
|
import dbus.service
|
2013-09-04 21:09:40 +02:00
|
|
|
from dbus.mainloop.glib import DBusGMainLoop
|
|
|
|
DBusGMainLoop(set_as_default=True)
|
2008-08-27 11:04:54 +02:00
|
|
|
|
2011-12-20 18:48:09 +01:00
|
|
|
from sugar3.activity import activityhandle
|
2013-09-10 22:42:48 +02:00
|
|
|
from sugar3 import config
|
2011-12-20 18:48:09 +01:00
|
|
|
from sugar3.bundle.activitybundle import ActivityBundle
|
|
|
|
from sugar3 import logger
|
2008-08-27 11:04:54 +02:00
|
|
|
|
2016-04-17 07:57:07 +02:00
|
|
|
from sugar3.bundle.bundle import MalformedBundleException
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2016-05-17 06:36:01 +02:00
|
|
|
from distutils.dir_util import mkpath
|
2016-05-17 10:50:09 +02:00
|
|
|
import time
|
|
|
|
import hashlib
|
|
|
|
import random
|
2016-05-17 06:36:01 +02:00
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
def create_activity_instance(constructor, handle):
|
|
|
|
activity = constructor(handle)
|
|
|
|
activity.show()
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
return activity
|
2008-08-27 11:04:54 +02:00
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
def get_single_process_name(bundle_id):
|
|
|
|
return bundle_id
|
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
def get_single_process_path(bundle_id):
|
|
|
|
return '/' + bundle_id.replace('.', '/')
|
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
class SingleProcess(dbus.service.Object):
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
def __init__(self, name_service, constructor):
|
|
|
|
self.constructor = constructor
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
bus = dbus.SessionBus()
|
|
|
|
bus_name = dbus.service.BusName(name_service, bus=bus)
|
|
|
|
object_path = get_single_process_path(name_service)
|
|
|
|
dbus.service.Object.__init__(self, bus_name, object_path)
|
|
|
|
|
2010-10-15 21:14:59 +02:00
|
|
|
@dbus.service.method('org.laptop.SingleProcess', in_signature='a{sv}')
|
2008-08-27 11:04:54 +02:00
|
|
|
def create(self, handle_dict):
|
|
|
|
handle = activityhandle.create_from_dict(handle_dict)
|
|
|
|
create_activity_instance(self.constructor, handle)
|
|
|
|
|
2014-05-19 22:52:53 +02:00
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
def main():
|
2016-04-17 07:57:07 +02:00
|
|
|
usage = 'usage: %prog [options] [activity dir] [python class]'
|
|
|
|
epilog = 'If you are running from a directory containing an Activity, ' \
|
2016-10-08 02:06:57 +02:00
|
|
|
'the argument may be omitted. Otherwise please provide either '\
|
2016-04-17 07:57:07 +02:00
|
|
|
'a directory containing a Sugar Activity [activity dir], a '\
|
|
|
|
'[python_class], or both.'
|
|
|
|
|
|
|
|
parser = OptionParser(usage=usage, epilog=epilog)
|
2010-10-15 21:14:59 +02:00
|
|
|
parser.add_option('-b', '--bundle-id', dest='bundle_id',
|
|
|
|
help='identifier of the activity bundle')
|
|
|
|
parser.add_option('-a', '--activity-id', dest='activity_id',
|
|
|
|
help='identifier of the activity instance')
|
|
|
|
parser.add_option('-o', '--object-id', dest='object_id',
|
|
|
|
help='identifier of the associated datastore object')
|
|
|
|
parser.add_option('-u', '--uri', dest='uri',
|
|
|
|
help='URI to load')
|
2008-08-27 11:04:54 +02:00
|
|
|
parser.add_option('-s', '--single-process', dest='single_process',
|
|
|
|
action='store_true',
|
|
|
|
help='start all the instances in the same process')
|
2010-08-16 17:27:10 +02:00
|
|
|
parser.add_option('-i', '--invited', dest='invited',
|
2010-10-05 16:36:13 +02:00
|
|
|
action='store_true', default=False,
|
2010-07-15 10:50:05 +02:00
|
|
|
help='the activity is being launched for handling an '
|
|
|
|
'invite from the network')
|
2008-08-27 11:04:54 +02:00
|
|
|
(options, args) = parser.parse_args()
|
|
|
|
|
|
|
|
logger.start()
|
|
|
|
|
2016-04-17 07:57:07 +02:00
|
|
|
activity_class = None
|
|
|
|
if len(args) == 2:
|
|
|
|
activity_class = args[1]
|
|
|
|
os.chdir(args[0])
|
|
|
|
elif len(args) == 1:
|
|
|
|
if os.path.isdir(args[0]):
|
|
|
|
os.chdir(args[0])
|
|
|
|
else:
|
|
|
|
activity_class = args[0]
|
2008-08-27 11:04:54 +02:00
|
|
|
|
2016-04-17 07:57:07 +02:00
|
|
|
os.environ['SUGAR_BUNDLE_PATH'] = os.path.abspath(os.curdir)
|
2008-08-27 11:04:54 +02:00
|
|
|
|
|
|
|
bundle_path = os.environ['SUGAR_BUNDLE_PATH']
|
|
|
|
sys.path.append(bundle_path)
|
|
|
|
|
2016-04-17 07:57:07 +02:00
|
|
|
try:
|
|
|
|
bundle = ActivityBundle(bundle_path)
|
|
|
|
except MalformedBundleException:
|
|
|
|
parser.print_help()
|
|
|
|
exit(0)
|
|
|
|
|
|
|
|
if not activity_class:
|
|
|
|
if bundle.get_command().startswith('sugar-activity'):
|
|
|
|
print 'Guessing python class from activity.info!'
|
|
|
|
activity_class = bundle.get_command().split(" ")[1]
|
|
|
|
|
|
|
|
if 'SUGAR_VERSION' not in os.environ:
|
2016-05-17 06:36:01 +02:00
|
|
|
profile_id = os.environ.get('SUGAR_PROFILE', 'default')
|
|
|
|
home_dir = os.environ.get('SUGAR_HOME', os.path.expanduser('~/.sugar'))
|
|
|
|
base = os.path.join(home_dir, profile_id)
|
|
|
|
activity_root = os.path.join(base, bundle.get_bundle_id())
|
|
|
|
|
|
|
|
instance_dir = os.path.join(activity_root, 'instance')
|
|
|
|
mkpath(instance_dir)
|
|
|
|
|
|
|
|
data_dir = os.path.join(activity_root, 'data')
|
|
|
|
mkpath(data_dir)
|
|
|
|
|
|
|
|
tmp_dir = os.path.join(activity_root, 'tmp')
|
|
|
|
mkpath(tmp_dir)
|
|
|
|
|
|
|
|
os.environ['SUGAR_ACTIVITY_ROOT'] = activity_root
|
|
|
|
os.environ['SUGAR_BUNDLE_PATH'] = bundle.get_path()
|
2008-08-27 11:04:54 +02:00
|
|
|
|
|
|
|
os.environ['SUGAR_BUNDLE_ID'] = bundle.get_bundle_id()
|
|
|
|
os.environ['SUGAR_BUNDLE_NAME'] = bundle.get_name()
|
2008-08-27 12:00:18 +02:00
|
|
|
os.environ['SUGAR_BUNDLE_VERSION'] = str(bundle.get_activity_version())
|
2008-08-27 11:04:54 +02:00
|
|
|
|
2012-06-04 17:45:30 +02:00
|
|
|
# must be done early, some activities set translations globally, SL #3654
|
2013-09-10 22:42:48 +02:00
|
|
|
activity_locale_path = os.environ.get("SUGAR_LOCALEDIR",
|
|
|
|
config.locale_path)
|
|
|
|
|
|
|
|
gettext.bindtextdomain(bundle.get_bundle_id(), activity_locale_path)
|
2013-09-11 16:04:13 +02:00
|
|
|
gettext.bindtextdomain('sugar-toolkit-gtk3', config.locale_path)
|
2013-09-10 22:42:48 +02:00
|
|
|
gettext.textdomain(bundle.get_bundle_id())
|
2012-06-04 17:45:30 +02:00
|
|
|
|
2016-04-17 07:57:07 +02:00
|
|
|
splitted_module = activity_class.rsplit('.', 1)
|
2008-08-27 11:04:54 +02:00
|
|
|
module_name = splitted_module[0]
|
|
|
|
class_name = splitted_module[1]
|
|
|
|
|
2009-08-25 19:55:48 +02:00
|
|
|
module = __import__(module_name)
|
2008-08-27 11:04:54 +02:00
|
|
|
for comp in module_name.split('.')[1:]:
|
|
|
|
module = getattr(module, comp)
|
|
|
|
|
|
|
|
activity_constructor = getattr(module, class_name)
|
2016-04-17 07:57:07 +02:00
|
|
|
|
|
|
|
if not options.activity_id:
|
2016-05-17 10:50:09 +02:00
|
|
|
# Generate random hash
|
|
|
|
data = '%s%s' % (time.time(), random.randint(10000, 100000))
|
|
|
|
random_hash = hashlib.sha1(data).hexdigest()
|
|
|
|
options.activity_id = random_hash
|
2016-04-17 07:57:07 +02:00
|
|
|
options.bundle_id = bundle.get_bundle_id()
|
|
|
|
|
2008-08-27 11:04:54 +02:00
|
|
|
activity_handle = activityhandle.ActivityHandle(
|
2014-05-19 22:52:53 +02:00
|
|
|
activity_id=options.activity_id,
|
|
|
|
object_id=options.object_id, uri=options.uri,
|
|
|
|
invited=options.invited)
|
2008-08-27 11:04:54 +02:00
|
|
|
|
|
|
|
if options.single_process is True:
|
|
|
|
sessionbus = dbus.SessionBus()
|
|
|
|
|
|
|
|
service_name = get_single_process_name(options.bundle_id)
|
|
|
|
service_path = get_single_process_path(options.bundle_id)
|
|
|
|
|
|
|
|
bus_object = sessionbus.get_object(
|
2014-05-19 22:52:53 +02:00
|
|
|
'org.freedesktop.DBus', '/org/freedesktop/DBus')
|
2008-08-27 11:04:54 +02:00
|
|
|
try:
|
|
|
|
name = bus_object.GetNameOwner(
|
2014-05-19 22:52:53 +02:00
|
|
|
service_name, dbus_interface='org.freedesktop.DBus')
|
|
|
|
except dbus.DBusException:
|
2008-08-27 11:04:54 +02:00
|
|
|
name = None
|
|
|
|
|
|
|
|
if not name:
|
2008-08-27 14:53:59 +02:00
|
|
|
SingleProcess(service_name, activity_constructor)
|
2008-08-27 11:04:54 +02:00
|
|
|
else:
|
2014-05-19 22:38:03 +02:00
|
|
|
try:
|
|
|
|
single_process = sessionbus.get_object(service_name,
|
|
|
|
service_path)
|
|
|
|
single_process.create(
|
|
|
|
activity_handle.get_dict(),
|
|
|
|
dbus_interface='org.laptop.SingleProcess')
|
|
|
|
|
|
|
|
print 'Created %s in a single process.' % service_name
|
|
|
|
sys.exit(0)
|
|
|
|
except (TypeError, dbus.DBusException):
|
|
|
|
print 'Could not communicate with the instance process,' \
|
|
|
|
'launching a new process'
|
2008-08-27 11:04:54 +02:00
|
|
|
|
|
|
|
if hasattr(module, 'start'):
|
|
|
|
module.start()
|
|
|
|
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
instance = create_activity_instance(activity_constructor, activity_handle)
|
|
|
|
|
|
|
|
if hasattr(instance, 'run_main_loop'):
|
|
|
|
instance.run_main_loop()
|
2008-08-27 11:04:54 +02:00
|
|
|
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
main()
|