path: root/src/jobs/widget_install/task_manifest_file.cpp

/*
 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
/**
 * @file    task_manifest_file.cpp
 * @author  Pawel Sikorski (p.sikorski@samgsung.com)
 * @version
 * @brief
 */

//SYSTEM INCLUDES
#include <string>
#include <dpl/assert.h>
#include <dirent.h>
#include <fstream>
#include <ail.h>

//WRT INCLUDES
#include <widget_install/task_manifest_file.h>
#include <widget_install/job_widget_install.h>
#include <widget_install/widget_install_errors.h>
#include <widget_install/widget_install_context.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/log/log.h>
#include <dpl/file_input.h>
#include <dpl/file_output.h>
#include <dpl/copy.h>
#include <dpl/exception.h>
#include <dpl/foreach.h>
#include <dpl/sstream.h>
#include <dpl/string.h>
#include <dpl/optional.h>
#include <dpl/utils/wrt_utility.h>
#include <map>
#include <libxml_utils.h>
#include <pkgmgr/pkgmgr_parser.h>

#define DEFAULT_ICON_NAME   "icon.png"

using namespace WrtDB;

namespace {
typedef std::map<DPL::String, DPL::String> LanguageTagMap;

LanguageTagMap getLanguageTagMap()
{
    LanguageTagMap map;

#define ADD(tag, l_tag) map.insert(std::make_pair(L ## # tag, L ## # l_tag));
#include "languages.def"
#undef ADD

    return map;
}

DPL::OptionalString getLangTag(const DPL::String& tag)
{
    static LanguageTagMap TagsMap =
        getLanguageTagMap();

    DPL::String langTag = tag;

    LogDebug("Trying to map language tag: " << langTag);
    size_t pos = langTag.find_first_of(L'_');
    if (pos != DPL::String::npos) {
        langTag.erase(pos);
    }
    DPL::OptionalString ret;

    LanguageTagMap::iterator it = TagsMap.find(langTag);
    if (it != TagsMap.end()) {
        ret = it->second;
    }
    LogDebug("Mapping IANA Language tag to language tag: " <<
             langTag << " -> " << ret);

    return ret;
}
}

namespace Jobs {
namespace WidgetInstall {

const char * TaskManifestFile::encoding = "UTF-8";

TaskManifestFile::TaskManifestFile(InstallerContext &inCont) :
    DPL::TaskDecl<TaskManifestFile>(this),
    m_context(inCont)
{
    if (false == m_context.existingWidgetInfo.isExist) {
        AddStep(&TaskManifestFile::stepCopyIconFiles);
        AddStep(&TaskManifestFile::stepCreateExecFile);
        AddStep(&TaskManifestFile::stepGenerateManifest);
        AddStep(&TaskManifestFile::stepParseManifest);
        AddStep(&TaskManifestFile::stepFinalize);
    } else {
    // for widget update.
        AddStep(&TaskManifestFile::stepBackupIconFiles);
        AddStep(&TaskManifestFile::stepCopyIconFiles);
        AddStep(&TaskManifestFile::stepGenerateManifest);
        AddStep(&TaskManifestFile::stepParseUpgradedManifest);
        AddStep(&TaskManifestFile::stepUpdateFinalize);

        AddAbortStep(&TaskManifestFile::stepAbortIconFiles);
    }
}

TaskManifestFile::~TaskManifestFile()
{
}

void TaskManifestFile::stepCreateExecFile()
{
    //ln -s /usr/bin/wrt-client {widget-handle}

    std::ostringstream real_path;
    DPL::OptionalString pkgname = m_context.widgetConfig.pkgname;
    if (pkgname.IsNull()) {
        ThrowMsg(Exceptions::InternalError, "No Package name exists.");
    }

    real_path << m_context.locations->getBinaryDir() << "/" << m_context.widgetHandle;
    std::string clientExeStr = GlobalConfig::GetWrtClientExec();

    LogInfo("link -s " << clientExeStr << " " << real_path.str());
    symlink(clientExeStr.c_str(), real_path.str().c_str());

    m_context.job->UpdateProgress(
        InstallerContext::INSTALL_CREATE_EXECFILE,
        "Widget execfile creation Finished");
}

void TaskManifestFile::stepCopyIconFiles()
{
    LogDebug("CopyIconFiles");

    DPL::OptionalString pkgname = m_context.widgetConfig.pkgname;
    if (pkgname.IsNull()) {
        ThrowMsg(Exceptions::InternalError, "No Package name exists.");
    }
    Assert(!!m_context.widgetHandle);

    WidgetDAOReadOnly dao(*m_context.widgetHandle);
    WidgetDAOReadOnly::WidgetLocalizedIconList locList = dao.getLocalizedIconList();
    WidgetDAOReadOnly::WidgetIconList list = dao.getIconList();

    FOREACH(it, locList)
    {
        DPL::String i = it->widgetLocale;
        DPL::OptionalString src;
        FOREACH(icon, list)
        {
            if (icon->iconId == it->iconId) {
                src = icon->iconSrc;
            }
        }
        LogDebug("Icon for locale: " << i << "is : " << src);

        std::ostringstream sourceFile;
        std::ostringstream targetFile;

        if (!!src) {

            sourceFile << m_context.locations->getSourceDir() << "/";

            if (!i.empty()) {
                sourceFile << "locales/" << i << "/";
            }

            sourceFile << *src;

            targetFile << GlobalConfig::GetUserWidgetDesktopIconPath() << "/";
            targetFile << getIconTargetFilename(i);

            if (m_context.locations->browserRequest())
            {
                m_context.locations->setIconTargetFilenameForLocale(targetFile.str());
            }

        } else {
            //Use WRT default (not from the widget) only if widget default (not
            // localized) doesn't exist.
            if (i.empty()) {
                LogError("Using Default Icon for widget");
                sourceFile << GlobalConfig::GetUserWidgetDefaultIconFile();
            } else {
                continue;
            }
        }

        LogDebug("Copying icon: " << sourceFile.str() <<
                 " -> " << targetFile.str());

        icon_list.push_back(targetFile.str());

        Try
        {
            DPL::FileInput input(sourceFile.str());
            DPL::FileOutput output(targetFile.str());
            DPL::Copy(&input, &output);
        }

        Catch(DPL::FileInput::Exception::Base)
        {
            // Error while opening or closing source file
            //ReThrowMsg(InstallerException::CopyIconFailed, sourceFile.str());
            LogError(
                "Copying widget's icon failed. Widget's icon will not be"\
                "available from Main Screen");
        }

        Catch(DPL::FileOutput::Exception::Base)
        {
            // Error while opening or closing target file
            //ReThrowMsg(InstallerException::CopyIconFailed, targetFile.str());
            LogError(
                "Copying widget's icon failed. Widget's icon will not be"\
                "available from Main Screen");
        }

        Catch(DPL::CopyFailed)
        {
            // Error while copying
            //ReThrowMsg(InstallerException::CopyIconFailed, targetFile.str());
            LogError(
                "Copying widget's icon failed. Widget's icon will not be"\
                "available from Main Screen");
        }
    }

    m_context.job->UpdateProgress(
        InstallerContext::INSTALL_COPY_ICONFILE,
        "Widget iconfile copy Finished");
}

void TaskManifestFile::stepBackupIconFiles()
{
    LogDebug("Backup Icon Files");

    backup_dir << m_context.locations->getPackageInstallationDir();
    backup_dir << "/" << "backup" << "/";

    backupIconFiles();

    m_context.job->UpdateProgress(
        InstallerContext::INSTALL_BACKUP_ICONFILE,
        "New Widget icon file backup Finished");
}

void TaskManifestFile::stepAbortIconFiles()
{
    LogDebug("Abrot Icon Files");
    FOREACH(it, icon_list)
    {
        LogDebug("Remove Update Icon : " << (*it));
        unlink((*it).c_str());
    }

    std::ostringstream b_icon_dir;
    b_icon_dir << backup_dir.str() << "icons";

    std::list<std::string> fileList;
    getFileList(b_icon_dir.str().c_str(), fileList);

    FOREACH(back_icon, fileList)
    {
        std::ostringstream res_file;
        res_file << GlobalConfig::GetUserWidgetDesktopIconPath();
        res_file << "/" << (*back_icon);

        std::ostringstream backup_file;
        backup_file << b_icon_dir.str() << "/" << (*back_icon);

        Try
        {
            DPL::FileInput input(backup_file.str());
            DPL::FileOutput output(res_file.str());
            DPL::Copy(&input, &output);
        }
        Catch(DPL::FileInput::Exception::Base)
        {
            LogError("Restoration icon File Failed." << backup_file.str()
                    << " to " << res_file.str());
        }

        Catch(DPL::FileOutput::Exception::Base)
        {
            LogError("Restoration icon File Failed." << backup_file.str()
                    << " to " << res_file.str());
        }
        Catch(DPL::CopyFailed)
        {
            LogError("Restoration icon File Failed." << backup_file.str()
                    << " to " << res_file.str());
        }
    }
}

void TaskManifestFile::stepUpdateFinalize()
{
    LogDebug("Finished Update Desktopfile");
}

DPL::String TaskManifestFile::getIconTargetFilename(
        const DPL::String& languageTag) const
{
    DPL::OStringStream filename;
    DPL::Optional<DPL::String> pkgname = m_context.widgetConfig.pkgname;
    if (pkgname.IsNull()) {
        ThrowMsg(Exceptions::InternalError, "No Package name exists.");
    }

    filename << DPL::ToUTF8String(*pkgname).c_str();

    if (!languageTag.empty()) {
        DPL::OptionalString tag = getLangTag(languageTag); // translate en -> en_US etc
        if (tag.IsNull()) { tag = languageTag; }
        DPL::String locale =
            LocalizationUtils::BCP47LanguageTagToLocale(*tag);

       if(locale.empty()) {
            filename << L"." << languageTag;
        } else {
            filename << L"." << locale;
        }
    }

    filename << L".png";
    return filename.str();
}

void TaskManifestFile::stepFinalize()
{
    LogInfo("Finished ManifestFile step");
}


void TaskManifestFile::saveLocalizedKey(std::ofstream &file,
        const DPL::String& key,
        const DPL::String& languageTag)
{
    DPL::String locale =
        LocalizationUtils::BCP47LanguageTagToLocale(languageTag);

    file << key;
    if (!locale.empty()) {
        file << "[" << locale << "]";
    }
    file << "=";
}

void TaskManifestFile::updateAilInfo()
{
    // Update ail for desktop
    std::string cfgPkgname =
        DPL::ToUTF8String(*m_context.widgetConfig.pkgname);
    const char* pkgname = cfgPkgname.c_str();

    LogDebug("Update ail desktop : " << pkgname );
    ail_appinfo_h ai = NULL;
    ail_error_e ret;

    ret = ail_package_get_appinfo(pkgname, &ai);
    if (ai) {
        ail_package_destroy_appinfo(ai);
    }
    
    if (AIL_ERROR_NO_DATA == ret) {
        if (ail_desktop_add(pkgname) < 0) {
            LogDebug("Failed to add ail desktop : " << pkgname);
        }
    } else if (AIL_ERROR_OK == ret) {
        if (ail_desktop_update(pkgname) < 0) {
            LogDebug("Failed to update ail desktop : " << pkgname);
        }
    }
}

void TaskManifestFile::backupIconFiles()
{
    LogInfo("Backup Icon Files");

    std::ostringstream b_icon_dir;
    b_icon_dir << backup_dir.str() << "icons";

    LogDebug("Create icon backup folder : " << b_icon_dir.str());
    _WrtMakeDir(b_icon_dir.str().c_str(), 0755, WRT_FILEUTILS_RECUR);

    std::list<std::string> fileList;
    getFileList(GlobalConfig::GetUserWidgetDesktopIconPath(), fileList);
    std::string pkgname = DPL::ToUTF8String(*m_context.widgetConfig.pkgname);
    
    FOREACH(it, fileList)
    {
        if (0 == (strncmp((*it).c_str(), pkgname.c_str(),
                        strlen(pkgname.c_str())))) {
            std::ostringstream icon_file, backup_icon;
            icon_file << GlobalConfig::GetUserWidgetDesktopIconPath();
            icon_file << "/" << (*it);

            backup_icon << b_icon_dir.str() << "/" << (*it);

            LogDebug("Backup icon file " << icon_file.str() << " to " <<
                    backup_icon.str());
            Try
            {
                DPL::FileInput input(icon_file.str());
                DPL::FileOutput output(backup_icon.str());
                DPL::Copy(&input, &output);
            }
            Catch(DPL::FileInput::Exception::Base)
            {
                LogError("Backup Desktop File Failed.");
                ReThrowMsg(Exceptions::BackupFailed, icon_file.str());
            }

            Catch(DPL::FileOutput::Exception::Base)
            {
                LogError("Backup Desktop File Failed.");
                ReThrowMsg(Exceptions::BackupFailed, backup_icon.str());
            }
            Catch(DPL::CopyFailed)
            {
                LogError("Backup Desktop File Failed.");
                ReThrowMsg(Exceptions::BackupFailed, backup_icon.str());
            }
            unlink((*it).c_str());
        }
    }
}

void TaskManifestFile::getFileList(const char* path,
        std::list<std::string> &list)
{
    DIR* dir = opendir(path);
    if (!dir) {
        LogError("icon directory doesn't exist");
        ThrowMsg(Exceptions::InternalError, path);
    }

    struct dirent* d_ent;
    do {
        if ((d_ent = readdir(dir))) {
            if(strcmp(d_ent->d_name, ".") == 0 || 
                    strcmp(d_ent->d_name, "..") == 0) {
                continue;
            }
            std::string file_name = d_ent->d_name;
            list.push_back(file_name);
        }
    }while(d_ent);
}

void TaskManifestFile::stepGenerateManifest()
{
    DPL::String pkgname = *m_context.widgetConfig.pkgname;
    manifest_name = pkgname + L".xml";
    manifest_file += L"/tmp/" + manifest_name;

    //libxml - init and check
    LibxmlSingleton::Instance().init();

    writeManifest(manifest_file);
    validateManifest();
    commitManifest();

    m_context.job->UpdateProgress(
        InstallerContext::INSTALL_CREATE_MANIFEST,
        "Widget Manifest Creation Finished");
}

void TaskManifestFile::stepParseManifest()
{
    int code = pkgmgr_parser_parse_manifest_for_installation(
            DPL::ToUTF8String(manifest_file).c_str(), NULL);

    if(code != 0)
    {
        LogError("Manifest parser error: " << code);
        ThrowMsg(ManifestParsingError, "Parser returncode: " << code);
    }

    // TODO : It will be removed. AIL update is temporary code request by pkgmgr team.
    updateAilInfo();

    m_context.job->UpdateProgress(
        InstallerContext::INSTALL_CREATE_MANIFEST,
        "Widget Manifest Parsing Finished");
    LogDebug("Manifest parsed");
}

void TaskManifestFile::stepParseUpgradedManifest()
{
    int code = pkgmgr_parser_parse_manifest_for_upgrade(
            DPL::ToUTF8String(manifest_file).c_str(), NULL);

    if(code != 0)
    {
        LogError("Manifest parser error: " << code);
        ThrowMsg(ManifestParsingError, "Parser returncode: " << code);
    }

    // TODO : It will be removed. AIL update is temporary code request by pkgmgr team.
    updateAilInfo();

    m_context.job->UpdateProgress(
        InstallerContext::INSTALL_CREATE_MANIFEST,
        "Widget Manifest Parsing Finished");
    LogDebug("Manifest parsed");
}

void TaskManifestFile::validateManifest()
{
    int code = pkgmgr_parser_check_manifest_validation(
            DPL::ToUTF8String(manifest_name).c_str());

    if(code != 0)
    {
        LogError("Manifest validation error");
        //TODO: manifest files are not yet validating properly because of href
        // attribute in author element (incompatible types in W3C spec. and
        // manifest spec.)
        //ThrowMsg(ManifestValidationError, "Validation returncode: " << code);
    }

    m_context.job->UpdateProgress(
        InstallerContext::INSTALL_CREATE_MANIFEST,
        "Widget Manifest Validation Finished");
    LogDebug("Manifest validated");
}

void TaskManifestFile::commitManifest()
{
    LogDebug("Commiting manifest file : " << manifest_file);

    std::ostringstream destFile;
    destFile << "/opt/share/packages" << "/"; //TODO constant with path
    destFile << DPL::ToUTF8String(manifest_name);
    LogInfo("cp " << manifest_file << " " << destFile.str());

    DPL::FileInput input(DPL::ToUTF8String(manifest_file));
    DPL::FileOutput output(destFile.str());
    DPL::Copy(&input, &output);
    LogDebug("Manifest writen to: " << destFile.str());

    //removing temp file
    unlink((DPL::ToUTF8String(manifest_file)).c_str());
    manifest_file = DPL::FromUTF8String(destFile.str().c_str());
}

void TaskManifestFile::writeManifest(const DPL::String & path)
{
    LogDebug("Generating manifest file : " << path);
    Manifest manifest;
    UiApplication uiApp;

    setWidgetExecPath(uiApp);
    setWidgetName(manifest, uiApp);
    setWidgetIcons(uiApp);
    setWidgetManifest(manifest);
    setWidgetOtherInfo(uiApp);
    setAppServiceInfo(uiApp);

    manifest.addUiApplication(uiApp);
    manifest.generate(path);
    LogDebug("Manifest file serialized");
}

void TaskManifestFile::setWidgetExecPath(UiApplication & uiApp)
{
    DPL::OptionalString pkgname = m_context.widgetConfig.pkgname;
    if (pkgname.IsNull()) {
        ThrowMsg(Exceptions::InternalError, "No Package name exists.");
    }

    std::ostringstream path;
    path << m_context.locations->getBinaryDir() << "/" << *m_context.widgetHandle;
    uiApp.setExec(DPL::FromASCIIString(path.str()));
}

void TaskManifestFile::setWidgetName(Manifest & manifest, UiApplication & uiApp)
{
    Assert(!!m_context.widgetHandle);
    WidgetDAOReadOnly dao(*m_context.widgetHandle);
    LanguageTagsList languageTags(dao.getLanguageTags());
    bool defaultNameSaved = false;

    //labels
    FOREACH(i, languageTags)
    {
        DPL::OptionalString tag = getLangTag(*i); // translate en -> en_US etc
        if (tag.IsNull())
        {
            tag = *i;
        }
        DPL::OptionalString name = dao.getLocalizedInfo(*i).name;
        generateWidgetName(manifest, uiApp, tag, name, defaultNameSaved);
    }
    DPL::OptionalString defaultLocale = dao.getDefaultlocale();
    if (!!defaultLocale && !defaultNameSaved)
    {
        DPL::OptionalString name = dao.getLocalizedInfo(*defaultLocale).name;
        generateWidgetName(manifest, uiApp, DPL::OptionalString::Null, name, defaultNameSaved);
    }
    //appid
    DPL::String pkgname;
    if(!!m_context.widgetConfig.pkgname)
    {
        pkgname = *m_context.widgetConfig.pkgname;
        uiApp.setAppid(pkgname);
    }

    //extraid
    if(!!m_context.widgetConfig.guid) {
        uiApp.setExtraid(*m_context.widgetConfig.guid);
    } else {
        if(!pkgname.empty()) {
            uiApp.setExtraid(DPL::String(L"http://") + pkgname);
        }
    }

    //type
    uiApp.setType(DPL::FromASCIIString("webapp"));
    manifest.setType(L"wgt");
    uiApp.setTaskmanage(true);
}

void TaskManifestFile::generateWidgetName(Manifest & manifest, UiApplication &uiApp, const DPL::OptionalString& tag, DPL::OptionalString name, bool & defaultNameSaved)
{
    if (!!name) {
        if (!!tag)
        {
            DPL::String locale =
                LocalizationUtils::BCP47LanguageTagToLocale(*tag);

            if (!locale.empty()) {
                uiApp.addLabel(LabelType(*name,*tag));
            }
            else
            {
                uiApp.addLabel(LabelType(*name));
                manifest.addLabel(LabelType(*name));
            }
        }
        else
        {
            defaultNameSaved = true;
            uiApp.addLabel(LabelType(*name));
            manifest.addLabel(LabelType(*name));
        }
    }
}

void TaskManifestFile::setWidgetIcons(UiApplication & uiApp)
{
    DPL::OptionalString pkgname = m_context.widgetConfig.pkgname;
    if (pkgname.IsNull()) {
        ThrowMsg(Exceptions::InternalError, "No Package name exists.");
    }

    //TODO this file will need to be updated when user locale preferences
    //changes.
    Assert(!!m_context.widgetHandle);
    WidgetDAOReadOnly dao(*m_context.widgetHandle);

    WidgetDAOReadOnly::WidgetLocalizedIconList locList = dao.getLocalizedIconList();
    WidgetDAOReadOnly::WidgetIconList list = dao.getIconList();
    bool defaultIconSaved = false;

    FOREACH(it, locList)
    {
        DPL::String i = it->widgetLocale;
        DPL::OptionalString tag = getLangTag(i); // translate en -> en_US etc
        if (tag.IsNull()) { tag = i; }

        generateWidgetIcon(uiApp, tag, i, it->iconId, list, defaultIconSaved);
    }
    DPL::OptionalString defaultLocale = dao.getDefaultlocale();
    if (!!defaultLocale && !defaultIconSaved)
    {
        int iconId = -1;
        FOREACH(it, locList)
        {
            if (it->widgetLocale == *defaultLocale)
            {
                iconId = it->iconId;
            }
        }
        if (-1 != iconId)
        {
            generateWidgetIcon(uiApp, DPL::OptionalString::Null,
                               DPL::String(),
                               iconId,
                               list,
                               defaultIconSaved);
        }
    }
}

void TaskManifestFile::generateWidgetIcon(UiApplication & uiApp, const DPL::OptionalString& tag,
        const DPL::String& language, int iconId, const WrtDB::WidgetDAOReadOnly::WidgetIconList & list,
        bool & defaultIconSaved)
{
    DPL::String locale;
    if (!!tag)
    {
        locale = LocalizationUtils::BCP47LanguageTagToLocale(*tag);
    }
    else
    {
        defaultIconSaved = true;
    }

    DPL::OptionalString src;
    FOREACH(icon, list)
    {
        if (icon->iconId == iconId) {
            src = icon->iconSrc;
        }
    }
    if (!!src) {
        DPL::String iconText;
        iconText += getIconTargetFilename(language);

        if(!locale.empty())
        {
            uiApp.addIcon(IconType(iconText,locale));
        }
        else
        {
            uiApp.addIcon(IconType(iconText));
        }
    }
}

void TaskManifestFile::setWidgetManifest(Manifest & manifest)
{
    if(!!m_context.widgetConfig.pkgname)
    {
        manifest.setPackage(*m_context.widgetConfig.pkgname);
    }
    if(!!m_context.widgetConfig.version)
    {
        manifest.setVersion(*m_context.widgetConfig.version);
    }
    DPL::String email = (!!m_context.widgetConfig.configInfo.authorEmail ?
                            *m_context.widgetConfig.configInfo.authorEmail : L"");
    DPL::String href = (!!m_context.widgetConfig.configInfo.authorHref ?
                            *m_context.widgetConfig.configInfo.authorHref : L"");
    DPL::String name = (!!m_context.widgetConfig.configInfo.authorName ?
                            *m_context.widgetConfig.configInfo.authorName : L"");
    manifest.addAuthor(Author(email,href,L"",name));
}

void TaskManifestFile::setWidgetOtherInfo(UiApplication & uiApp)
{
    uiApp.setNodisplay(false);
    //TODO
    //There is no "X-TIZEN-PackageType=wgt"
    //There is no X-TIZEN-PackageID in manifest "X-TIZEN-PackageID=" << DPL::ToUTF8String(*widgetID).c_str()
    //There is no Comment in pkgmgr "Comment=Widget application"
    //that were in desktop file
}

void TaskManifestFile::setAppServiceInfo(UiApplication & uiApp)
{
    Assert(!!m_context.widgetHandle);
    WidgetDAOReadOnly dao(*m_context.widgetHandle);
    WidgetApplicationServiceList appServiceList;
    dao.getAppServiceList(appServiceList);

    if (appServiceList.empty()) {
        LogInfo("Widget doesn't contain application service");
        return;
    }

    // x-tizen-svc=http://tizen.org/appsvc/operation/pick|NULL|image;
    FOREACH(it, appServiceList) {
        ApplicationService appService;
        appService.addOperation(it->operation);
        appService.addOperation(it->scheme);
        appService.addOperation(it->mime);
        uiApp.addApplicationService(appService);
    }
}

} //namespace WidgetInstall
} //namespace Jobs