322 lines
11 KiB
Python
322 lines
11 KiB
Python
# Copyright (C) 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.
|
|
|
|
"""Metadata description of a given application/activity"""
|
|
|
|
import logging
|
|
import locale
|
|
import os
|
|
import zipfile
|
|
from ConfigParser import ConfigParser
|
|
import StringIO
|
|
import tempfile
|
|
|
|
import dbus
|
|
|
|
from sugar import env
|
|
from sugar import activity
|
|
|
|
_PYTHON_FACTORY='sugar-activity-factory'
|
|
|
|
_DBUS_SHELL_SERVICE = "org.laptop.Shell"
|
|
_DBUS_SHELL_PATH = "/org/laptop/Shell"
|
|
_DBUS_ACTIVITY_REGISTRY_IFACE = "org.laptop.Shell.ActivityRegistry"
|
|
|
|
class AlreadyInstalledException(Exception): pass
|
|
class NotInstalledException(Exception): pass
|
|
class InvalidPathException(Exception): pass
|
|
class ZipExtractException(Exception): pass
|
|
class RegistrationException(Exception): pass
|
|
class MalformedBundleException(Exception): pass
|
|
|
|
class Bundle:
|
|
"""Metadata description of a given application/activity
|
|
|
|
The metadata is normally read from an activity.info file,
|
|
which is an INI-style configuration file read using the
|
|
standard Python ConfigParser module.
|
|
|
|
The format reference for the Bundle definition files is
|
|
available for further reference:
|
|
|
|
http://wiki.laptop.org/go/Activity_bundles
|
|
"""
|
|
def __init__(self, path):
|
|
self._init_with_path(path)
|
|
|
|
def _init_with_path(self, path):
|
|
self._name = None
|
|
self._icon = None
|
|
self._service_name = None
|
|
self._mime_types = None
|
|
self._show_launcher = True
|
|
self._valid = True
|
|
self._path = path
|
|
self._activity_version = 0
|
|
|
|
info_file = self._get_info_file()
|
|
if info_file:
|
|
self._parse_info(info_file)
|
|
else:
|
|
self._valid = False
|
|
|
|
linfo_file = self._get_linfo_file()
|
|
if linfo_file:
|
|
self._parse_linfo(linfo_file)
|
|
|
|
def _get_info_file(self):
|
|
info_file = None
|
|
|
|
if os.path.isdir(self._path):
|
|
info_path = os.path.join(self._path, 'activity', 'activity.info')
|
|
if os.path.isfile(info_path):
|
|
info_file = open(info_path)
|
|
else:
|
|
zip_file = zipfile.ZipFile(self._path)
|
|
file_names = zip_file.namelist()
|
|
root_dir = self._get_bundle_root_dir(file_names)
|
|
info_path = os.path.join(root_dir, 'activity', 'activity.info')
|
|
if info_path in file_names:
|
|
info_data = zip_file.read(info_path)
|
|
info_file = StringIO.StringIO(info_data)
|
|
zip_file.close()
|
|
|
|
return info_file
|
|
|
|
def _parse_info(self, info_file):
|
|
cp = ConfigParser()
|
|
cp.readfp(info_file)
|
|
|
|
section = 'Activity'
|
|
|
|
if cp.has_option(section, 'service_name'):
|
|
self._service_name = cp.get(section, 'service_name')
|
|
else:
|
|
self._valid = False
|
|
logging.error('%s must specify a service name' % self._path)
|
|
|
|
if cp.has_option(section, 'name'):
|
|
self._name = cp.get(section, 'name')
|
|
else:
|
|
self._valid = False
|
|
logging.error('%s must specify a name' % self._path)
|
|
|
|
if cp.has_option(section, 'class'):
|
|
self._class = cp.get(section, 'class')
|
|
self._exec = '%s --bundle-path="%s"' % (
|
|
env.get_bin_path(_PYTHON_FACTORY), self._path)
|
|
elif cp.has_option(section, 'exec'):
|
|
self._class = None
|
|
cmdline = cp.get(section, 'exec')
|
|
cmdline = os.path.join(self._path, cmdline)
|
|
cmdline = cmdline.replace('$SUGAR_BUNDLE_PATH', self._path)
|
|
cmdline = os.path.expandvars(cmdline)
|
|
self._exec = cmdline
|
|
else:
|
|
self._exec = None
|
|
self._valid = False
|
|
logging.error('%s must specify exec or class' % self._path)
|
|
|
|
if cp.has_option(section, 'mime_types'):
|
|
mime_list = cp.get(section, 'mime_types')
|
|
self._mime_types = mime_list.strip(';').split(';')
|
|
|
|
if cp.has_option(section, 'show_launcher'):
|
|
if cp.get(section, 'show_launcher') == 'no':
|
|
self._show_launcher = False
|
|
|
|
if cp.has_option(section, 'icon'):
|
|
self._icon = cp.get(section, 'icon')
|
|
|
|
if cp.has_option(section, 'activity_version'):
|
|
version = cp.get(section, 'activity_version')
|
|
try:
|
|
self._activity_version = int(version)
|
|
except ValueError:
|
|
self._valid = False
|
|
|
|
def _parse_linfo(self, linfo_file):
|
|
cp = ConfigParser()
|
|
cp.readfp(linfo_file)
|
|
|
|
section = 'Activity'
|
|
|
|
if cp.has_option(section, 'name'):
|
|
self._name = cp.get(section, 'name')
|
|
|
|
def _get_linfo_file(self):
|
|
linfo_file = None
|
|
|
|
lang = locale.getdefaultlocale()[0]
|
|
if not lang:
|
|
return None
|
|
|
|
if os.path.isdir(self._path):
|
|
linfo_path = os.path.join(self.get_locale_path(), lang, 'activity.linfo')
|
|
if not os.path.isfile(linfo_path):
|
|
linfo_path = os.path.join(self.get_locale_path(), lang[:2], 'activity.linfo')
|
|
if os.path.isfile(linfo_path):
|
|
linfo_file = open(linfo_path)
|
|
else:
|
|
zip_file = zipfile.ZipFile(self._path)
|
|
file_names = zip_file.namelist()
|
|
root_dir = self._get_bundle_root_dir(file_names)
|
|
linfo_path = os.path.join(root_dir, 'locale', lang, 'activity.linfo')
|
|
if not linfo_path in file_names:
|
|
linfo_path = os.path.join(root_dir, 'locale', lang[:2], 'activity.linfo')
|
|
if linfo_path in zip_file.namelist():
|
|
linfo_data = zip_file.read(linfo_path)
|
|
linfo_file = StringIO.StringIO(linfo_data)
|
|
|
|
zip_file.close()
|
|
|
|
return linfo_file
|
|
|
|
def is_valid(self):
|
|
return self._valid
|
|
|
|
def get_locale_path(self):
|
|
"""Get the locale path inside the activity bundle."""
|
|
return os.path.join(self._path, 'locale')
|
|
|
|
def get_icons_path(self):
|
|
"""Get the icons path inside the activity bundle."""
|
|
return os.path.join(self._path, 'icons')
|
|
|
|
def get_path(self):
|
|
"""Get the activity bundle path."""
|
|
return self._path
|
|
|
|
def get_name(self):
|
|
"""Get the activity user visible name."""
|
|
return self._name
|
|
|
|
def get_service_name(self):
|
|
"""Get the activity service name"""
|
|
return self._service_name
|
|
|
|
def get_icon(self):
|
|
"""Get the activity icon name"""
|
|
if os.path.isdir(self._path):
|
|
activity_path = os.path.join(self._path, 'activity')
|
|
return os.path.join(activity_path, self._icon + '.svg')
|
|
else:
|
|
zip_file = zipfile.ZipFile(self._path)
|
|
file_names = zip_file.namelist()
|
|
root_dir = self._get_bundle_root_dir(file_names)
|
|
icon_path = os.path.join(root_dir, 'activity', self._icon + '.svg')
|
|
print icon_path
|
|
print file_names
|
|
if icon_path in file_names:
|
|
icon_data = zip_file.read(icon_path)
|
|
temp_file, temp_file_path = tempfile.mkstemp(self._icon)
|
|
os.write(temp_file, icon_data)
|
|
os.close(temp_file)
|
|
return temp_file_path
|
|
else:
|
|
return None
|
|
|
|
def get_activity_version(self):
|
|
"""Get the activity version"""
|
|
return self._activity_version
|
|
|
|
def get_exec(self):
|
|
"""Get the command to execute to launch the activity factory"""
|
|
return self._exec
|
|
|
|
def get_class(self):
|
|
"""Get the main Activity class"""
|
|
return self._class
|
|
|
|
def get_mime_types(self):
|
|
"""Get the MIME types supported by the activity"""
|
|
return self._mime_types
|
|
|
|
def get_show_launcher(self):
|
|
"""Get whether there should be a visible launcher for the activity"""
|
|
return self._show_launcher
|
|
|
|
def is_installed(self):
|
|
if self._valid and activity.get_registry().get_activity(self._service_name):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def _get_bundle_root_dir(self, file_names):
|
|
"""
|
|
We check here that all the files in the .xo are inside one only dir
|
|
(bundle_root_dir).
|
|
"""
|
|
bundle_root_dir = None
|
|
for file_name in file_names:
|
|
if not bundle_root_dir:
|
|
bundle_root_dir = file_name.split('/')[0]
|
|
if not bundle_root_dir.endswith('.activity'):
|
|
raise MalformedBundleException(
|
|
'The activity directory name must end with .activity')
|
|
else:
|
|
if not file_name.startswith(bundle_root_dir):
|
|
raise MalformedBundleException(
|
|
'All files in the bundle must be inside the activity directory')
|
|
|
|
return bundle_root_dir
|
|
|
|
def install(self):
|
|
if self.is_installed():
|
|
raise AlreadyInstalledException
|
|
|
|
ext = os.path.splitext(self._path)[1]
|
|
if not os.path.isfile(self._path):
|
|
raise InvalidPathException
|
|
|
|
bundle_dir = env.get_user_activities_path()
|
|
if not os.path.isdir(bundle_dir):
|
|
os.mkdir(bundle_dir)
|
|
|
|
zip_file = zipfile.ZipFile(self._path)
|
|
file_names = zip_file.namelist()
|
|
bundle_root_dir = self._get_bundle_root_dir(file_names)
|
|
bundle_path = os.path.join(bundle_dir, bundle_root_dir)
|
|
|
|
if os.spawnlp(os.P_WAIT, 'unzip', 'unzip', self._path, '-d', bundle_dir):
|
|
raise ZipExtractException
|
|
|
|
self._init_with_path(bundle_path)
|
|
|
|
if not activity.get_registry().add_bundle(bundle_path):
|
|
raise RegistrationException
|
|
|
|
def deinstall(self):
|
|
if not self.is_installed():
|
|
raise NotInstalledException
|
|
|
|
ext = os.path.splitext(self._path)[1]
|
|
if not os.path.isfile(self._path) or ext != '.activity':
|
|
raise InvalidPathException
|
|
|
|
for root, dirs, files in os.walk(self._path, topdown=False):
|
|
for name in files:
|
|
os.remove(os.path.join(root, name))
|
|
for name in dirs:
|
|
os.rmdir(os.path.join(root, name))
|
|
os.rmdir(self._path)
|
|
|
|
self._init_with_path(None)
|
|
|
|
# TODO: notify shell
|
|
|