From b7b1b75e5aa81fd7d1444ce5a8a296f4707d3a6e Mon Sep 17 00:00:00 2001 From: Soyoung Kim Date: Fri, 26 Oct 2012 00:03:24 +0900 Subject: [PATCH] Update wrt-plugins-common_0.3.60 --- CMakeLists.txt | 3 + debian/changelog | 59 ++ packaging/wrt-plugins-common.spec | 17 +- pkgconfigs/wrt-plugins-api-support.pc.in | 11 + pkgconfigs/wrt-popup-runner.pc.in | 12 + src/CMakeLists.txt | 8 + src/Commons/CMakeLists.txt | 5 +- src/Commons/WrtAccess/WrtAccess.cpp | 8 +- src/CommonsJavaScript/Converter.cpp | 6 + src/CommonsJavaScript/Converter.h | 7 + src/plugin-loading/plugin_container_support.cpp | 126 +-- src/plugin-loading/plugin_container_support.h | 10 +- src/plugin-loading/plugin_logic.cpp | 3 + src/plugins-api-support/CMakeLists.txt | 70 ++ src/plugins-api-support/CallbackSupport.h | 88 ++ src/plugins-api-support/ExportedApi.h | 153 ++++ src/plugins-api-support/IObject.h | 73 ++ src/plugins-api-support/IObject_cast.h | 38 + src/plugins-api-support/Object.cpp | 140 ++++ src/plugins-api-support/Object.h | 108 +++ src/plugins-api-support/ObjectFactory.cpp | 63 ++ src/plugins-api-support/ObjectFactory.h | 51 ++ src/plugins-api-support/Plugin.cpp | 45 ++ src/plugins-api-support/Plugin.h | 48 ++ src/plugins-api-support/PluginRegistration.cpp | 60 ++ src/plugins-api-support/PluginRegistration.h | 51 ++ src/plugins-api-support/PluginRegistrationImpl.h | 63 ++ src/plugins-api-support/PluginRegistry.cpp | 170 ++++ src/plugins-api-support/PluginRegistry.h | 82 ++ src/plugins-api-support/PluginSignals.h | 39 + src/plugins-api-support/SignalSignature.h | 40 + src/plugins-api-support/SignalsSupport.h | 101 +++ src/plugins-api-support/SoFeatures.h | 83 ++ src/plugins-api-support/detail/traits.h | 78 ++ src/plugins-api-support/js_types.h | 44 + src/plugins-api-support/traits.h | 46 ++ src/plugins-api-support/tuple.h | 39 + src/plugins-installer/CMakeLists.txt | 88 ++ src/plugins-installer/DESCRIPTION | 2 + src/plugins-installer/commons/wrt_common_types.h | 45 ++ src/plugins-installer/commons/wrt_error.h | 140 ++++ .../configuration_parser/deny_all_parser.h | 42 + .../configuration_parser/element_parser.h | 91 +++ .../configuration_parser/ignoring_parser.h | 43 + .../configuration_parser/libiriwrapper.h | 46 ++ .../configuration_parser/parser_runner.h | 47 ++ .../configuration_parser/root_parser.h | 88 ++ .../configuration_parser/widget_parser.h | 111 +++ src/plugins-installer/jobs/job.cpp | 105 +++ src/plugins-installer/jobs/job.h | 67 ++ src/plugins-installer/jobs/job_base.h | 113 +++ src/plugins-installer/jobs/job_exception_base.h | 100 +++ .../jobs/plugin_install/job_plugin_install.cpp | 95 +++ .../jobs/plugin_install/job_plugin_install.h | 83 ++ .../jobs/plugin_install/plugin_install_task.cpp | 444 ++++++++++ .../jobs/plugin_install/plugin_install_task.h | 72 ++ .../jobs/plugin_install/plugin_installer_context.h | 63 ++ .../jobs/plugin_install/plugin_installer_errors.h | 59 ++ .../jobs/plugin_install/plugin_installer_struct.h | 45 ++ .../jobs/plugin_install/plugin_metafile_reader.cpp | 83 ++ .../jobs/plugin_install/plugin_metafile_reader.h | 61 ++ .../jobs/plugin_install/plugin_objects.cpp | 109 +++ .../jobs/plugin_install/plugin_objects.h | 58 ++ .../jobs/widget_install/widget_install_errors.h | 98 +++ .../jobs/widget_install/widget_installer_struct.h | 121 +++ .../logic/installer_controller.cpp | 107 +++ src/plugins-installer/logic/installer_controller.h | 149 ++++ src/plugins-installer/logic/installer_logic.cpp | 259 ++++++ src/plugins-installer/logic/installer_logic.h | 78 ++ src/plugins-installer/misc/feature_logic.cpp | 108 +++ src/plugins-installer/misc/feature_logic.h | 99 +++ src/plugins-installer/misc/libxml_utils.cpp | 54 ++ src/plugins-installer/misc/libxml_utils.h | 58 ++ src/plugins-installer/misc/wac_widget_id.cpp | 100 +++ src/plugins-installer/misc/wac_widget_id.h | 42 + src/plugins-installer/misc/widget_location.cpp | 174 ++++ src/plugins-installer/misc/widget_location.h | 182 +++++ src/plugins-installer/wrt-installer/CMakeLists.txt | 72 ++ .../installer_callbacks_translate.cpp | 282 +++++++ .../wrt-installer/installer_callbacks_translate.h | 87 ++ .../wrt-installer/installer_main_thread.cpp | 77 ++ .../wrt-installer/installer_main_thread.h | 45 ++ .../wrt-installer/language_subtag_rst_tree.cpp | 170 ++++ .../wrt-installer/language_subtag_rst_tree.h | 47 ++ .../wrt-installer/option_parser.cpp | 57 ++ .../wrt-installer/option_parser.h | 39 + .../wrt-installer/plugin_utils.cpp | 109 +++ src/plugins-installer/wrt-installer/plugin_utils.h | 48 ++ .../wrt-installer/wrt_installer.cpp | 896 +++++++++++++++++++++ .../wrt-installer/wrt_installer.h | 155 ++++ .../wrt-installer/wrt_installer_api.cpp | 652 +++++++++++++++ .../wrt-installer/wrt_installer_api.h | 338 ++++++++ src/plugins-installer/wrt-installer/wrt_type.h | 255 ++++++ src/standards/W3C/Widget/JSWidget.cpp | 5 +- src/wrt-popup/CMakeLists.txt | 2 + src/wrt-popup/popup-bin/CMakeLists.txt | 64 ++ src/wrt-popup/popup-bin/Popup.cpp | 406 ++++++++++ src/wrt-popup/popup-bin/Popup.h | 39 + src/wrt-popup/popup-runner/CMakeLists.txt | 65 ++ src/wrt-popup/popup-runner/popup-runner.cpp | 283 +++++++ src/wrt-popup/popup-runner/popup-runner.h | 56 ++ wrt-plugins-common.manifest | 11 + 102 files changed, 10163 insertions(+), 74 deletions(-) create mode 100644 pkgconfigs/wrt-plugins-api-support.pc.in create mode 100644 pkgconfigs/wrt-popup-runner.pc.in create mode 100644 src/plugins-api-support/CMakeLists.txt create mode 100644 src/plugins-api-support/CallbackSupport.h create mode 100644 src/plugins-api-support/ExportedApi.h create mode 100644 src/plugins-api-support/IObject.h create mode 100644 src/plugins-api-support/IObject_cast.h create mode 100644 src/plugins-api-support/Object.cpp create mode 100644 src/plugins-api-support/Object.h create mode 100644 src/plugins-api-support/ObjectFactory.cpp create mode 100644 src/plugins-api-support/ObjectFactory.h create mode 100644 src/plugins-api-support/Plugin.cpp create mode 100644 src/plugins-api-support/Plugin.h create mode 100644 src/plugins-api-support/PluginRegistration.cpp create mode 100644 src/plugins-api-support/PluginRegistration.h create mode 100644 src/plugins-api-support/PluginRegistrationImpl.h create mode 100644 src/plugins-api-support/PluginRegistry.cpp create mode 100644 src/plugins-api-support/PluginRegistry.h create mode 100644 src/plugins-api-support/PluginSignals.h create mode 100644 src/plugins-api-support/SignalSignature.h create mode 100644 src/plugins-api-support/SignalsSupport.h create mode 100644 src/plugins-api-support/SoFeatures.h create mode 100644 src/plugins-api-support/detail/traits.h create mode 100644 src/plugins-api-support/js_types.h create mode 100644 src/plugins-api-support/traits.h create mode 100644 src/plugins-api-support/tuple.h create mode 100755 src/plugins-installer/CMakeLists.txt create mode 100644 src/plugins-installer/DESCRIPTION create mode 100644 src/plugins-installer/commons/wrt_common_types.h create mode 100644 src/plugins-installer/commons/wrt_error.h create mode 100644 src/plugins-installer/configuration_parser/deny_all_parser.h create mode 100644 src/plugins-installer/configuration_parser/element_parser.h create mode 100644 src/plugins-installer/configuration_parser/ignoring_parser.h create mode 100644 src/plugins-installer/configuration_parser/libiriwrapper.h create mode 100644 src/plugins-installer/configuration_parser/parser_runner.h create mode 100644 src/plugins-installer/configuration_parser/root_parser.h create mode 100755 src/plugins-installer/configuration_parser/widget_parser.h create mode 100644 src/plugins-installer/jobs/job.cpp create mode 100644 src/plugins-installer/jobs/job.h create mode 100644 src/plugins-installer/jobs/job_base.h create mode 100644 src/plugins-installer/jobs/job_exception_base.h create mode 100644 src/plugins-installer/jobs/plugin_install/job_plugin_install.cpp create mode 100644 src/plugins-installer/jobs/plugin_install/job_plugin_install.h create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_install_task.cpp create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_install_task.h create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_installer_context.h create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_installer_errors.h create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_installer_struct.h create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.cpp create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.h create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_objects.cpp create mode 100644 src/plugins-installer/jobs/plugin_install/plugin_objects.h create mode 100644 src/plugins-installer/jobs/widget_install/widget_install_errors.h create mode 100755 src/plugins-installer/jobs/widget_install/widget_installer_struct.h create mode 100644 src/plugins-installer/logic/installer_controller.cpp create mode 100644 src/plugins-installer/logic/installer_controller.h create mode 100644 src/plugins-installer/logic/installer_logic.cpp create mode 100644 src/plugins-installer/logic/installer_logic.h create mode 100644 src/plugins-installer/misc/feature_logic.cpp create mode 100644 src/plugins-installer/misc/feature_logic.h create mode 100644 src/plugins-installer/misc/libxml_utils.cpp create mode 100644 src/plugins-installer/misc/libxml_utils.h create mode 100644 src/plugins-installer/misc/wac_widget_id.cpp create mode 100644 src/plugins-installer/misc/wac_widget_id.h create mode 100644 src/plugins-installer/misc/widget_location.cpp create mode 100644 src/plugins-installer/misc/widget_location.h create mode 100644 src/plugins-installer/wrt-installer/CMakeLists.txt create mode 100644 src/plugins-installer/wrt-installer/installer_callbacks_translate.cpp create mode 100644 src/plugins-installer/wrt-installer/installer_callbacks_translate.h create mode 100755 src/plugins-installer/wrt-installer/installer_main_thread.cpp create mode 100755 src/plugins-installer/wrt-installer/installer_main_thread.h create mode 100644 src/plugins-installer/wrt-installer/language_subtag_rst_tree.cpp create mode 100644 src/plugins-installer/wrt-installer/language_subtag_rst_tree.h create mode 100644 src/plugins-installer/wrt-installer/option_parser.cpp create mode 100644 src/plugins-installer/wrt-installer/option_parser.h create mode 100644 src/plugins-installer/wrt-installer/plugin_utils.cpp create mode 100755 src/plugins-installer/wrt-installer/plugin_utils.h create mode 100644 src/plugins-installer/wrt-installer/wrt_installer.cpp create mode 100644 src/plugins-installer/wrt-installer/wrt_installer.h create mode 100755 src/plugins-installer/wrt-installer/wrt_installer_api.cpp create mode 100755 src/plugins-installer/wrt-installer/wrt_installer_api.h create mode 100755 src/plugins-installer/wrt-installer/wrt_type.h create mode 100755 src/wrt-popup/CMakeLists.txt create mode 100644 src/wrt-popup/popup-bin/CMakeLists.txt create mode 100644 src/wrt-popup/popup-bin/Popup.cpp create mode 100644 src/wrt-popup/popup-bin/Popup.h create mode 100644 src/wrt-popup/popup-runner/CMakeLists.txt create mode 100644 src/wrt-popup/popup-runner/popup-runner.cpp create mode 100644 src/wrt-popup/popup-runner/popup-runner.h create mode 100644 wrt-plugins-common.manifest diff --git a/CMakeLists.txt b/CMakeLists.txt index b36642f..5ea4ab5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -84,6 +84,7 @@ set(DESTINATION_HEADER_PREFIX include/${PROJECT_NAME}) set(DESTINATION_HEADERS_NON_JS ${DESTINATION_HEADER_PREFIX}/Commons) set(DESTINATION_HEADERS_JS ${DESTINATION_HEADER_PREFIX}/CommonsJavaScript) set(DESTINATION_HEADERS_JS_OVERLAY ${DESTINATION_HEADER_PREFIX}/js-overlay) +set(DESTINATION_HEADERS_WRT_POPUP_RUNNER ${DESTINATION_HEADER_PREFIX}/popup-runner) ################################################################################ # Target platform @@ -133,6 +134,8 @@ configure_and_install_pkg(wrt-plugins-widgetdb.pc) configure_and_install_pkg(wrt-plugins-plugin-manager.pc) configure_and_install_pkg(wrt-plugin-loading.pc) configure_and_install_pkg(wrt-plugin-js-overlay.pc) +configure_and_install_pkg(wrt-popup-runner.pc) +configure_and_install_pkg(wrt-plugins-api-support.pc) ################################################################################ # Cache diff --git a/debian/changelog b/debian/changelog index 1859a2b..97d7bc4 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,62 @@ +wrt-plugins-common (0.3.60) unstable; urgency=low + + * New Plugin API #2 : Plugins-Installer + * Add license installing + + * Git : framework/web/wrt-plugins-common + * Tag : wrt-plugins-common_0.3.60 + + -- Jihoon Chung Fri, 12 Oct 2012 08:11:28 +0900 + +wrt-plugins-common (0.3.59) unstable; urgency=low + + * Manifest file fix + + * Git : slp/pkgs/w/wrt-plugins-common + * Tag : wrt-plugins-common_0.3.59 + + -- Tae-Jeong Lee Tue, 09 Oct 2012 21:00:45 +0900 + +wrt-plugins-common (0.3.58) unstable; urgency=low + + * [Plugins] Add wrt-popup + * [Plugins] New plugin API #1 : API + * [Plugins] Change path for "plugin-installation-required" + + * Git : slp/pkgs/w/wrt-plugins-common + * Tag : wrt-plugins-common_0.3.58 + + -- Jihoon Chung Fri, 05 Oct 2012 07:45:07 +0900 + +wrt-plugins-common (0.3.57) unstable; urgency=low + + * Add smack manifest + + * Git : framework/web/wrt-plugins-common + * Tag : wrt-plugins-common_0.3.57 + + -- Tae-Jeong Lee Thu, 20 Sep 2012 20:12:59 +0900 + +wrt-plugins-common (0.3.56) unstable; urgency=low + + * Read allowed plugins when session start + * Converer toLongLong conversion + + * Git : framework/web/wrt-plugins-common + * Tag : wrt-plugins-common_0.3.56 + + -- Tae-Jeong Lee Wed, 19 Sep 2012 12:14:22 +0900 + +wrt-plugins-common (0.3.55) unstable; urgency=low + + * [Plugins] Allow to initialize localStorage for many widgets + * [Plugins] Upgrade Security dependencies + + * Git : slp/pkgs/w/wrt-plugins-common + * Tag : wrt-plugins-common_0.3.55 + + -- Jihoon Chung Tue, 11 Sep 2012 15:35:20 +0900 + wrt-plugins-common (0.3.54) unstable; urgency=low * [Plugins] Code clean up diff --git a/packaging/wrt-plugins-common.spec b/packaging/wrt-plugins-common.spec index f5297c7..4094c0d 100644 --- a/packaging/wrt-plugins-common.spec +++ b/packaging/wrt-plugins-common.spec @@ -1,7 +1,7 @@ -#sbs-git:slp/pkgs/w/wrt-plugins-common wrt-plugins-common 0.3.54 +#sbs-git:slp/pkgs/w/wrt-plugins-common wrt-plugins-common 0.3.60 Name: wrt-plugins-common Summary: wrt-plugins common library -Version: 0.3.54 +Version: 0.3.60 Release: 1 Group: Development/Libraries License: Apache License, Version 2.0 @@ -10,15 +10,18 @@ Source0: %{name}-%{version}.tar.gz BuildRequires: cmake BuildRequires: pkgconfig(dpl-efl) BuildRequires: pkgconfig(wrt-plugins-types) -BuildRequires: pkgconfig(ace-client) +BuildRequires: pkgconfig(security-client) BuildRequires: pkgconfig(dpl-event-efl) BuildRequires: pkgconfig(ewebkit2) BuildRequires: pkgconfig(dpl-wrt-dao-ro) +BuildRequires: pkgconfig(dpl-wrt-dao-rw) BuildRequires: pkgconfig(dpl-db-efl) BuildRequires: pkgconfig(libpcrecpp) BuildRequires: pkgconfig(mm-sound) BuildRequires: pkgconfig(mm-player) BuildRequires: pkgconfig(icu-i18n) +BuildRequires: pkgconfig(libxml-2.0) +BuildRequires: pkgconfig(cert-svc-vcore) Requires: ldconfig %description @@ -45,6 +48,8 @@ cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \ make %{?jobs:-j%jobs} %install +mkdir -p %{buildroot}/usr/share/license +cp LICENSE %{buildroot}/usr/share/license/%{name} %make_install %clean @@ -53,15 +58,19 @@ rm -rf %{buildroot} %post mkdir -p /usr/lib/wrt-plugins mkdir -p /usr/etc/wrt/injected-javascript -touch /opt/apps/widget/plugin-installation-required +touch /opt/share/widget/plugin-installation-required %files +%manifest wrt-plugins-common.manifest /usr/etc/wrt-plugins/config.dtd %{_libdir}/*.so %{_libdir}/*.so.* %{_libdir}/wrt-plugins/w3c-widget-interface/libwrt-plugins-w3c-widget-interface.so %attr(644,root,root) %{_libdir}/wrt-plugins/standard-features-list %attr(644,root,root) /usr/share/wrt-plugins-common/widget_interface_db.sql +%attr(755,root,root) %{_bindir}/wrt-popup-runtime +%attr(755,root,root) %{_bindir}/wrt-plugins-installer +%{_datadir}/license/%{name} %files devel %{_includedir}/* diff --git a/pkgconfigs/wrt-plugins-api-support.pc.in b/pkgconfigs/wrt-plugins-api-support.pc.in new file mode 100644 index 0000000..579a085 --- /dev/null +++ b/pkgconfigs/wrt-plugins-api-support.pc.in @@ -0,0 +1,11 @@ +prefix=/usr +exec_prefix=${prefix} +libdir=${prefix}/lib +includedir=${prefix}/include + +Name: wrt-plugins-api-support +Description: wrt-plugins-api-support +Version: @PROJECT_VERSION@ +Requires: +Libs: -lwrt-plugins-api-support -L${libdir} +Cflags: -I${includedir}/wrt-plugins-api-support diff --git a/pkgconfigs/wrt-popup-runner.pc.in b/pkgconfigs/wrt-popup-runner.pc.in new file mode 100644 index 0000000..7e53635 --- /dev/null +++ b/pkgconfigs/wrt-popup-runner.pc.in @@ -0,0 +1,12 @@ +prefix=/usr +project_name=@CMAKE_PROJECT_NAME@ +exec_prefix=${prefix} +libdir=${prefix}/lib +includedir=${prefix}/include/${project_name} + +Name: wrt-popup-runner +Description: Library with function to run wrt runtime popup +Version: @CMAKE_PROJECT_VERSION@ +Requires: dpl-efl dpl-dbus-efl elementary security-client +Libs: -L${libdir} -lwrt-popup-runner +Cflags: -I${includedir} diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 8ab7022..76e712d 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -42,6 +42,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/CommonsJavaScript ${CMAKE_CURRENT_SOURCE_DIR}/plugin-loading ${CMAKE_CURRENT_SOURCE_DIR}/js-overlay + ${CMAKE_CURRENT_SOURCE_DIR}/wrt-popup/popup-runner ) #target names @@ -49,12 +50,19 @@ set(TARGET_PLUGIN_LOADING_LIB "wrt-plugin-loading") set(TARGET_COMMONS "wrt-plugins-commons") set(TARGET_COMMONS_JAVASCRIPT "wrt-plugins-commons-javascript") set(TARGET_JS_OVERLAY "wrt-plugins-js-overlay") +SET(TARGET_WRT_POPUP "wrt-popup-runtime") +SET(TARGET_WRT_POPUP_RUNNER_LIB "wrt-popup-runner") +set(TARGET_PLUGINS_API_SUPPORT "wrt-plugins-api-support") set(PLUGIN_LOADING_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/plugin-loading) +set(PLUGINS_API_SUPPORT_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/plugins-api-support) +add_subdirectory(plugins-api-support) add_subdirectory(plugin-loading) add_subdirectory(js-overlay) add_subdirectory(Commons) add_subdirectory(CommonsJavaScript) add_subdirectory(modules) add_subdirectory(standards) +add_subdirectory(wrt-popup) +add_subdirectory(plugins-installer) diff --git a/src/Commons/CMakeLists.txt b/src/Commons/CMakeLists.txt index a195bc9..64126f3 100644 --- a/src/Commons/CMakeLists.txt +++ b/src/Commons/CMakeLists.txt @@ -30,7 +30,7 @@ endmacro() include_config_file(WrtAccess) pkg_search_module(plugin-types REQUIRED wrt-plugins-types) -pkg_search_module(ace-client REQUIRED ace-client) +pkg_search_module(ace-client REQUIRED security-client) pkg_search_module(dpl-event REQUIRED dpl-event-efl) pkg_search_module(icu REQUIRED icu-i18n) @@ -66,9 +66,10 @@ target_link_libraries(${TARGET_NAME} ${ace-client_LIBRARIES} ${dpl-event_LIBRARIES} ${icu_LIBRARIES} + ${TARGET_WRT_POPUP_RUNNER_LIB} ) -set_target_properties(${TARGET_NAME} PROPERTIES +set_target_properties(${TARGET_NAME} PROPERTIES SOVERSION ${CMAKE_PROJECT_API_VERSION} VERSION ${CMAKE_PROJECT_VERSION} ) diff --git a/src/Commons/WrtAccess/WrtAccess.cpp b/src/Commons/WrtAccess/WrtAccess.cpp index 67b2979..b1f5850 100644 --- a/src/Commons/WrtAccess/WrtAccess.cpp +++ b/src/Commons/WrtAccess/WrtAccess.cpp @@ -34,6 +34,7 @@ #include #include +#include "popup-runner.h" IMPLEMENT_SAFE_SINGLETON(WrtDeviceApis::Commons::WrtAccess) namespace { @@ -150,11 +151,8 @@ void WrtAccess::initialize(int widgetId) LogDebug("Invalid widget id"); Throw(Exception); } - // TODO: implement UI handler - ace_return_t ret = ace_client_initialize(NULL); - // Assert(ACE_OK == ret); // This is commented because UI handler is not - // implemented, ace client will work, but initialization will return - // ACE_INVALID_ARGUMENTS + ace_return_t ret = ace_client_initialize(Wrt::Popup::run_popup); + Assert(ACE_OK == ret); m_initialized = true; m_widgetId = widgetId; } diff --git a/src/CommonsJavaScript/Converter.cpp b/src/CommonsJavaScript/Converter.cpp index 60d58e1..f550032 100644 --- a/src/CommonsJavaScript/Converter.cpp +++ b/src/CommonsJavaScript/Converter.cpp @@ -80,6 +80,12 @@ long Converter::toLong(const JSValueRef& arg) return (isNan(tmp) ? 0 : static_cast(tmp)); } +long long Converter::toLongLong(const JSValueRef& arg) +{ + double tmp = toNumber_(arg); + return (isNan(tmp) ? 0 : static_cast(tmp)); +} + unsigned long Converter::toULong(const JSValueRef& arg) { return static_cast(toLong(arg)); diff --git a/src/CommonsJavaScript/Converter.h b/src/CommonsJavaScript/Converter.h index b18635c..302141d 100644 --- a/src/CommonsJavaScript/Converter.h +++ b/src/CommonsJavaScript/Converter.h @@ -93,6 +93,13 @@ class Converter : private DPL::Noncopyable long toLong(const JSValueRef& arg); /** + * Converts JSvalueRef to long long integer value. + * @param arg JSValueRef object to convert. + * @return Long long integer value. + * @throw ConversionException Thrown when conversion fails. + */ + long long toLongLong(const JSValueRef& arg); + /** * Converts JSValueRef to unsigned long value. * @param arg JSValueRef object to convert. * @return Unsigned long value. diff --git a/src/plugin-loading/plugin_container_support.cpp b/src/plugin-loading/plugin_container_support.cpp index b8a1a08..68ebfd4 100644 --- a/src/plugin-loading/plugin_container_support.cpp +++ b/src/plugin-loading/plugin_container_support.cpp @@ -28,18 +28,15 @@ namespace { const char *STANDARD_FEATURES_LIST_FILE = "standard-features-list"; +const char* FEATURE_WAC20_DEVICAPIS_NAME = "http://wacapps.net/api/deviceapis"; } using namespace WrtDB; -PluginContainerSupport::PluginContainerSupport() -{ - // Retrieve plugin model list - readPlugins(); - - // Retrieve features model list - readFeatures(); +#include +PluginContainerSupport::PluginContainerSupport(): m_initialized(false) +{ // Reading standard features list from file readStandardFeaturesList(); } @@ -56,6 +53,72 @@ PluginContainerSupport::~PluginContainerSupport() m_standardFeatureList.clear(); } +void PluginContainerSupport::readAllowedPlugins(int widgetHandle) +{ + //TODO it has to return LIST NOT SET!!! + WidgetDAOReadOnly widgetDao(widgetHandle); + DbWidgetFeatureSet features = widgetDao.getFeaturesList(); + + std::list allowedFeatures(m_standardFeatureList); + FOREACH(it, features) { + LogInfo("Loading api-feature: " << it->name); + if (it->rejected) { + LogWarning("Api-feature was rejected by ace. (Api-feature name: " + << it->name << ")" ); + continue; + } + + allowedFeatures.push_back(DPL::ToUTF8String(it->name)); + } + + auto widgetType = widgetDao.getWidgetType(); + + //WAC2.0 requirement + if (widgetType == APP_TYPE_WAC20) { + auto it = find(allowedFeatures.begin(), + allowedFeatures.end(), + FEATURE_WAC20_DEVICAPIS_NAME); + + if (allowedFeatures.end() == it) { + LogInfo("WAC2.0 Deviceapis not declared but added"); + allowedFeatures.push_front(FEATURE_WAC20_DEVICAPIS_NAME); + } + } + + FeatureData* dt = NULL; + std::map featureDataList = FeatureDAOReadOnly::GetFeatures(allowedFeatures); + DeviceCapList deviceCapabilities = FeatureDAOReadOnly::GetDevCapWithFeatureHandle(); + FOREACH(data, featureDataList) { + dt = &(data->second); + registerPluginModel(dt->pluginHandle); + registerFeatureModel(data->first, dt, deviceCapabilities); + } + + m_initialized = true; +} + +void PluginContainerSupport::registerFeatureModel(FeatureHandle handle, FeatureData* data, DeviceCapList deviceCapabilities) +{ + LogDebug("Analyzing feature: " << handle); + FeatureModelPtr model = getFeatureModel(handle); + if (model) { + LogDebug("Model for feature:" << handle << " already created"); + return; + } + + LogDebug("Creating Model for feature:" << handle); + + model.Reset(new FeatureModel(handle)); + + std::set devCapList; + auto ret = deviceCapabilities.equal_range(handle); + for (auto devCapIt = ret.first; devCapIt != ret.second; devCapIt++) { + devCapList.insert((*devCapIt).second); + } + model->SetData(data->featureName, devCapList, data->pluginHandle); + m_featureModels.insert(model); +} + void PluginContainerSupport::registerPluginModel(DbPluginHandle handle) { PluginModelPtr model = getPluginModelById(handle); @@ -82,55 +145,6 @@ void PluginContainerSupport::registerPluginModel(DbPluginHandle handle) m_pluginModels.insert(model); } -void PluginContainerSupport::readPlugins() -{ - LogDebug("Retrieving installed plugin list..."); - PluginHandleList plugins = PluginDAOReadOnly::getPluginHandleList(); - - FOREACH(it, plugins) - { - registerPluginModel(*it); - } -} - -void PluginContainerSupport::readFeatures() -{ - std::map featureNames = FeatureDAOReadOnly::GetNames(); - std::multimap deviceCapabilities = FeatureDAOReadOnly::GetDevCapWithFeatureHandle(); - - FOREACH(pluginIt, m_pluginModels) - { - PluginModelPtr model = *pluginIt; - LogDebug("Analyzing Plugin model: " << model->Handle.Get()); - - WrtDB::DbPluginHandle pluginHandle = model->Handle.Get(); - FeatureHandleListPtr featureHandles = model->FeatureHandles.Get(); - - FOREACH(featureIt, *featureHandles) - { - LogDebug("Analyzing feature: " << *featureIt); - FeatureModelPtr model = getFeatureModel(*featureIt); - if (model) { - LogDebug("Model for feature:" << *featureIt << " already created"); - continue; - } - - LogDebug("Creating Model for feature:" << *featureIt); - - model.Reset(new FeatureModel(*featureIt)); - - std::set devCapList; - auto ret = deviceCapabilities.equal_range(*featureIt); - for (auto devCapIt = ret.first; devCapIt != ret.second; devCapIt++) - { - devCapList.insert((*devCapIt).second); - } - model->SetData(featureNames.find(*featureIt)->second, devCapList, pluginHandle); - m_featureModels.insert(model); - } - } -} - void PluginContainerSupport::readStandardFeaturesList() { LogDebug("Reading standard features list from file..."); diff --git a/src/plugin-loading/plugin_container_support.h b/src/plugin-loading/plugin_container_support.h index e8b38c4..5192bcd 100644 --- a/src/plugin-loading/plugin_container_support.h +++ b/src/plugin-loading/plugin_container_support.h @@ -52,15 +52,16 @@ private: FeatureModelContainer m_featureModels; + bool m_initialized; + private: // Reading - void readPlugins(); - void readFeatures(); void readStandardFeaturesList(); // Plugin models void registerPluginModel(WrtDB::DbPluginHandle handle); - + typedef std::multimap DeviceCapList; + void registerFeatureModel(WrtDB::FeatureHandle handle, WrtDB::FeatureData* data, DeviceCapList deviceCapabilities); WrtDB::FeatureModelPtr getFeatureModel(const std::string &name) const ; WrtDB::FeatureModelPtr getFeatureModel(WrtDB::FeatureHandle handle) const ; @@ -70,6 +71,9 @@ private: public: PluginContainerSupport(); + bool isInitialized() { return m_initialized; } + void readAllowedPlugins(int widgetHandle); + FeaturesList getStandardFeatures() const; PluginsList getStandardPlugins() const; diff --git a/src/plugin-loading/plugin_logic.cpp b/src/plugin-loading/plugin_logic.cpp index 2c2fc6c..e97b593 100644 --- a/src/plugin-loading/plugin_logic.cpp +++ b/src/plugin-loading/plugin_logic.cpp @@ -220,6 +220,9 @@ void PluginLogic::Impl::startSession(int widgetHandle, { LogInfo("Starting widget session..."); + if (!m_pluginsSupport->isInitialized()) + m_pluginsSupport->readAllowedPlugins(widgetHandle); + auto sessionIt = m_sessions.find(context); // Check if corresponding session if not already created diff --git a/src/plugins-api-support/CMakeLists.txt b/src/plugins-api-support/CMakeLists.txt new file mode 100644 index 0000000..7a67b5e --- /dev/null +++ b/src/plugins-api-support/CMakeLists.txt @@ -0,0 +1,70 @@ +# 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 CMakeLists.txt +# @author Grzegorz Krawczyk (g.krawczyk@samsung.com) +# @version 1.0 +# + +pkg_search_module(dpl REQUIRED dpl-efl) + +set(PLUGINS_API_SUPPORT_SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/Plugin.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/Object.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/ObjectFactory.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/PluginRegistration.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/PluginRegistry.cpp +) + +INCLUDE_DIRECTORIES( + ${CMAKE_CURRENT_SOURCE_DIR} + ${dpl_INCLUDE_DIRS} +) + +ADD_LIBRARY(${TARGET_PLUGINS_API_SUPPORT} SHARED + ${PLUGINS_API_SUPPORT_SOURCES} +) + +SET_TARGET_PROPERTIES(${TARGET_PLUGIN_API_SUPPORT} PROPERTIES + COMPILE_FLAGS -fPIC + LINK_FLAGS "-Wl,--as-needed -Wl,--hash-style=both" +) + +SET_TARGET_PROPERTIES(${TARGET_PLUGINS_API_SUPPORT} PROPERTIES + SOVERSION ${CMAKE_PROJECT_API_VERSION} + VERSION ${CMAKE_PROJECT_VERSION} +) + +target_link_libraries(${TARGET_PLUGINS_API_SUPPORT} + ${dpl_LIBRARIES} +) + +INSTALL(TARGETS ${TARGET_PLUGINS_API_SUPPORT} + DESTINATION lib + PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE + GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE +) + +INSTALL(FILES + ${CMAKE_CURRENT_SOURCE_DIR}/ExportedApi.h + ${CMAKE_CURRENT_SOURCE_DIR}/Plugin.h + ${CMAKE_CURRENT_SOURCE_DIR}/IObject.h + ${CMAKE_CURRENT_SOURCE_DIR}/ObjectFactory.h + ${CMAKE_CURRENT_SOURCE_DIR}/CallbackSupport.h + ${CMAKE_CURRENT_SOURCE_DIR}/tuple.h + ${CMAKE_CURRENT_SOURCE_DIR}/PluginSignals.h + ${CMAKE_CURRENT_SOURCE_DIR}/SignalSignature.h + ${CMAKE_CURRENT_SOURCE_DIR}/PluginRegistration.h + DESTINATION include/wrt-plugins-api-support) diff --git a/src/plugins-api-support/CallbackSupport.h b/src/plugins-api-support/CallbackSupport.h new file mode 100644 index 0000000..f460fd1 --- /dev/null +++ b/src/plugins-api-support/CallbackSupport.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2012 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 CallbackSupport.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_CALLBACK_SUPPORT_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_CALLBACK_SUPPORT_H_ + +#include +#include +#include +#include + +namespace WrtPluginsApi +{ + +template +class CallbackSupport +{ +public: + typedef typename Sig::Signature SlotSignature; + typedef typename Sig::Type SlotType; + typedef std::string GroupType; + typedef std::vector SlotList; + + void Connect(const GroupType& group, const SlotType& slot) + { + auto groupIt = m_slots.find(group); + if (m_slots.end() == groupIt) + { + groupIt = m_slots.insert(std::make_pair(group, SlotList())).first; + } + groupIt->second.push_back(slot); + } + + void Disconnect(const GroupType& group) + { + m_slots.erase(group); + } + + template + void Invoke(const Args&... args) + { + + FOREACH(groupIt, m_slots) + { + FOREACH(slotIt, groupIt->second) + { + (*slotIt)(args...); + } + } + } + + template + void InvokeGroup(const GroupType& group, const Args&... args) + { + auto groupIt = m_slots.find(group); + + if (m_slots.end() != groupIt) + { + FOREACH (slotIt, groupIt->second) + { + (*slotIt)(args...); + } + } + } + +private: + std::map m_slots; +}; + +} +#endif diff --git a/src/plugins-api-support/ExportedApi.h b/src/plugins-api-support/ExportedApi.h new file mode 100644 index 0000000..f11395c --- /dev/null +++ b/src/plugins-api-support/ExportedApi.h @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2012 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 ExportedApi.h + * @author Grzegorz Krawczyk (g.krawczyk@samsung.com) + * @version 0.1 + * @brief + */ +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_EXPORTED_API_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_EXPORTED_API_H_ + +#include + +/** + * This file provides definition of entry point to the plugin's shared library + * used by wrt. + * + * Each plugin have to provide 1 symbol which is get by dlsym. + * The name of required symbol is specified by 'GetExportedSymbolName' function + * The type of this symbol is pointer to ExportedApi struct + * + * To allow access to your plugin, you have to: + * + * 1)define 3 functions: + * - Register, + * - Unregister, + * - GetProvidedFeatures + * (names are not important) + * + * 2)define global struct named "dll_api" and initialize it with above functions + * *Example: + * ExportedApi dll_api = {Register, Unregister, GetProvidedFeatures}; + * + * + * Detailed Example how the file with api may looks like file: + * + #include + #include + + #include + #include + #include + #include + + #include "JSTest.h" + #include "plugin_config.h" + + #define OBJECT_WIDGET "widget" + #define OBJECT_TEST "__test" + + using namespace WrtPlugins::W3C; + using namespace WrtDeviceApis; + using namespace WrtDeviceApis::Commons; + using namespace WrtPluginsApi; + + namespace W3CTest + { + + void on_widget_start_callback(int widgetId) + { + + } + + void on_widget_stop_callback(int widgetId) + { + } + + } + + void Register(PluginRegistration& r) + { + Plugin* plugin = new Plugin(); + + auto test = ObjectFactory::createMainObject( + OBJECT_TEST, + WrtPlugins::W3C::JSTest::getClassRef, + OBJECT_WIDGET); + + plugin->AddObject(test); + + r.Connect(W3CTest::on_widget_start_callback); + + r.Connect(W3CTest::on_widget_stop_callback); + + r.AddPlugin(*plugin); + } + + void Unregister(PluginRegistration& r, Plugin* plugin) + { + r.DisconnectAll(); + delete plugin; + } + + void GetProvidedFeatures(feature_mapping_interface_t *mapping) + { + WrtPlugins::W3C::WidgetTestDeclarations::getMappingInterface(mapping); + } + + ExportedApi dll_api={Register, Unregister, GetProvidedFeatures}; + + #undef OBJECT_WIDGET + #undef OBJECT_TEST + * + * + * */ + +//forward declaration +struct feature_mapping_interface_s; +typedef struct feature_mapping_interface_s feature_mapping_interface_t; + +class WrtPluginsApi::Plugin; + +extern "C" struct ExportedApi +{ + /* + * This function is invoked when library is loaded + * */ + void (*Register)(WrtPluginsApi::PluginRegistration&); + + /* + * This function is invoked when library is unloaded + * */ + void (*Unregister)(WrtPluginsApi::PluginRegistration&, + WrtPluginsApi::Plugin* plugin); + + /* + * This function is invoked by wrt-plugins-installer to obtain + * info about features,functions,objects provided by plugin + * */ + void (*GetProvidedFeatures)(feature_mapping_interface_t*); +}; + + +constexpr const char* GetExportedSymbolName() +{ + return "dll_api"; +} + +#endif diff --git a/src/plugins-api-support/IObject.h b/src/plugins-api-support/IObject.h new file mode 100644 index 0000000..a3acf24 --- /dev/null +++ b/src/plugins-api-support/IObject.h @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2012 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 IObject.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_IOBJECT_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_IOBJECT_H_ + +#include +#include + +extern "C" { + typedef struct OpaqueJSClass* const (*ClassRef)(); +} + +namespace WrtPluginsApi +{ + +enum class IObjectType +{ + Object, + Function, + Interface, + InterfaceInstance +}; + +enum class IObjectOption +{ + Overlayed +}; + +class IObject; +typedef std::shared_ptr IObjectPtr; + +class IObject +{ + public: + constexpr static const char* WINDOW_OBJECT() + { + return "window"; + } + + virtual void AddChild(const IObjectPtr& ) = 0; + + /* + * Optional + * */ + virtual void setBoolOption(IObjectOption option, bool value) = 0; + + virtual ~IObject(){}; +}; + +typedef std::list IObjectsList; +typedef std::shared_ptr IObjectsListPtr; + +} +#endif diff --git a/src/plugins-api-support/IObject_cast.h b/src/plugins-api-support/IObject_cast.h new file mode 100644 index 0000000..8dcf234 --- /dev/null +++ b/src/plugins-api-support/IObject_cast.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2012 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 IObject_cast.h + * @author + * @version + * @brief + */ +#ifndef _WRT_PLUGINS_COMMON_PLUGINS_API_SUPPORT_CAST_H_ +#define _WRT_PLUGINS_COMMON_PLUGINS_API_SUPPORT_CAST_H_ + +#include +#include +#include + +namespace WrtPluginsApi +{ + +inline ObjectPtr CAST(const IObjectPtr& object) +{ + return std::dynamic_pointer_cast(object); +} + +} +#endif diff --git a/src/plugins-api-support/Object.cpp b/src/plugins-api-support/Object.cpp new file mode 100644 index 0000000..1aa039e --- /dev/null +++ b/src/plugins-api-support/Object.cpp @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2012 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 Object.cpp + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ + +#include "Object.h" + +namespace WrtPluginsApi +{ + +void Object::AddChild(const IObjectPtr& child) +{ + if(!m_children) + { + m_children = IObjectsListPtr(new IObjectsList); + } + m_children->push_back(child); +} + +void Object::setBoolOption(IObjectOption option, bool value) +{ + if(!m_options) + { + m_options = ObjectOptionPtr(new ObjectOption); + } + + switch(option) + { + case IObjectOption::Overlayed: + m_options->overlayedMode = value; + break; + default: + break; + } +} + +IObjectsListPtr Object::GetChildren() const +{ + return m_children; +} + +ClassRef Object::GetClass() const +{ + return m_classRef; +} + +ClassRef Object::GetClassConstructor() const +{ + return m_constructorRef; +} + +const char* Object::GetInterfaceName() const +{ + return m_interfaceName; +} + +const char* Object::GetName() const +{ + return m_name; +} + +IObjectType Object::GetType() const +{ + return m_type; +} + +const char* Object::GetParentName() const +{ + return m_parentName; +} + +ObjectOptionPtr Object::GetOptions() const +{ + return m_options; +} + +Object::Object(const char* name, + ClassRef ref, + IObjectType type) + : m_name(name), + m_classRef(ref), + m_parentName(0), + m_type(type), + m_interfaceRef(0), + m_interfaceName(0), + m_constructorRef(0) +{ +} + +Object::Object(const char* name, + ClassRef ref, + const char* parentName, + IObjectType type) + : m_name(name), + m_classRef(ref), + m_parentName(parentName), + m_type(type), + m_interfaceRef(0), + m_interfaceName(0), + m_constructorRef(0) +{ +} + +Object::Object(const char* name, + ClassRef interfaceRef, + const char* interfaceName, + ClassRef constructorRef, + const char* parentName, + IObjectType type) + : m_name(name), + m_parentName(parentName), + m_type(type), + m_interfaceRef(interfaceRef), + m_interfaceName(interfaceName), + m_constructorRef(constructorRef) +{ +} + +Object::~Object() +{ +} + +} diff --git a/src/plugins-api-support/Object.h b/src/plugins-api-support/Object.h new file mode 100644 index 0000000..285f3fe --- /dev/null +++ b/src/plugins-api-support/Object.h @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2012 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 IObject.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_OBJECT_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_OBJECT_H_ + +#include +#include + +#include +#include + +namespace WrtPluginsApi +{ + +class Object; +typedef std::shared_ptr ObjectPtr; + +struct ObjectOption +{ + DPL::Optional overlayedMode; +}; +typedef std::shared_ptr ObjectOptionPtr; + + +class Object : public IObject +{ + public: + Object(const char* name, + ClassRef ref, + IObjectType type = IObjectType::Object); + + Object(const char* name, + ClassRef ref, + const char* parentName = IObject::WINDOW_OBJECT(), + IObjectType type = IObjectType::Object); + + Object(const char* name, + ClassRef interfaceRef, + const char* interfaceName, + ClassRef constructorRef, + const char* parentName = IObject::WINDOW_OBJECT(), + IObjectType type = IObjectType::Object); + + ~Object(); + + void AddChild(const IObjectPtr& ); + + void setBoolOption(IObjectOption option, bool value); + + IObjectsListPtr GetChildren() const ; + + ClassRef GetClass() const; + + /* + * Available only for object with type InterfaceInstance + * */ + ClassRef GetClassConstructor() const; + + const char* GetInterfaceName() const; + + const char* GetName() const; + + IObjectType GetType() const; + + const char* GetParentName() const; + + ObjectOptionPtr GetOptions() const; + + private: + const char* m_name; + ClassRef m_classRef; + + const char* m_parentName; + + IObjectType m_type; + + ClassRef m_interfaceRef; + const char* m_interfaceName; + ClassRef m_constructorRef; + + ObjectOptionPtr m_options; + + IObjectsListPtr m_children; +}; + +} + +#endif diff --git a/src/plugins-api-support/ObjectFactory.cpp b/src/plugins-api-support/ObjectFactory.cpp new file mode 100644 index 0000000..c854344 --- /dev/null +++ b/src/plugins-api-support/ObjectFactory.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2012 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 ObjectFactory.cpp + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ + +#include "ObjectFactory.h" +#include "Object.h" + +namespace WrtPluginsApi { +namespace ObjectFactory { + +IObjectPtr createObject( + const char* name, + ClassRef ref, + IObjectType type) +{ + return IObjectPtr(new Object(name, ref, type)); +} + +IObjectPtr createMainObject( + const char* name, + ClassRef ref, + const char* parentName, + IObjectType type) +{ + return IObjectPtr(new Object(name, ref, parentName, type)); +} + +IObjectPtr createObjectWithInterface( + const char* name, + ClassRef interfaceRef, + const char* interfaceName, + ClassRef constructorRef, + const char* parentName, + IObjectType type) +{ + return IObjectPtr(new Object(name, + interfaceRef, + interfaceName, + constructorRef, + parentName, + type)); +} + +} +} diff --git a/src/plugins-api-support/ObjectFactory.h b/src/plugins-api-support/ObjectFactory.h new file mode 100644 index 0000000..bd43878 --- /dev/null +++ b/src/plugins-api-support/ObjectFactory.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2012 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 ObjectFactory.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_OBJECT_FACTORY_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_OBJECT_FACTORY_H_ + +#include +#include + +namespace WrtPluginsApi { +namespace ObjectFactory { + + IObjectPtr createObject( + const char* name, + ClassRef ref, + IObjectType type = IObjectType::Object); + + IObjectPtr createMainObject( + const char* name, + ClassRef ref, + const char* parentName = IObject::WINDOW_OBJECT(), + IObjectType type = IObjectType::Object); + + IObjectPtr createObjectWithInterface( + const char* name, + ClassRef interfaceRef, + const char* interfaceName, + ClassRef constructorRef, + const char* parentName = IObject::WINDOW_OBJECT(), + IObjectType type = IObjectType::Object); +} +} +#endif diff --git a/src/plugins-api-support/Plugin.cpp b/src/plugins-api-support/Plugin.cpp new file mode 100644 index 0000000..a3c1d04 --- /dev/null +++ b/src/plugins-api-support/Plugin.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2012 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 Plugin.cpp + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ +#include "Plugin.h" + +namespace WrtPluginsApi +{ + +void Plugin::AddObject(const IObjectPtr& object) +{ + m_objects->push_back(object); +} + +IObjectsListPtr Plugin::GetObjects() const +{ + return m_objects; +} + +Plugin::~Plugin() +{ +} + +Plugin::Plugin() : m_objects(new IObjectsList()) +{ +} + +} diff --git a/src/plugins-api-support/Plugin.h b/src/plugins-api-support/Plugin.h new file mode 100644 index 0000000..3cee0a2 --- /dev/null +++ b/src/plugins-api-support/Plugin.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2012 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 Plugin.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_H_ + +#include +#include + +namespace WrtPluginsApi +{ + +class Plugin +{ +public: + void AddObject(const IObjectPtr& object); + + IObjectsListPtr GetObjects() const; + + Plugin(); + + virtual ~Plugin(); + +private: + IObjectsListPtr m_objects; +}; + +} + +#endif diff --git a/src/plugins-api-support/PluginRegistration.cpp b/src/plugins-api-support/PluginRegistration.cpp new file mode 100644 index 0000000..dadd367 --- /dev/null +++ b/src/plugins-api-support/PluginRegistration.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2012 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 PluginRegistration.cpp + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#include "PluginRegistration.h" + +#include "PluginRegistrationImpl.h" +#include "Plugin.h" +#include + +namespace WrtPluginsApi +{ + +PluginRegistration::PluginRegistration(Impl* impl) : m_impl(impl) +{ + Assert(impl != 0 && "impl is NULL"); +} + +template +void PluginRegistration::Connect(const typename SignalSignature::Type& slot) +{ + m_impl->Connect(slot); +} + +void PluginRegistration::DisconnectAll() +{ + m_impl->DisconnectAll(); +} + +void PluginRegistration::AddPlugin(Plugin& plugin) +{ + m_impl->AddPlugin(plugin); +} + +#define EXPLICIT_INSTATIATE_PLUGIN_REGISTRATION(SignalSignature) \ + template void PluginRegistration::Connect( \ + const typename SignalSignature::Type&) + +EXPLICIT_INSTATIATE_PLUGIN_REGISTRATION(OnWidgetStart); +EXPLICIT_INSTATIATE_PLUGIN_REGISTRATION(OnWidgetStop); +EXPLICIT_INSTATIATE_PLUGIN_REGISTRATION(OnFrameLoad); +EXPLICIT_INSTATIATE_PLUGIN_REGISTRATION(OnFrameUnload); + +} diff --git a/src/plugins-api-support/PluginRegistration.h b/src/plugins-api-support/PluginRegistration.h new file mode 100644 index 0000000..ea7972f --- /dev/null +++ b/src/plugins-api-support/PluginRegistration.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2012 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 PluginRegistration.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_REGISTRATION_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_REGISTRATION_H_ + +#include +#include "Plugin.h" +#include "PluginSignals.h" + +namespace WrtPluginsApi +{ + +class PluginRegistration +{ +public: + class Impl; + + explicit PluginRegistration(PluginRegistration::Impl* impl); + + template + void Connect(const typename SignalSignature::Type& slot); + + void DisconnectAll(); + + void AddPlugin(Plugin& plugin); + +private: + std::unique_ptr m_impl; +}; + +} + +#endif diff --git a/src/plugins-api-support/PluginRegistrationImpl.h b/src/plugins-api-support/PluginRegistrationImpl.h new file mode 100644 index 0000000..3e1c752 --- /dev/null +++ b/src/plugins-api-support/PluginRegistrationImpl.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2012 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 PluginRegistrationImpl.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_REGISTRATION_IMPL_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_REGISTRATION_IMPL_H_ + +#include +#include "SignalsSupport.h" +#include "Plugin.h" +#include + +namespace WrtPluginsApi +{ + +class PluginRegistration::Impl +{ +public: + Impl(SignalsSupport& registry, const std::string& libraryName) + : m_registry(registry), + m_libraryName(libraryName) + {} + + void AddPlugin(Plugin& plugin) + { + m_registry.AddPlugin(m_libraryName, plugin); + } + + template + void Connect(const typename T::Type& slot) + { + m_registry.Connect(m_libraryName, slot); + } + + void DisconnectAll() + { + m_registry.Disconnect(m_libraryName); + } + +private: + SignalsSupport& m_registry; + std::string m_libraryName; +}; + +} + +#endif diff --git a/src/plugins-api-support/PluginRegistry.cpp b/src/plugins-api-support/PluginRegistry.cpp new file mode 100644 index 0000000..761ba9d --- /dev/null +++ b/src/plugins-api-support/PluginRegistry.cpp @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2012 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 PluginRegistry.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ +#include "PluginRegistry.h" +#include "PluginRegistration.h" +#include "PluginRegistrationImpl.h" +#include "ExportedApi.h" + +#include +#include +#include +#include +#include + +#include +#include + + +namespace { +const char* DLL_ENTRY_POINT_NAME = "dll_api"; +} + +namespace WrtPluginsApi +{ + +void PluginRegistry::AddPlugin(const std::string& libraryName, + Plugin& plugin) +{ + LogDebug("Adding plugin for library: " << libraryName); + + auto libraryIt = m_plugins.find(libraryName); + if (m_plugins.end() == libraryIt) + { + m_plugins[libraryName] = &plugin; + } +} + +Plugin* PluginRegistry::GetPlugin(const std::string& libraryName) +{ + auto it = m_plugins.find(libraryName); + if (it == m_plugins.end()) + { + if (!LoadFromFile(libraryName)) + { + LogError("Failed to load lib" << libraryName); + ThrowMsg(PluginNotFound, "Failed to load plugin"); + } + + return m_plugins[libraryName]; + } + + return it->second; +} + +void PluginRegistry::RemovePlugin(const std::string& libraryName, + Plugin& plugin) +{ + auto it = m_plugins.find(libraryName); + if (it != m_plugins.end()) + { + if (&plugin == it->second) + { + m_plugins.erase(it); + } + } +} + +void PluginRegistry::UnloadAll() +{ + LogDebug("Unload all plugins"); + + typedef void (*UnregisterFunction) (PluginRegistration&, Plugin&); + + FOREACH(libraryIt, m_libraries) + { + auto pluginIt = m_plugins.find(libraryIt->first); + if (m_plugins.end() != pluginIt) + { + void* handle = dlopen(libraryIt->first.c_str(), RTLD_NOW); + if (!handle) { + LogError("Error: " << dlerror()); + continue; + } + + ExportedApi* entryPoint = + static_cast + (dlsym(handle, GetExportedSymbolName())); + if (NULL == entryPoint) + { + LogError("Error: " << dlerror()); + continue; + } + if (entryPoint->Unregister == NULL) + { + LogError("Error Unregister function not set"); + continue; + } + + PluginRegistration registration( + new PluginRegistration::Impl(*this, libraryIt->first)); + + entryPoint->Unregister(registration, (pluginIt->second)); + + m_plugins.erase(pluginIt); + } + dlclose(libraryIt->second); + } +} + +bool PluginRegistry::LoadFromFile(const std::string& libraryName) +{ + void* handle = dlopen(libraryName.c_str(), RTLD_NOW); + if (!handle) { + LogError("Error: " << dlerror()); + return false; + } + m_libraries[libraryName] = handle; + + ExportedApi* entryPoint = + static_cast(dlsym(handle, GetExportedSymbolName())); + if (NULL == entryPoint) + { + LogError("Error: " << dlerror()); + return false; + } + + if (entryPoint->Register == NULL) + { + LogError("Error Register function not set"); + return false; + } + if (entryPoint->Unregister== NULL) + { + LogError("Error Unregister function not set"); + return false; + } + + PluginRegistration registration( + new PluginRegistration::Impl(*this, libraryName)); + entryPoint->Register(registration); + + return true; +} + + +PluginRegistry::~PluginRegistry() +{ + //TODO discuss ... when the unload should be called +// UnloadAll(); +} + +} diff --git a/src/plugins-api-support/PluginRegistry.h b/src/plugins-api-support/PluginRegistry.h new file mode 100644 index 0000000..d3e66b4 --- /dev/null +++ b/src/plugins-api-support/PluginRegistry.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2012 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 PluginRegistry.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_LOADING_PLUGIN_REGISTRY_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_LOADING_PLUGIN_REGISTRY_H_ + +#include +#include +#include "SignalsSupport.h" +#include "Plugin.h" +#include + +namespace WrtPluginsApi +{ + +typedef std::list PluginsList; +typedef std::shared_ptr PluginsListPtr; +typedef std::map< std::string, PluginsListPtr> PluginsSet; + +class PluginRegistry : public SignalsSupport +{ +public: + DECLARE_EXCEPTION_TYPE(DPL::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, PluginNotFound) + + template + void Call(Args... args) + { + Invoke(args...); + } + + template + void CallGroup(const typename CallbackSupport::GroupType& type, + Args... args) + { + InvokeGroup(type, args...); + } + + void AddPlugin(const std::string& libraryName, Plugin& plugin); + + /* + * @throw PluginNotFound + * */ + Plugin* GetPlugin(const std::string& libraryName); + + void RemovePlugin(const std::string& libraryName, Plugin& plugin); + + void UnloadAll(); + + ~PluginRegistry(); +private: + bool LoadFromFile(const std::string& libraryName); + + typedef void* Symbol; + + std::map m_plugins; + std::map m_libraries; +}; + +typedef std::shared_ptr PluginRegistryPtr; + +} + +#endif diff --git a/src/plugins-api-support/PluginSignals.h b/src/plugins-api-support/PluginSignals.h new file mode 100644 index 0000000..ab22da1 --- /dev/null +++ b/src/plugins-api-support/PluginSignals.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2012 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 PluginSignals.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_SIGNALS_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_PLUGIN_SIGNALS_H_ + +#include "SignalSignature.h" + +namespace WrtPluginsApi +{ + +struct OnWidgetStart : SignalSignature {}; + +struct OnWidgetStop : SignalSignature {}; + +struct OnFrameLoad: SignalSignature {}; + +struct OnFrameUnload : SignalSignature {}; + +} + +#endif diff --git a/src/plugins-api-support/SignalSignature.h b/src/plugins-api-support/SignalSignature.h new file mode 100644 index 0000000..19fce6c --- /dev/null +++ b/src/plugins-api-support/SignalSignature.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2012 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 SignalSignature.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_SIGNAL_SIGNATURE_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_SIGNAL_SIGNATURE_H_ + +#include + +namespace WrtPluginsApi +{ + +template struct SignalSignature; + +template +struct SignalSignature +{ + typedef R (*Signature) (Args...); + typedef std::function Type; +}; + +} + +#endif diff --git a/src/plugins-api-support/SignalsSupport.h b/src/plugins-api-support/SignalsSupport.h new file mode 100644 index 0000000..56e7e67 --- /dev/null +++ b/src/plugins-api-support/SignalsSupport.h @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2012 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 IPluginRegistry.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_SIGNALS_SUPPORT_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_SIGNALS_SUPPORT_H_ + +#include +#include +#include "CallbackSupport.h" +#include "tuple.h" +#include "PluginSignals.h" +#include "Plugin.h" + +namespace WrtPluginsApi +{ + +class SignalsSupport +{ +public: + virtual ~SignalsSupport() {} + + template + void Connect(const std::string& libraryName, const typename T::Type& slot) + { + Tuple::get_by_type>(m_slots).Connect(libraryName, + slot); + } + + void Disconnect(const std::string& libraryName) + { + DisconnectGroup(m_slots, libraryName); + } + + virtual void AddPlugin(const std::string& libraryName, Plugin& plugin) = 0; + +protected: + template + void Invoke(const Args&... args) + { + Tuple::get_by_type>(m_slots).Invoke(args...); + } + + template + void InvokeGroup(const std::string& libraryName, const Args&... args) + { + Tuple::get_by_type>(m_slots).InvokeGroup(libraryName, + args...); + } + +private: + template + void DisconnectSlot(std::tuple& slots, + const std::string& libraryName, + typename std::enable_if<(N >= 0)>::type* = NULL) + { + std::get(slots).Disconnect(libraryName); + DisconnectSlot(slots, libraryName); + } + + template + void DisconnectSlot(std::tuple& slots, + const std::string& libraryName, + typename std::enable_if<(N == -1)>::type* = NULL) + { + } + + template + void DisconnectGroup(std::tuple& slots, + const std::string& libraryName) + { + DisconnectSlot(slots, libraryName); + } + + std::tuple, + CallbackSupport, + CallbackSupport, + CallbackSupport> m_slots; +}; + +} + +#endif diff --git a/src/plugins-api-support/SoFeatures.h b/src/plugins-api-support/SoFeatures.h new file mode 100644 index 0000000..54b1bd7 --- /dev/null +++ b/src/plugins-api-support/SoFeatures.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2012 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 + * @author + * @version + * @brief TODO This header must be removed because it does not fit to current + * solution, its just a temporary approach. + */ +#ifndef _WRT_PLUGINS_COMMON_FEATURE_API_SO_FEATURES_H_ +#define _WRT_PLUGINS_COMMON_FEATURE_API_SO_FEATURES_H_ + +#define PLUGIN_WIDGET_INIT_PROC_NAME "on_widget_init" +//#define PLUGIN_WIDGET_INIT_PROC_NAME \ +// "_Z23on_widget_init_callbackP27feature_mapping_interface_s" + +//TODO remove +/* + * list of device caps + */ +typedef struct devcaps_s +{ + char** deviceCaps; + size_t devCapsCount; +} devcaps_t; + +/* + * mapping from a feature to corresponding list of device capabilities + */ +typedef struct feature_devcaps_s +{ + char* feature_name; + devcaps_t devCaps; +} feature_devcaps_t; + +/* + * list of feature_devcaps_t structs + */ +typedef struct feature_mapping_s +{ + feature_devcaps_t* features; + size_t featuresCount; +} feature_mapping_t; + + +typedef feature_mapping_t* pfeature_mapping_t; + +typedef pfeature_mapping_t (*features_getter)(void); + +typedef const devcaps_t* (*devcaps_getter)(pfeature_mapping_t /*features*/, + const char* /*featureName*/); +typedef void (*deinitializer)(pfeature_mapping_t /*features*/); + +typedef struct feature_mapping_interface_s +{ + features_getter featGetter; /* returns a list of api features */ + devcaps_getter dcGetter; /* + * for a given api feature returns a list of + * corresponding device capabilities + */ + + deinitializer release; /* as memory ownership of features is + * transfered to callee you have to call + * the release function ptr on features + */ +} feature_mapping_interface_t; + +typedef void (*on_widget_init_proc)(feature_mapping_interface_t *interface); + +#endif diff --git a/src/plugins-api-support/detail/traits.h b/src/plugins-api-support/detail/traits.h new file mode 100644 index 0000000..912e286 --- /dev/null +++ b/src/plugins-api-support/detail/traits.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2012 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 traits.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_DETAIL_TRAITS_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_DETAIL_TRAITS_H_ + +namespace WrtPluginsApi { +namespace Traits { +namespace Detail { + +template +struct index_of_; + +/* + * CurrentArgType is not equal to RequiredType, check next tuple's argument + */ +template +struct index_of_ +{ + static const size_t value = index_of_::value; +}; + +/* + * RequiredType found on tuple's args list + * return position on tuple's list + */ +template +struct index_of_ +{ + static const size_t value = n; +}; + +/* + * RequiredType found on last position of tuple's args list + * return position on tuple's list + */ +template +struct index_of_ +{ + static const size_t value = n; +}; + +/* + * RequiredType was not found on tuple args list + */ +template +struct index_of_ +{ + static const size_t value = -1; +}; + +} +} +} + +#endif diff --git a/src/plugins-api-support/js_types.h b/src/plugins-api-support/js_types.h new file mode 100644 index 0000000..69181ee --- /dev/null +++ b/src/plugins-api-support/js_types.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2012 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 js_types.h + * @author Grzegorz Krawczyk (g.krawczyk@samsung.com) + * @version 1.0 + */ + +#ifndef WRT_PLUGIN_COMMON_API_SUPPORT_JS_TYPES_H_ +#define WRT_PLUGIN_COMMON_API_SUPPORT_JS_TYPES_H_ + +#include + +//forward declaration +extern "C" { + typedef struct OpaqueJSContext* JSGlobalContextRef; + typedef struct OpaqueJSValue* JSObjectRef; +} + +namespace WrtPluginsApi +{ + +struct JavaScriptObject +{ + JSObjectRef instance; + std::string name; +}; + +} + +#endif diff --git a/src/plugins-api-support/traits.h b/src/plugins-api-support/traits.h new file mode 100644 index 0000000..7635a0a --- /dev/null +++ b/src/plugins-api-support/traits.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2012 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 traits.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_TRAITS_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_TRAITS_H_ + +#include "detail/traits.h" + +namespace WrtPluginsApi +{ + +namespace Traits { + +/** + * Gets index of specified type in the type list. + */ +template +struct index_of +{ + static const size_t value = Detail::index_of_<0, + RequiredType, + TupleArgTypes...>::value; +}; + +} + +} + +#endif diff --git a/src/plugins-api-support/tuple.h b/src/plugins-api-support/tuple.h new file mode 100644 index 0000000..ef3b62c --- /dev/null +++ b/src/plugins-api-support/tuple.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2012 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 tuple.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + */ + +#ifndef _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_TUPLE_H_ +#define _WRT_PLUGINS_COMMON_PLUGIN_API_SUPPORT_TUPLE_H_ + +#include +#include "traits.h" + +namespace WrtPluginsApi { +namespace Tuple { + +template +T& get_by_type(std::tuple& tuple) +{ + return std::get::value>(tuple); +} + +} +} + +#endif diff --git a/src/plugins-installer/CMakeLists.txt b/src/plugins-installer/CMakeLists.txt new file mode 100755 index 0000000..70351cd --- /dev/null +++ b/src/plugins-installer/CMakeLists.txt @@ -0,0 +1,88 @@ +# 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 CMakeLists.txt +# @author Lukasz Wrzosek (l.wrzosek@samsung.com) +# @version 1.0 +# + +SET(TARGET_INSTALLER "wrt-plugins-installer") +SET(TARGET_INSTALLER_STATIC "wrt-installer_static") + +SET(INSTALLER_SRC_DIR + ${PROJECT_SOURCE_DIR}/src/plugins-installer + ) + +SET(INSTALLER_JOBS + ${INSTALLER_SRC_DIR}/jobs + ) + +SET(INSTALLER_INCLUDES + ${INSTALLER_SRC_DIR} + ${INSTALLER_SRC_DIR}/logic + ${INSTALLER_SRC_DIR}/jobs + ${INSTALLER_SRC_DIR}/jobs/plugin_install + # ${INSTALLER_SRC_DIR}/jobs/widget_install + #${INSTALLER_SRC_DIR}/jobs/widget_uninstall + ${INSTALLER_SRC_DIR}/misc + ${INSTALLER_SRC_DIR}/configuration_parser + ${INSTALLER_SRC_DIR}/wrt-installer + ${INSTALLER_SRC_DIR}/commons + # ${INSTALLER_SRC_DIR}/pkg-manager +) + +SET(INSTALLER_SOURCES + ${INSTALLER_JOBS}/job.cpp + ${INSTALLER_JOBS}/plugin_install/job_plugin_install.cpp + ${INSTALLER_JOBS}/plugin_install/plugin_install_task.cpp + ${INSTALLER_JOBS}/plugin_install/plugin_objects.cpp + ${INSTALLER_JOBS}/plugin_install/plugin_metafile_reader.cpp + ${INSTALLER_SRC_DIR}/logic/installer_logic.cpp + ${INSTALLER_SRC_DIR}/logic/installer_controller.cpp + ${INSTALLER_SRC_DIR}/misc/libxml_utils.cpp + ) + +PKG_CHECK_MODULES(INSTALLER_STATIC_DEP + libxml-2.0 + cert-svc-vcore + dpl-event-efl + dpl-wrt-dao-rw + libpcrecpp + REQUIRED + ) + +INCLUDE_DIRECTORIES( + ${INSTALLER_DEP_INCLUDES} + ${INSTALLER_INCLUDES} + ${INSTALLER_STATIC_DEP_INCLUDE_DIRS} + ${PLUGINS_API_SUPPORT_DIRS} + ) + +ADD_LIBRARY(${TARGET_INSTALLER_STATIC} STATIC + ${INSTALLER_SOURCES} + ) + +ADD_DEFINITIONS(${INSTALLER_STATIC_DEP_CFLAGS}) +ADD_DEFINITIONS(${INSTALLER_STATIC_DEP_CFLAGS_OTHERS}) + +TARGET_LINK_LIBRARIES(${TARGET_INSTALLER_STATIC} + ${INSTALLER_STATIC_DEP_LIBRARIES} + ${TARGET_PLUGINS_API_SUPPORT} + ) + +SET_TARGET_PROPERTIES(${TARGET_INSTALLER_STATIC} PROPERTIES + COMPILE_FLAGS -fPIC) + +ADD_SUBDIRECTORY(wrt-installer) diff --git a/src/plugins-installer/DESCRIPTION b/src/plugins-installer/DESCRIPTION new file mode 100644 index 0000000..0e8c571 --- /dev/null +++ b/src/plugins-installer/DESCRIPTION @@ -0,0 +1,2 @@ +!!!options!!! stop +Widget (un)installer, plugin (un)installer diff --git a/src/plugins-installer/commons/wrt_common_types.h b/src/plugins-installer/commons/wrt_common_types.h new file mode 100644 index 0000000..9b80c8a --- /dev/null +++ b/src/plugins-installer/commons/wrt_common_types.h @@ -0,0 +1,45 @@ +/* + * 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. + */ +/* + * plugin_common_types.h + * + * Author: Soyoung Kim(sy037.kim@samsung.com) + */ + +#ifndef PLUGIN_COMMON_TYPES_H +#define PLUGIN_COMMON_TYPES_H + +#include +#include + +/** +* Widget version is optional +*/ +typedef DPL::Optional OptionalWidgetVersion; + + +/* Define db type */ +typedef WrtDB::DbWidgetHandle WidgetHandle; +typedef WrtDB::DbWidgetHandleList WidgetHandleList; + +typedef WrtDB::DbWidgetFeature WidgetFeature; +typedef WrtDB::DbWidgetFeatureSet WidgetFeatureSet; + +typedef WrtDB::DbWidgetSize WidgetSize; + +typedef WrtDB::DbPluginHandle PluginHandle; + +#endif /* PLUGIN_COMMON_TYPES_H */ diff --git a/src/plugins-installer/commons/wrt_error.h b/src/plugins-installer/commons/wrt_error.h new file mode 100644 index 0000000..5a1960a --- /dev/null +++ b/src/plugins-installer/commons/wrt_error.h @@ -0,0 +1,140 @@ +/* + * 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. + */ +/** + * This file contains the declaration of the error codes of Widget. + * + * @file wrt_error.h + * @author MaQuan (jason.ma@samsung.com) + * @version 0.7 + * @brief This file contains the declaration of the error codes of Widget. + */ + +#ifndef _WRT_ERROR_H_ +#define _WRT_ERROR_H_ + +#ifndef WRT_ERROR_MASKL8 +#define WRT_ERROR_MASKL8 0xFF +#endif + +#ifndef WRT_SET_IDENT +#define WRT_SET_IDENT(X) (X & WRT_ERROR_MASKL8) +#endif + +#ifndef WRT_ERROR_SET +#define WRT_ERROR_SET(X) ((X & WRT_ERROR_MASKL8) << 8) +#endif + +#define WRT_MID_ERRCODE 0x10000 + WRT_SET_IDENT(5) + +/*typedef */ enum +{ + WRT_GENERAL_ERRCODE = WRT_MID_ERRCODE + WRT_SET_IDENT(0), + WRT_CONFIG_ERRCODE = WRT_MID_ERRCODE + WRT_SET_IDENT(1), + WRT_DOMAIN_ERRCODE = WRT_MID_ERRCODE + WRT_SET_IDENT(2), + WRT_JS_EXT_ERRCODE = WRT_MID_ERRCODE + WRT_SET_IDENT(3), + WRT_WM_ERRCODE = WRT_MID_ERRCODE + WRT_SET_IDENT(4), + WRT_PLUGIN_ERRCODE = WRT_MID_ERRCODE + WRT_SET_IDENT(5), + //_ACE support + WRT_SAI_ERRCODE = WRT_MID_ERRCODE + WRT_SET_IDENT(6) +}; + +/** + * WRT error code description + * + * @ WRT_SUCCESS + * There is no error with WRT operations. + * + * @ WRT_ERR_UNKNOW + * An unknow error happened to WRT. + * + * @ WRT_ERR_INVALID_ARG + * Invalid arguments are passed into WRT functions. + * + * @ WRT_ERR_OUT_MEMORY + * No memory space available for WRT. + * + * @ WRT_ERR_NO_DISK_SPACE + * There is no disk space for widget applications. + * + * + * + * + */ +enum WrtError +{ + /* General errors */ + WRT_SUCCESS = WRT_GENERAL_ERRCODE + WRT_ERROR_SET(0x01), + WRT_ERR_UNKNOWN = WRT_GENERAL_ERRCODE + WRT_ERROR_SET(0x02), + WRT_ERR_INVALID_ARG = WRT_GENERAL_ERRCODE + WRT_ERROR_SET(0x03), + WRT_ERR_OUT_OF_MEMORY = WRT_GENERAL_ERRCODE + WRT_ERROR_SET(0x04), + WRT_ERR_NO_DISK_SPACE = WRT_GENERAL_ERRCODE + WRT_ERROR_SET(0x05), + + /* Configuration */ + WRT_CONF_ERR_GCONF_FAILURE = WRT_CONFIG_ERRCODE + WRT_ERROR_SET(0x01), + WRT_CONF_ERR_OBJ_MISSING = WRT_CONFIG_ERRCODE + WRT_ERROR_SET(0x02), + WRT_CONF_ERR_OBJ_EXIST = WRT_CONFIG_ERRCODE + WRT_ERROR_SET(0x03), + WRT_CONF_ERR_START_FILE_MISSING = WRT_CONFIG_ERRCODE + WRT_ERROR_SET(0x04), + WRT_CONF_ERR_EMDB_FAILURE = WRT_CONFIG_ERRCODE + WRT_ERROR_SET(0x05), + WRT_CONF_ERR_EMDB_NO_RECORD = WRT_CONFIG_ERRCODE + WRT_ERROR_SET(0x06), + + /* Domain */ + WRT_DOMAIN_ERR_CREATE_JS_RT = WRT_DOMAIN_ERRCODE + WRT_ERROR_SET(0x01), + WRT_DOMAIN_ERR_MSG_QUEUE = WRT_DOMAIN_ERRCODE + WRT_ERROR_SET(0x02), + + /* Widget manager*/ + WRT_WM_ERR_NOT_INSTALLED = WRT_WM_ERRCODE + WRT_ERROR_SET(0x01), + WRT_WM_ERR_HIGH_VER_INSTALLED = WRT_WM_ERRCODE + WRT_ERROR_SET(0x02), + WRT_WM_ERR_LOW_VER_INSTALLED = WRT_WM_ERRCODE + WRT_ERROR_SET(0x03), + WRT_WM_ERR_INVALID_ARCHIVE = WRT_WM_ERRCODE + WRT_ERROR_SET(0x04), + WRT_WM_ERR_INVALID_CERTIFICATION = WRT_WM_ERRCODE + WRT_ERROR_SET(0x05), + WRT_WM_ERR_NULL_CERTIFICATION = WRT_WM_ERRCODE + WRT_ERROR_SET(0x06), + WRT_WM_ERR_INSTALLATION_CANCEL = WRT_WM_ERRCODE + WRT_ERROR_SET(0x07), + WRT_WM_ERR_ALREADY_INSTALLED = WRT_WM_ERRCODE + WRT_ERROR_SET(0x08), + WRT_WM_ERR_INSTALL_FAILED = WRT_WM_ERRCODE + WRT_ERROR_SET(0x09), + WRT_WM_ERR_DELETE_BY_SERVER = WRT_WM_ERRCODE + WRT_ERROR_SET(0x0a), + WRT_WM_ERR_DEINSTALLATION_CANCEL = WRT_WM_ERRCODE + WRT_ERROR_SET(0x0b), + WRT_WM_ERR_INCORRECT_UPDATE_INFO = WRT_WM_ERRCODE + WRT_ERROR_SET(0x0c), + WRT_WM_ERR_UNREG_FAILED = WRT_WM_ERRCODE + WRT_ERROR_SET(0x0d), + WRT_WM_ERR_REMOVE_FILES_FAILED = WRT_WM_ERRCODE + WRT_ERROR_SET(0x0e), + WRT_WM_ERR_ALREADY_LATEST = WRT_WM_ERRCODE + WRT_ERROR_SET(0x0f), + WRT_WM_ERR_UPDATE_CANCEL = WRT_WM_ERRCODE + WRT_ERROR_SET(0x10), + WRT_WM_ERR_IS_FACTORY_WIDGET = WRT_WM_ERRCODE + WRT_ERROR_SET(0x11), + WRT_WM_ERR_INVALID_APP_ID = WRT_WM_ERRCODE + WRT_ERROR_SET(0x12), + + /* Access Control Manager */ + WRT_SAI_ERR_INIT_ACE_FAILED = WRT_SAI_ERRCODE + WRT_ERROR_SET(0x01) +}; + +namespace CommonError { +enum Type +{ + WrtSuccess, ///< Success + + HandleNotFound, ///< Widget handle was not found + AlreadyRunning, ///< Widget is already running + AlreadyStopped, ///< Widget is already stopped + InvalidLanguage, ///< Widget is invalid in current locales + StillAuthorizing, ///< Widget is still autorizing and has not yet finished it + EarlyKilled, ///< Widget was early killed during launch + AccessDenied, ///< Access denied from ACE + CertificateRevoked, ///< Some certificate was revoked. + /// Widget is not allowed to run. + + Unknown ///< Temporary error. Try to not use this. +}; +} +#endif /* _WRT_ERROR_H_ */ + diff --git a/src/plugins-installer/configuration_parser/deny_all_parser.h b/src/plugins-installer/configuration_parser/deny_all_parser.h new file mode 100644 index 0000000..2d45707 --- /dev/null +++ b/src/plugins-installer/configuration_parser/deny_all_parser.h @@ -0,0 +1,42 @@ +/* + * 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 deny_all_parser.h + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 0.1 + * @brief + */ +#ifndef DENY_ALL_PARSER_H +#define DENY_ALL_PARSER_H + +#include "element_parser.h" + +struct DenyAllParser : public ElementParser +{ + static ElementParserPtr Create(); + virtual void Accept(const Element& /*element*/); + virtual void Accept(const XmlAttribute& /*attribute*/); + virtual void Accept(const Text& /*text*/); + virtual void Verify() + { + } + virtual ActionFunc GetElementParser(const DPL::String& ns, + const DPL::String& name); + + DenyAllParser(); +}; + +#endif // DENY_ALL_PARSER_H diff --git a/src/plugins-installer/configuration_parser/element_parser.h b/src/plugins-installer/configuration_parser/element_parser.h new file mode 100644 index 0000000..dc843b6 --- /dev/null +++ b/src/plugins-installer/configuration_parser/element_parser.h @@ -0,0 +1,91 @@ +/* + * 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 element_parser.h + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 0.1 + * @brief + */ +#ifndef ELEMENT_PARSER_H_ +#define ELEMENT_PARSER_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct XmlAttribute +{ + DPL::String prefix; + DPL::String name; + DPL::String value; + DPL::String ns; + DPL::String lang; +}; + +struct Element +{ + DPL::String name; + DPL::String value; + DPL::String ns; + DPL::String lang; +}; + +struct Text +{ + DPL::String value; + DPL::String ns; + DPL::String lang; +}; + +class ElementParser; + +typedef DPL::SharedPtr ElementParserPtr; + +class ElementParser : public DPL::EnableSharedFromThis +{ + public: + class Exception + { + public: + DECLARE_EXCEPTION_TYPE(DPL::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, ParseError) + }; + typedef DPL::FastDelegate0 ActionFunc; + typedef std::map FuncMap; + + virtual void Accept(const Element&) = 0; + virtual void Accept(const XmlAttribute&) = 0; + virtual void Accept(const Text&) = 0; + virtual void Verify() = 0; + virtual ActionFunc GetElementParser(const DPL::String &ns, + const DPL::String &name) = 0; + virtual ~ElementParser() + { + } + + protected: + ElementParser() + { + } +}; + +#endif // ELEMENT_PARSER_H_ diff --git a/src/plugins-installer/configuration_parser/ignoring_parser.h b/src/plugins-installer/configuration_parser/ignoring_parser.h new file mode 100644 index 0000000..9f1f6d5 --- /dev/null +++ b/src/plugins-installer/configuration_parser/ignoring_parser.h @@ -0,0 +1,43 @@ +/* + * 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 ignoring_parser.h + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 0.1 + * @brief + */ +#ifndef IGNORING_PARSER_H_ +#define IGNORING_PARSER_H_ + +#include "element_parser.h" + +struct IgnoringParser : public ElementParser +{ + static ElementParserPtr Create(); + virtual ActionFunc GetElementParser(const DPL::String& ns, + const DPL::String& name); + virtual void Accept(const Element&); + virtual void Accept(const Text&); + virtual void Accept(const XmlAttribute&); + virtual void Verify(); + + IgnoringParser(); + + private: + ElementParserPtr Reuse(); +}; + +#endif // IGNORING_PARSER_H_ diff --git a/src/plugins-installer/configuration_parser/libiriwrapper.h b/src/plugins-installer/configuration_parser/libiriwrapper.h new file mode 100644 index 0000000..1029059 --- /dev/null +++ b/src/plugins-installer/configuration_parser/libiriwrapper.h @@ -0,0 +1,46 @@ +/* + * 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 libiriwrapper.cpp + * @author Piotr Marcinkiewicz (p.marcinkiew@samsung.com + * @version 0.1 + * @brief Libiri parser wrapper + */ + +#ifndef _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_LIBIRIWRAPPER_H_ +#define _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_LIBIRIWRAPPER_H_ + +#include +#include + +//TODO: Design and implement new IRI manager class +// +namespace LibIri { +struct Wrapper +{ + Wrapper(const char* aIri); + ~Wrapper(); + iri_t *m_Iri; + //! \brief Returns true if iri is valid + bool Validate(); +}; + +std::ostream & operator<<(std::ostream& a_stream, + const Wrapper& a_wrapper); +} //namespace LibIri + +#endif // _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_LIBIRIWRAPPER_H_ + diff --git a/src/plugins-installer/configuration_parser/parser_runner.h b/src/plugins-installer/configuration_parser/parser_runner.h new file mode 100644 index 0000000..1176165 --- /dev/null +++ b/src/plugins-installer/configuration_parser/parser_runner.h @@ -0,0 +1,47 @@ +/* + * 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 parser_runner.h + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 0.1 + * @brief + */ +#ifndef PARSER_RUNNER_H_ +#define PARSER_RUNNER_H_ + +#include +#include +#include +#include "element_parser.h" + +class ParserRunner : private DPL::Noncopyable +{ + public: + void Parse(const std::string& filename, + ElementParserPtr root); + void Parse(DPL::AbstractInput *input, + ElementParserPtr root); + + ParserRunner(); + ~ParserRunner(); + + private: + class Impl; + Impl* m_impl; +}; + +#endif // PARSER_RUNNER_H_ + diff --git a/src/plugins-installer/configuration_parser/root_parser.h b/src/plugins-installer/configuration_parser/root_parser.h new file mode 100644 index 0000000..3f4a86b --- /dev/null +++ b/src/plugins-installer/configuration_parser/root_parser.h @@ -0,0 +1,88 @@ +/* + * 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 root_parser.h + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 0.1 + * @brief + */ +#ifndef _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_ROOT_PARSER_H_ +#define _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_ROOT_PARSER_H_ + +#include +#include "element_parser.h" + +template +class RootParser : public ElementParser +{ + public: + typedef typename ta_Parser::Data Data; + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& name) + { + if (name == m_tag) { + return DPL::MakeDelegate(this, + &RootParser::OnWidgetElement); + } else { + ThrowMsg(Exception::ParseError, + name << " != " << m_tag); + } + } + + RootParser(Data data, + const DPL::String& tag) : + m_data(data), + m_tag(tag) + { + } + + virtual ~RootParser() + { + } + + virtual void Accept(const Element& /*element*/) + { + LogDebug("element"); + } + + virtual void Accept(const XmlAttribute& /*attribute*/) + { + LogDebug("attribute"); + } + + virtual void Accept(const Text& /*text*/) + { + LogDebug("text"); + } + + virtual void Verify() + { + LogDebug(""); + } + + private: + + ElementParserPtr OnWidgetElement() + { + typedef ta_Parser Parser; + return ElementParserPtr(new Parser(this->m_data)); + } + + Data m_data; + const DPL::String& m_tag; +}; + +#endif // _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_ROOT_PARSER_H_ diff --git a/src/plugins-installer/configuration_parser/widget_parser.h b/src/plugins-installer/configuration_parser/widget_parser.h new file mode 100755 index 0000000..6ea2ffb --- /dev/null +++ b/src/plugins-installer/configuration_parser/widget_parser.h @@ -0,0 +1,111 @@ +/* + * 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. + */ + /** + * This file have been implemented in compliance with W3C WARP SPEC. + * but there are some patent issue between W3C WARP SPEC and APPLE. + * so if you want to use this file, refer to the README file in root directory + */ +/** + * @file widget_parser.h + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 0.1 + * @brief + */ +#ifndef WIDGET_PARSER_H_ +#define WIDGET_PARSER_H_ + +#include "element_parser.h" +#include +#include +#include +#include + +namespace ConfigurationNamespace { +static const DPL::String W3CWidgetNamespaceName = + L"http://www.w3.org/ns/widgets"; +static const DPL::String WacWidgetNamespaceNameForLinkElement = + L"http://wacapps.net/ns/widgets#"; +static const DPL::String WacWidgetNamespaceName = + L"http://wacapps.net/ns/widgets"; +static const DPL::String TizenWebAppNamespaceName = + L"http://tizen.org/ns/widgets"; +} + +namespace PluginsPrefix { +const char * const W3CPluginsPrefix = "http://www.w3.org/"; +const char * const WACPluginsPrefix = "http://wacapps.net/api/"; +const char * const TIZENPluginsPrefix = "http://tizen.org/api/"; +} + +namespace Unicode { +enum Direction +{ + LRE, + RLE, + LRO, + RLO, + EMPTY +}; +} + +class WidgetParser : public ElementParser +{ + public: + ElementParserPtr OnNameElement(); + ElementParserPtr OnDescriptionElement(); + ElementParserPtr OnAuthorElement(); + ElementParserPtr OnLicenseElement(); + ElementParserPtr OnIconElement(); + ElementParserPtr OnContentElement(); + ElementParserPtr OnFeatureElement(); + ElementParserPtr OnPreferenceElement(); + ElementParserPtr OnAccessElement(); + ElementParserPtr OnFlashElement(); + ElementParserPtr OnLinkElement(); + ElementParserPtr OnSettingElement(); + ElementParserPtr OnServiceElement(); + ElementParserPtr OnApplicationElement(); + ElementParserPtr OnSplashElement(); + ElementParserPtr OnBackgroundElement(); + + virtual ActionFunc GetElementParser(const DPL::String& ns, + const DPL::String& name); + + virtual void Accept(const Element&); + virtual void Accept(const Text&); + virtual void Accept(const XmlAttribute&); + virtual void Verify(); + + //Typedef used by RootParser + typedef WrtDB::ConfigParserData& Data; + + WidgetParser(Data&); + + private: + Data& m_data; + Unicode::Direction m_textDirection; + FuncMap m_map; + DPL::Optional m_version; + DPL::Optional m_minVersion; + std::list m_windowModes; + DPL::Optional m_defaultlocale; + std::map m_nameSpaces; +}; + +struct IconParser; +struct ContentParser; + +#endif // WIDGET_PARSER_H_ diff --git a/src/plugins-installer/jobs/job.cpp b/src/plugins-installer/jobs/job.cpp new file mode 100644 index 0000000..64903b2 --- /dev/null +++ b/src/plugins-installer/jobs/job.cpp @@ -0,0 +1,105 @@ +/* + * 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. + */ +#include +#include + +namespace Jobs { +Job::Job(InstallationType installType) : + m_installationType(installType), + m_UndoType(false), + m_paused(false) +{ +} + +InstallationType Job::GetInstallationType() const +{ + return m_installationType; +} + +bool Job::GetUndoType() const +{ + return m_UndoType; +} + +void Job::SetUndoType(bool flag) +{ + m_UndoType = flag; +} + +bool Job::IsPaused() const +{ + return m_paused; +} + +void Job::SetPaused(bool paused) +{ + if (paused) { + Pause(); + } else { + Resume(); + } +} + +void Job::Pause() +{ + if (m_paused) { + return; + } + + // Pause + m_paused = true; +} + +void Job::Resume() +{ + if (!m_paused) { + return; + } + + // Continue + m_paused = false; + + // Trigger next steps + CONTROLLER_POST_EVENT(Logic::InstallerController, + InstallerControllerEvents::NextStepEvent(this)); +} + +void Job::SetJobHandle(JobHandle handle) +{ + m_handle = handle; +} + +JobHandle Job::GetJobHandle() const +{ + return m_handle; +} + +void Job::SendProgress() +{ +} + +void Job::SendFinishedSuccess() +{ +} + +void Job::SendFinishedFailure() +{ +} + +void Job::SaveExceptionData(const Jobs::JobExceptionBase&) +{ +} +} //namespace Jobs diff --git a/src/plugins-installer/jobs/job.h b/src/plugins-installer/jobs/job.h new file mode 100644 index 0000000..877a966 --- /dev/null +++ b/src/plugins-installer/jobs/job.h @@ -0,0 +1,67 @@ +/* + * 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. + */ +#ifndef INSTALLER_MODEL_H +#define INSTALLER_MODEL_H + +#include + +namespace Jobs { +class JobExceptionBase; +/** + * @brief Defines installation and uninstallation type. + */ +enum InstallationType +{ + Installation, ///< defines install process + Uninstallation, ///< defines uninstall process + PluginInstallation ///< defines plugin installation process +}; + +typedef int JobHandle; + +class Job : + public DPL::TaskList +{ + public: + Job(InstallationType installType); + + InstallationType GetInstallationType() const; + + // Undo + void SetUndoType(bool flag); + bool GetUndoType() const; + + // Pause/resume support + bool IsPaused() const; + void SetPaused(bool paused); + void Pause(); + void Resume(); + void SetJobHandle(JobHandle handle); + JobHandle GetJobHandle() const; + virtual void SendProgress(); + virtual void SendFinishedSuccess(); + virtual void SendFinishedFailure(); + + virtual void SaveExceptionData(const Jobs::JobExceptionBase&); + private: + JobHandle m_handle; + InstallationType m_installationType; + bool m_UndoType; //TODO change name to m_AbortStarted + bool m_paused; +}; +} //namespace Jobs + +#endif // INSTALLER_MODEL_H diff --git a/src/plugins-installer/jobs/job_base.h b/src/plugins-installer/jobs/job_base.h new file mode 100644 index 0000000..86e1746 --- /dev/null +++ b/src/plugins-installer/jobs/job_base.h @@ -0,0 +1,113 @@ +/* + * 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. + */ +#ifndef SRC_INSTALLER_CORE_JOBS_JOB_BASE_H +#define SRC_INSTALLER_CORE_JOBS_JOB_BASE_H + +#include + +typedef std::string ProgressDescription; +typedef float ProgressPercent; + +namespace Jobs { +template +class JobProgressBase +{ + protected: + bool m_progressFlag; + ProgressDescription m_progresDescription; + ProgressPercent m_progresPercent; + + public: + JobProgressBase() : m_progressFlag(false), + m_progresPercent(0.0) + { + } + + void SetProgressFlag(bool flag) + { + m_progressFlag = flag; + } + bool GetProgressFlag() const + { + return m_progressFlag; + } + + ProgressDescription GetProgressDescription() const + { + return m_progresDescription; + } + + ProgressPercent GetProgressPercent() const + { + return m_progresPercent; + } + + void UpdateProgress(T_InstallationStep step, + ProgressDescription const &description) + { + m_progresPercent = + ((static_cast(step) + 1.0) / + static_cast(lastElement)) * 100; + m_progresDescription = description; + } +}; + +template +class JobContextBase +{ + public: + JobContextBase(const T_JobStruct& jobStruct) : + m_jobStruct(jobStruct) + { + } + + T_JobStruct getInstallerStruct() const + { + return m_jobStruct; + } //TODO RENAME + + protected: + T_JobStruct m_jobStruct; +}; + +template +struct JobCallbacksBase +{ + T_finishedCb finishedCallback; + T_progressCb progressCallback; + void *userParam; + + // It must be empty-constructible as a parameter of generic event + JobCallbacksBase() : + finishedCallback(0), + progressCallback(0), + userParam(0) + { + } + + JobCallbacksBase(T_finishedCb finished, + T_progressCb progress, + void *param) : + finishedCallback(finished), + progressCallback(progress), + userParam(param) + { + } +}; +} //namespace Jobs + +#endif // SRC_INSTALLER_CORE_JOBS_JOB_BASE_H diff --git a/src/plugins-installer/jobs/job_exception_base.h b/src/plugins-installer/jobs/job_exception_base.h new file mode 100644 index 0000000..3f12a2d --- /dev/null +++ b/src/plugins-installer/jobs/job_exception_base.h @@ -0,0 +1,100 @@ +/* + * 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 job_exception_base.h + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @version + * @brief + */ + +#include + +#ifndef SRC_INSTALLER_CORE_JOBS_JOB_EXCEPTION_BASE_H_ +#define SRC_INSTALLER_CORE_JOBS_JOB_EXCEPTION_BASE_H_ + +#define DECLARE_JOB_EXCEPTION_BASE(Base, Class, Param) \ + class Class : \ + public Base { \ + public: \ + Class(const char *path, \ + const char *function, \ + int line, \ + const std::string & message = std::string()) : \ + Base(path, function, line, message) \ + { \ + m_className = # Class; \ + m_param = Param; \ + } \ + \ + Class(const char *path, \ + const char *function, \ + int line, \ + const Exception &reason, \ + const std::string & message = std::string()) : \ + Base(path, function, line, reason, message) \ + { \ + m_className = # Class; \ + m_param = Param; \ + } \ + \ + virtual int getParam() const \ + { \ + return m_param; \ + } \ + protected: \ + int m_param; \ + }; +//TODO template for m_param + +#define DECLARE_JOB_EXCEPTION(Base, Class, Param) \ + class Class : \ + public Base { \ + public: \ + Class(const char *path, \ + const char *function, \ + int line, \ + const std::string & message = std::string()) : \ + Base(path, function, line, message) \ + { \ + m_className = # Class; \ + m_param = Param; \ + } \ + \ + Class(const char *path, \ + const char *function, \ + int line, \ + const Exception &reason, \ + const std::string & message = std::string()) : \ + Base(path, function, line, reason, message) \ + { \ + m_className = # Class; \ + m_param = Param; \ + } \ + \ + virtual int getParam() const \ + { \ + return m_param; \ + } \ + }; +//TODO template for m_param + +//TODO maybe use DPL:: DECLARE_EXCEPTION_TYPE instead of creating own + +namespace Jobs { +DECLARE_JOB_EXCEPTION_BASE(DPL::Exception, JobExceptionBase, 0) +} + +#endif /* SRC_INSTALLER_CORE_JOBS_JOB_EXCEPTION_BASE_H_ */ diff --git a/src/plugins-installer/jobs/plugin_install/job_plugin_install.cpp b/src/plugins-installer/jobs/plugin_install/job_plugin_install.cpp new file mode 100644 index 0000000..8bf52ff --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/job_plugin_install.cpp @@ -0,0 +1,95 @@ +/* + * 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 job_plugin_install.cpp + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @version + * @brief + */ +#include +#include +#include //TODO remove + +//#include +#include "plugin_objects.h" + +namespace Jobs { +namespace PluginInstall { +JobPluginInstall::JobPluginInstall(std::string const &pluginPath, + const PluginInstallerStruct &installerStruct) : + Job(PluginInstallation), + JobContextBase(installerStruct) +{ + // + // Init installer context + // + m_context.pluginFilePath = pluginPath; + m_context.pluginHandle = INVALID_HANDLE; + m_context.installationCompleted = false; + + m_context.installerTask = this; + // + // Create main installation tasks + // + AddTask(new PluginInstallTask(&m_context)); +} + +void JobPluginInstall::SendProgress() +{ + if (GetProgressFlag() && getInstallerStruct().progressCallback != NULL) { + LogDebug("Call Plugin install progressCallback"); + getInstallerStruct().progressCallback(getInstallerStruct().userParam, + GetProgressPercent(), GetProgressDescription()); + } +} + +void JobPluginInstall::SendFinishedSuccess() +{ + PluginHandle handle = getNewPluginHandle(); + + if (handle != Jobs::PluginInstall::JobPluginInstall::INVALID_HANDLE && + isReadyToInstall()) + { + LogDebug("Call Plugin install success finishedCallback"); + getInstallerStruct().finishedCallback(getInstallerStruct().userParam, + Exceptions::Success); + } else { + LogDebug("Call Plugin install waiting finishedCallback"); + getInstallerStruct().finishedCallback(getInstallerStruct().userParam, + Exceptions::InstallationWaiting); + + LogInfo("Installation: " << getFilePath() << + " NOT possible"); + } +} + +void JobPluginInstall::SendFinishedFailure() +{ + LogError("Error in plugin installation step: " << m_exceptionCaught); + LogError("Message: " << m_exceptionMessage); + + LogDebug("Call Plugin install failure finishedCallback"); + getInstallerStruct().finishedCallback(getInstallerStruct().userParam, + m_exceptionCaught); +} + +void JobPluginInstall::SaveExceptionData(const Jobs::JobExceptionBase &e) +{ + m_exceptionCaught = static_cast(e.getParam()); + m_exceptionMessage = e.GetMessage(); +} +} //namespace Jobs +} //namespace PluginInstall diff --git a/src/plugins-installer/jobs/plugin_install/job_plugin_install.h b/src/plugins-installer/jobs/plugin_install/job_plugin_install.h new file mode 100644 index 0000000..a7fde44 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/job_plugin_install.h @@ -0,0 +1,83 @@ +/* + * 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 job_plugin_install.h + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @version + * @brief + */ + +#ifndef WRT_SRC_INSTALLER_CORE_JOB_JOB_PLUGIN_INSTALL_H_ +#define WRT_SRC_INSTALLER_CORE_JOB_JOB_PLUGIN_INSTALL_H_ + +//SYSTEM INCLUDES +#include + +//WRT INCLUDES +#include +#include +#include +#include + +namespace Jobs { +namespace PluginInstall { +class JobPluginInstall : + public Job, + public JobProgressBase, + public JobContextBase +{ + public: + static const WrtDB::DbPluginHandle INVALID_HANDLE = -1; + + public: + /** + * @brief Automaticaly sets installation process + */ + JobPluginInstall(std::string const &pluginPath, + const PluginInstallerStruct &installerStruct); + + WrtDB::DbPluginHandle getNewPluginHandle() const + { + return m_context.pluginHandle; + } + std::string getFilePath() const + { + return m_context.pluginFilePath; + } + bool isReadyToInstall() const + { + return m_context.installationCompleted; + } + + void SendProgress(); + void SendFinishedSuccess(); + void SendFinishedFailure(); + void SaveExceptionData(const Jobs::JobExceptionBase &e); + private: + //TODO move somewhere this attribute + //(as it is in all Jobs...) + PluginInstallerContext m_context; + + //TODO move it to base class of all jobs + //maybe separate JobBase class for this? + Exceptions::Type m_exceptionCaught; + std::string m_exceptionMessage; +}; +} //namespace Jobs +} //namespace PluginInstall + +#endif /* WRT_SRC_INSTALLER_CORE_JOB_JOB_PLUGIN_INSTALL_H_ */ diff --git a/src/plugins-installer/jobs/plugin_install/plugin_install_task.cpp b/src/plugins-installer/jobs/plugin_install/plugin_install_task.cpp new file mode 100644 index 0000000..7bf4558 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_install_task.cpp @@ -0,0 +1,444 @@ +/* + * 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 install_one_task.cpp + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ + +//SYSTEM INCLUDES +#include +#include +#include + +//WRT INCLUDES +#include +#include +#include +#include "plugin_install_task.h" +#include "job_plugin_install.h" +#include "plugin_installer_errors.h" +#include "plugin_metafile_reader.h" +#include +#include +#include +#include +#include "plugin_objects.h" + +#include +#include +#include +#include +#include + +using namespace WrtDB; +using namespace WrtPluginsApi; + +namespace { +const std::string DIRECTORY_SEPARATOR = std::string("/"); +} + +#define SET_PLUGIN_INSTALL_PROGRESS(step, desc) \ + m_context->installerTask->UpdateProgress( \ + PluginInstallerContext::step, desc); + +#define DISABLE_IF_PLUGIN_WITHOUT_LIB() \ + if(m_pluginInfo.m_libraryName.empty()) \ + { \ + LogWarning("Plugin without library."); \ + return; \ + } + +namespace Jobs { +namespace PluginInstall { + +PluginInstallTask::PluginInstallTask(PluginInstallerContext *inCont) : + DPL::TaskDecl(this), + m_context(inCont), + m_dataFromConfigXML(true) +{ + AddStep(&PluginInstallTask::stepCheckPluginPath); + AddStep(&PluginInstallTask::stepParseConfigFile); + AddStep(&PluginInstallTask::stepFindPluginLibrary); + AddStep(&PluginInstallTask::stepCheckIfAlreadyInstalled); + AddStep(&PluginInstallTask::stepLoadPluginLibrary); + AddStep(&PluginInstallTask::stepRegisterPlugin); + AddStep(&PluginInstallTask::stepRegisterFeatures); + AddStep(&PluginInstallTask::stepRegisterPluginObjects); + AddStep(&PluginInstallTask::stepResolvePluginDependencies); + + SET_PLUGIN_INSTALL_PROGRESS(START, "Installation initialized"); +} + +PluginInstallTask::~PluginInstallTask() +{ +} + +void PluginInstallTask::stepCheckPluginPath() +{ + LogInfo("Plugin installation: step CheckPluginPath"); + + struct stat tmp; + + if (-1 == stat(m_context->pluginFilePath.c_str(), &tmp)) { + ThrowMsg(Exceptions::PluginPathFailed, + "Stat function failed"); + } + + if (!S_ISDIR(tmp.st_mode)) { + ThrowMsg(Exceptions::PluginPathFailed, + "Invalid Directory"); + } + + SET_PLUGIN_INSTALL_PROGRESS(PLUGIN_PATH, "Path to plugin verified"); +} + +void PluginInstallTask::stepParseConfigFile() +{ + LogInfo("Plugin installation: step parse config file"); + + struct stat tmp; + + std::string filename = m_context->pluginFilePath + DIRECTORY_SEPARATOR + + std::string(GlobalConfig::GetPluginMetafileName()); + + if (-1 == stat(filename.c_str(), &tmp)) { + m_dataFromConfigXML = false; + return; + } + + LogInfo("Plugin Config file::" << filename); + + Try + { + PluginMetafileReader reader; + reader.initialize(filename); + reader.read(m_pluginInfo); + + FOREACH(it, m_pluginInfo.m_featureContainer) + { + LogDebug("Parsed feature : " << it->m_name); + FOREACH (devCap, it->m_deviceCapabilities) { + LogDebug(" | DevCap : " << *devCap); + } + } + + SET_PLUGIN_INSTALL_PROGRESS(PLUGIN_PATH, "Config file analyzed"); + } + Catch(ValidationCore::ParserSchemaException::Base) + { + LogError("Error during file processing " << filename); + ThrowMsg(Exceptions::PluginMetafileFailed, + "Metafile error"); + } +} + +void PluginInstallTask::stepFindPluginLibrary() +{ + if (m_dataFromConfigXML) + { + return; + } + LogDebug("Plugin installation: step find plugin library"); + std::string pluginPath = m_context->pluginFilePath; + size_t indexpos = pluginPath.find_last_of('/'); + + if (std::string::npos == indexpos) + { + indexpos = 0; + } + else + { + indexpos += 1; // move after '/' + } + + std::string libName = pluginPath.substr(indexpos); + libName = GlobalConfig::GetPluginPrefix() + libName + GlobalConfig::GetPluginSuffix(); + LogDebug("Plugin .so: " << libName); + m_pluginInfo.m_libraryName = libName; +} + +void PluginInstallTask::stepCheckIfAlreadyInstalled() +{ + if (PluginDAO::isPluginInstalled(m_pluginInfo.m_libraryName)) { + ThrowMsg(Exceptions::PluginAlreadyInstalled, + "Plugin already installed"); + } + + SET_PLUGIN_INSTALL_PROGRESS(PLUGIN_EXISTS_CHECK, "Check if plugin exist"); +} + +void PluginInstallTask::stepLoadPluginLibrary() +{ + LogInfo("Plugin installation: step load library"); + + DISABLE_IF_PLUGIN_WITHOUT_LIB() + + std::string filename = m_context->pluginFilePath + DIRECTORY_SEPARATOR + + m_pluginInfo.m_libraryName; + + LogDebug("Loading plugin: " << filename); + + void *dlHandle = dlopen(filename.c_str(), RTLD_NOW); + if (dlHandle == NULL ) { + LogError( + "Failed to load plugin: " << filename << + ". Reason: " << dlerror()); + ThrowMsg(Exceptions::PluginLibraryError, "Library error"); + } + + //TODO move it out + PluginRegistry registry; + + Plugin* plugin; + + Try{ + plugin = registry.GetPlugin(filename); + } + Catch(DPL::Exception) + { + LogError("Loading library failed " << filename); + ThrowMsg(Exceptions::PluginLibraryError, "Library error"); + } + + if(!plugin) + { + LogError("Failed to open library" << filename); + ThrowMsg(Exceptions::PluginLibraryError, "Library error"); + } + + m_libraryObjects = PluginObjectsPtr(new PluginObjects()); + + LogInfo("#####"); + LogInfo("##### Plugin: " << filename << " supports new plugin API"); + LogInfo("#####"); + + FOREACH(o, *plugin->GetObjects()) + { + m_libraryObjects->addObjects(CAST(*o)->GetParentName(), + CAST(*o)->GetName()); + + LogDebug("[Parent << Object] " << CAST(*o)->GetParentName() + << " << " + << CAST(*o)->GetName()); + + registerObjects(plugin->GetObjects()); + } + + + if (!m_dataFromConfigXML) + { + ExportedApi* entryPoint = + static_cast(dlsym(dlHandle, GetExportedSymbolName())); + if (NULL == entryPoint) + { + LogError("Error: " << dlerror()); + ThrowMsg(Exceptions::PluginLibraryError, "Library error"); + } + + // obtain feature -> dev-cap mapping + feature_mapping_interface_t mappingInterface = { NULL, NULL, NULL }; + entryPoint->GetProvidedFeatures(&mappingInterface); + + if (!mappingInterface.featGetter || !mappingInterface.release || + !mappingInterface.dcGetter) + { + LogError("Failed to obtain mapping interface from .so"); + ThrowMsg(Exceptions::PluginLibraryError, "Library error"); + } + + feature_mapping_t* devcapMapping = mappingInterface.featGetter(); + + LogDebug("Getting mapping from features to device capabilities"); + + for (size_t i = 0; i < devcapMapping->featuresCount; ++i) + { + PluginMetafileData::Feature feature; + feature.m_name = devcapMapping->features[i].feature_name; + + LogDebug("Feature: " << feature.m_name); + + const devcaps_t* dc = + mappingInterface.dcGetter(devcapMapping, + devcapMapping->features[i].feature_name); + + LogDebug("device=cap: " << dc); + + if (dc) + { + LogDebug("devcaps count: " << dc->devCapsCount); + + for (size_t j = 0; j < dc->devCapsCount; ++j) + { + LogDebug("devcap: " << dc->deviceCaps[j]); + feature.m_deviceCapabilities.insert(dc->deviceCaps[j]); + } + } + + m_pluginInfo.m_featureContainer.insert(feature); + } + + mappingInterface.release(devcapMapping); + } + + // Unload library + if (dlclose(dlHandle) != 0) { + LogError("Cannot close plugin handle"); + } else { + LogDebug("Library is unloaded"); + } + + // Load export table + LogDebug("Library successfuly loaded and parsed"); + + SET_PLUGIN_INSTALL_PROGRESS(LOADING_LIBRARY, "Library loaded and analyzed"); +} + +void PluginInstallTask::stepRegisterPlugin() +{ + LogInfo("Plugin installation: step register Plugin"); + + m_pluginHandle = + PluginDAO::registerPlugin(m_pluginInfo, m_context->pluginFilePath); + + SET_PLUGIN_INSTALL_PROGRESS(REGISTER_PLUGIN, "Plugin registered"); +} + +void PluginInstallTask::stepRegisterFeatures() +{ + LogInfo("Plugin installation: step register features"); + + FOREACH(it, m_pluginInfo.m_featureContainer) + { + LogError("PluginHandle: " << m_pluginHandle); + FeatureDAO::RegisterFeature(*it, m_pluginHandle); + } + SET_PLUGIN_INSTALL_PROGRESS(REGISTER_FEATURES, "Features registered"); +} + +void PluginInstallTask::stepRegisterPluginObjects() +{ + LogInfo("Plugin installation: step register objects"); + + DISABLE_IF_PLUGIN_WITHOUT_LIB() + + //register implemented objects + PluginObjects::ObjectsPtr objects = + m_libraryObjects->getImplementedObject(); + + FOREACH(it, *objects) + { + PluginDAO::registerPluginImplementedObject(*it, m_pluginHandle); + } + + //register requiredObjects + objects = m_libraryObjects->getDependentObjects(); + + FOREACH(it, *objects) + { + if (m_libraryObjects->hasObject(*it)) { + LogDebug("Dependency from the same library. ignored"); + continue; + } + + PluginDAO::registerPluginRequiredObject(*it, m_pluginHandle); + } + + SET_PLUGIN_INSTALL_PROGRESS(REGISTER_OBJECTS, "Plugin Objects registered"); +} + +void PluginInstallTask::stepResolvePluginDependencies() +{ + LogInfo("Plugin installation: step resolve dependencies "); + + //DISABLE_IF_PLUGIN_WITHOUT_LIB + if(m_pluginInfo.m_libraryName.empty()) + { + PluginDAO::setPluginInstallationStatus(m_pluginHandle, + PluginDAO::INSTALLATION_COMPLETED); + //Installation completed + m_context->pluginHandle = m_pluginHandle; + m_context->installationCompleted = true; + LogWarning("Plugin without library."); + return; + } + + PluginHandleSetPtr handles = PluginHandleSetPtr(new PluginHandleSet); + + DbPluginHandle handle = INVALID_PLUGIN_HANDLE; + + //register requiredObjects + FOREACH(it, *(m_libraryObjects->getDependentObjects())) + { + if (m_libraryObjects->hasObject(*it)) { + LogDebug("Dependency from the same library. ignored"); + continue; + } + + handle = PluginDAO::getPluginHandleForImplementedObject(*it); + if (handle == INVALID_PLUGIN_HANDLE) { + LogError("Library implementing: " << *it << " NOT FOUND"); + PluginDAO::setPluginInstallationStatus( + m_pluginHandle, + PluginDAO::INSTALLATION_WAITING); + return; + } + + handles->insert(handle); + } + + PluginDAO::registerPluginLibrariesDependencies(m_pluginHandle, handles); + + PluginDAO::setPluginInstallationStatus(m_pluginHandle, + PluginDAO::INSTALLATION_COMPLETED); + + //Installation completed + m_context->pluginHandle = m_pluginHandle; + m_context->installationCompleted = true; + + SET_PLUGIN_INSTALL_PROGRESS(RESOLVE_DEPENDENCIES, "Dependencies resolved"); +} + +void PluginInstallTask::registerObjects(const IObjectsListPtr& objects) +{ + LogDebug("registerObjects invoked"); + + FOREACH(o, *objects) + { + auto children = CAST(*o)->GetChildren(); + + if(children) + { + FOREACH(c, *children) + { + m_libraryObjects->addObjects(CAST(*o)->GetName(), + CAST(*c)->GetName()); + + LogDebug("[Parent << Object] " << CAST(*c)->GetName() + << " << " + << CAST(*o)->GetName()); + } + + registerObjects(children); + } + } +} + +#undef SET_PLUGIN_INSTALL_PROGRESS +} //namespace Jobs +} //namespace PluginInstall diff --git a/src/plugins-installer/jobs/plugin_install/plugin_install_task.h b/src/plugins-installer/jobs/plugin_install/plugin_install_task.h new file mode 100644 index 0000000..47c6e22 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_install_task.h @@ -0,0 +1,72 @@ +/* + * 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 install.h + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ + +#ifndef INSTALL_H_ +#define INSTALL_H_ + +//WRT INCLUDES +#include +#include "plugin_installer_context.h" +#include "plugin_objects.h" +#include + +namespace Jobs { +namespace PluginInstall { +class PluginInstallTask : + public DPL::TaskDecl +{ + public: + PluginInstallTask(PluginInstallerContext *inCont); + virtual ~PluginInstallTask(); + + private: + //data + PluginInstallerContext *m_context; + + //PluginMetafile + WrtDB::PluginMetafileData m_pluginInfo; + + //Plugin LibraryObjects + PluginObjectsPtr m_libraryObjects; + + WrtDB::DbPluginHandle m_pluginHandle; + + bool m_dataFromConfigXML; + + //steps + void stepCheckPluginPath(); + void stepFindPluginLibrary(); + void stepParseConfigFile(); + void stepCheckIfAlreadyInstalled(); + void stepLoadPluginLibrary(); + void stepRegisterPlugin(); + void stepRegisterFeatures(); + void stepRegisterPluginObjects(); + void stepResolvePluginDependencies(); + + void registerObjects(const WrtPluginsApi::IObjectsListPtr& objects); +}; +} //namespace Jobs +} //namespace PluginInstall + +#endif /* INSTALL_H_ */ diff --git a/src/plugins-installer/jobs/plugin_install/plugin_installer_context.h b/src/plugins-installer/jobs/plugin_install/plugin_installer_context.h new file mode 100644 index 0000000..026074a --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_installer_context.h @@ -0,0 +1,63 @@ +/* + * 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 plugin_installer_structs.h + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @version + * @brief Definition file of plugin installer tasks data structures + */ +#ifndef WRT_SRC_INSTALLERCORE_PLUGININSTALLERTASKS_PLUGININSTALLERCONTEXT_H_ +#define WRT_SRC_INSTALLERCORE_PLUGININSTALLERTASKS_PLUGININSTALLERCONTEXT_H_ + +#include +#include +//#include + +using namespace WrtDB; + +namespace Jobs { +namespace PluginInstall { +class JobPluginInstall; +} +} + +struct PluginInstallerContext +{ + enum PluginInstallStep + { + START, + PLUGIN_PATH, + CONFIG_FILE, + PLUGIN_EXISTS_CHECK, + LOADING_LIBRARY, + REGISTER_PLUGIN, + REGISTER_FEATURES, + REGISTER_OBJECTS, + RESOLVE_DEPENDENCIES, + PLUGIN_INSTALL_END + }; + + std::string pluginFilePath; ///< plugin directory + WrtDB::DbPluginHandle pluginHandle; + // if this value is true the plugin model may be created + // if not plugin installation has failed from some reason + bool installationCompleted; + + //used to set installation progress + Jobs::PluginInstall::JobPluginInstall* installerTask; +}; + +#endif // WRT_SRC_INSTALLERCORE_PLUGININSTALLERTASKS_PLUGININSTALLERCONTEXT_H_ diff --git a/src/plugins-installer/jobs/plugin_install/plugin_installer_errors.h b/src/plugins-installer/jobs/plugin_install/plugin_installer_errors.h new file mode 100644 index 0000000..35f0353 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_installer_errors.h @@ -0,0 +1,59 @@ +/* + * 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 plugin_installer_errors.h + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ + +#ifndef \ + WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_TASKS_PLUGIN_INSTALLER_ERRORS_H_ +#define \ + WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_TASKS_PLUGIN_INSTALLER_ERRORS_H_ + +#include + +namespace Jobs { +namespace PluginInstall { +namespace Exceptions { +enum Type +{ + Success, ///< Success + + WrongPluginPath, ///< ? + MetafileError, ///< ? + AlreadyInstalled, ///< ? + LoadingLibraryError, ///< Loading library by dlopen failed. + /// It may be caused by missing symbols + InstallationWaiting, /// Installation failed due to dependencies + Unknown ///< Temporary error. Try to not use this. +}; + +DECLARE_JOB_EXCEPTION_BASE(JobExceptionBase, Base, Unknown) +DECLARE_JOB_EXCEPTION(Base, PluginPathFailed, WrongPluginPath) +DECLARE_JOB_EXCEPTION(Base, PluginMetafileFailed, MetafileError) +DECLARE_JOB_EXCEPTION(Base, PluginAlreadyInstalled, AlreadyInstalled) +DECLARE_JOB_EXCEPTION(Base, PluginLibraryError, LoadingLibraryError) +DECLARE_JOB_EXCEPTION(Base, InstallationWaitingError, InstallationWaiting) +DECLARE_JOB_EXCEPTION(Base, UnknownError, Unknown) +} //namespace +} //namespace +} //namespace + +#endif /* WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_TASKS_PLUGIN_INSTALLER_ERRORS_H_ */ + diff --git a/src/plugins-installer/jobs/plugin_install/plugin_installer_struct.h b/src/plugins-installer/jobs/plugin_install/plugin_installer_struct.h new file mode 100644 index 0000000..ef69d6f --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_installer_struct.h @@ -0,0 +1,45 @@ +/* + * 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 plugin_installer_struct.h + * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com) + * @author Grzegorz Krawczyk (g.krawczyk@samsung.com) + * @version 1.0 + * @brief Implementation file for widget installer struct + */ +#ifndef WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_PLUGIN_INSTALLER_STRUCT_H_ +#define WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_PLUGIN_INSTALLER_STRUCT_H_ + +#include +#include + +//Plugin Installer typedefs +typedef void (*PluginInstallerFinishedCallback)( + void *userParam, + Jobs::PluginInstall::Exceptions::Type); + +//installer progress +typedef void (*PluginInstallerProgressCallback)( + void *userParam, + ProgressPercent percent, + const ProgressDescription &description); + +//Plugin Installetion Struct +typedef Jobs::JobCallbacksBase +PluginInstallerStruct; + +#endif // WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_PLUGIN_INSTALLER_STRUCT_H_ diff --git a/src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.cpp b/src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.cpp new file mode 100644 index 0000000..ac500e8 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.cpp @@ -0,0 +1,83 @@ +/* + * 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 plugin_metafile_reader.cpp + * @author Grzegorz Krawczyk(g.krawczyk@samsung.com) + * @version 1.0 + * @brief + */ + +#include "plugin_metafile_reader.h" + +using namespace WrtDB; + +namespace { +const std::string XML_NAMESPACE = ""; + +const std::string TOKEN_LIBRARY_NAME = "library-name"; +const std::string TOKEN_API_FEATURE = "api-feature"; +const std::string TOKEN_NAME = "name"; +const std::string TOKEN_DEVICECAPABILITY = "device-capability"; +} + +PluginMetafileReader::PluginMetafileReader() : m_parserSchema(this) +{ + m_parserSchema.addEndTagCallback( + TOKEN_LIBRARY_NAME, + XML_NAMESPACE, + &PluginMetafileReader::tokenEndLibraryName); + + m_parserSchema.addEndTagCallback( + TOKEN_API_FEATURE, + XML_NAMESPACE, + &PluginMetafileReader::tokenEndApiFeature); + + m_parserSchema.addEndTagCallback( + TOKEN_NAME, + XML_NAMESPACE, + &PluginMetafileReader::tokenEndName); + + m_parserSchema.addEndTagCallback( + TOKEN_DEVICECAPABILITY, + XML_NAMESPACE, + &PluginMetafileReader::tokenEndDeviceCapability); +} + +void PluginMetafileReader::blankFunction(PluginMetafileData & /* data */) +{ +} + +void PluginMetafileReader::tokenEndLibraryName(PluginMetafileData &data) +{ + data.m_libraryName = m_parserSchema.getText(); +} + +void PluginMetafileReader::tokenEndApiFeature(PluginMetafileData &data) +{ + data.m_featureContainer.insert(m_feature); + m_feature.m_deviceCapabilities.clear(); +} + +void PluginMetafileReader::tokenEndName(PluginMetafileData & /* data */) +{ + m_feature.m_name = m_parserSchema.getText(); +} + +void PluginMetafileReader::tokenEndDeviceCapability(PluginMetafileData& /*data*/) +{ + m_feature.m_deviceCapabilities.insert(m_parserSchema.getText()); +} + diff --git a/src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.h b/src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.h new file mode 100644 index 0000000..b0c88f0 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_metafile_reader.h @@ -0,0 +1,61 @@ +/* + * 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 plugin_metafile_reader.h + * @author Grzegorz Krawczyk(g.krawczyk@samsung.com) + * @version 1.0 + * @brief + */ + +#ifndef WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_TASKS_PLUGIN_METAFILE_READER_H_ +#define WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_TASKS_PLUGIN_METAFILE_READER_H_ + +#include +#include + +class PluginMetafileReader +{ + public: + PluginMetafileReader(); + + void initialize(const std::string &filename) + { + m_parserSchema.initialize(filename, + true, + ValidationCore::SaxReader::VALIDATION_DTD, + std::string()); + } + + void read(WrtDB::PluginMetafileData &data) + { + m_parserSchema.read(data); + } + + private: + void blankFunction(WrtDB::PluginMetafileData &data); + + void tokenEndLibraryName(WrtDB::PluginMetafileData &data); + void tokenEndApiFeature(WrtDB::PluginMetafileData &data); + void tokenEndName(WrtDB::PluginMetafileData &data); + void tokenEndDeviceCapability(WrtDB::PluginMetafileData &data); + + WrtDB::PluginMetafileData::Feature m_feature; + + ValidationCore::ParserSchema m_parserSchema; +}; + +#endif diff --git a/src/plugins-installer/jobs/plugin_install/plugin_objects.cpp b/src/plugins-installer/jobs/plugin_install/plugin_objects.cpp new file mode 100644 index 0000000..55e6ad3 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_objects.cpp @@ -0,0 +1,109 @@ +/* + * 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 plugin_objects.h + * @author Grzegorz Krawczyk (g.krawczyk@samgsung.com) + * @version + * @brief + */ +#include +#include +#include "plugin_objects.h" +#include + +namespace { +const char* SEPARATOR = "."; +const std::string GLOBAL_OBJECT_NAME = WrtPluginsApi::IObject::WINDOW_OBJECT(); + +std::string normalizeName(const std::string& objectName) +{ + if (objectName.empty()) { + LogError("Normalize name, name size is 0"); + return objectName; + } + + if (!objectName.compare(0, GLOBAL_OBJECT_NAME.size(), + GLOBAL_OBJECT_NAME)) { + return objectName; + } + + //each object in storage has name started from $GLOBAL_OBJECT_NAME$ + return GLOBAL_OBJECT_NAME + std::string(SEPARATOR) + objectName; +} + +std::string normalizeName(const std::string& objectName, + const std::string& parentName) +{ + if (objectName.empty() || parentName.empty()) { + LogError("Normalize name, name size or parent name size is 0"); + return std::string(); + } + + std::string normalizedName; + normalizedName = normalizeName(parentName) + + std::string(SEPARATOR) + objectName; + + return normalizedName; +} +} + +PluginObjects::PluginObjects() +{ + m_implemented = ObjectsPtr(new Objects()); + m_dependent = ObjectsPtr(new Objects()); +} + +PluginObjects::ObjectsPtr PluginObjects::getImplementedObject() const +{ + return m_implemented; +} + +PluginObjects::ObjectsPtr PluginObjects::getDependentObjects() const +{ + return m_dependent; +} + +void PluginObjects::addObjects(const std::string& parentName, + const std::string& name) +{ + LogDebug("\n Parent: " << parentName + << "\n Name: " << name + << "\n After: Implemented: " << normalizeName(name, parentName) + << "\n After Dependent: " << normalizeName(parentName) + ); + + addImplementedObject(normalizeName(name, parentName)); + addDependentObject(normalizeName(parentName)); +} + +void PluginObjects::addDependentObject(const std::string& value) +{ + if (!value.compare(GLOBAL_OBJECT_NAME)) { + //dont add dependency to GLOBAL_OBJECT + return; + } + m_dependent->insert(value); +} + +bool PluginObjects::hasObject(const std::string& name) const +{ + return m_implemented->find(name) != m_implemented->end(); +} + +void PluginObjects::addImplementedObject(const std::string& value) +{ + m_implemented->insert(value); +} diff --git a/src/plugins-installer/jobs/plugin_install/plugin_objects.h b/src/plugins-installer/jobs/plugin_install/plugin_objects.h new file mode 100644 index 0000000..c4cda28 --- /dev/null +++ b/src/plugins-installer/jobs/plugin_install/plugin_objects.h @@ -0,0 +1,58 @@ +/* + * 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 plugin_objects.h + * @author Grzegorz Krawczyk(g.krawczyk@samsung.com) + * @version 1.0 + * @brief + */ + +#ifndef WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_TASKS_PLUGIN_OBJECTS_H_ +#define WRT_SRC_INSTALLER_CORE_PLUGIN_INSTALLER_TASKS_PLUGIN_OBJECTS_H_ + +#include +#include +#include +#include + +#include +//TODO TO BE MOVED SOMEWHERE ELSE +// AS OTHER MODULES (LIKE DAO) USE IT + +class PluginObjects : public WrtDB::PluginObjectsDAO +{ + public: + explicit PluginObjects(); + + //getters for objects from library + ObjectsPtr getImplementedObject() const; + ObjectsPtr getDependentObjects() const; + + //add object declaration + void addObjects(const std::string& parentName, + const std::string& name); + + //check if library implemements object given as name + bool hasObject(const std::string& name) const; + + private: + void addImplementedObject(const std::string& value); + void addDependentObject(const std::string& value); +}; + +typedef DPL::SharedPtr PluginObjectsPtr; + +#endif diff --git a/src/plugins-installer/jobs/widget_install/widget_install_errors.h b/src/plugins-installer/jobs/widget_install/widget_install_errors.h new file mode 100644 index 0000000..b91962a --- /dev/null +++ b/src/plugins-installer/jobs/widget_install/widget_install_errors.h @@ -0,0 +1,98 @@ +/* + * 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 installer_errors.h + * @author Pawel Sikorski (p.sikorski@samgsung.com) + * @version + * @brief + */ + +#ifndef INSTALLER_ERRORS_H_ +#define INSTALLER_ERRORS_H_ + +#include +#include + +//TODO SafeException(...) + +namespace Jobs { +namespace WidgetInstall { +namespace Exceptions { +enum Type +{ + Success, ///< Success + + ErrorInvalidWidgetPackage, ///< ? + ErrorWidgetDoesNotExist, ///< ? + ErrorFactoryWidget, ///< Widget is factory installed, and cannot be uninstalled + ErrorAreadyUninstalling, ///< Widget is already being uninstalled + ErrorOutOfDiskSpace, ///< ? + ErrorInvalidPackage, ///< Widget signature is invalid. + ErrorAlreadyInstalled, ///< ? + ErrorInternal, ///< ? + ErrorNotAllowed, ///< Widget installation or update not allowed + ///< because violation of policy ocurred + ErrorDeferred, ///< Widget installation was deferred and will be continued when possible + ErrorDatabaseFailure, ///< Failure in database + ErrorRemovingFolderFailure, ///< Failure in removing existing widget folder + ErrorInstallOspServcie, ///< Failure in installing osp service + ErrorUpdateWidget, ///< Failure in widget update. + ErrorUnknown ///< Temporary error. Try to not use this. +}; + +DECLARE_JOB_EXCEPTION_BASE(JobExceptionBase, Base, ErrorUnknown) + +// PREPARE +DECLARE_JOB_EXCEPTION(Base, NotAllowed, ErrorNotAllowed) +DECLARE_JOB_EXCEPTION(Base, Deferred, ErrorDeferred) +DECLARE_JOB_EXCEPTION(Base, InvalidWidgetUrl, ErrorInvalidWidgetPackage) + +//UNZIP +DECLARE_JOB_EXCEPTION(Base, OpenZipFailed, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, GetZipGlobalInfoFailed, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, ZipEmpty, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, GetZippedFileInfoFailed, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, ZippedFileVersionTooNew, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, ExtractFileFailed, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, OutOfDiskSpace, ErrorOutOfDiskSpace) +DECLARE_JOB_EXCEPTION(Base, InternalError, ErrorInternal) + +//CERTIFY +DECLARE_JOB_EXCEPTION(Base, InvalidPackage, ErrorInvalidPackage) + +//WCONFIG +DECLARE_JOB_EXCEPTION(Base, WidgetConfigFileInvalid, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, NotInstalled, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, InstallationFailed, ErrorInvalidWidgetPackage) +DECLARE_JOB_EXCEPTION(Base, AlreadyInstalled, ErrorAlreadyInstalled) +DECLARE_JOB_EXCEPTION(Base, UnknownError, ErrorUnknown) +DECLARE_JOB_EXCEPTION(Base, DatabaseFailure, ErrorDatabaseFailure) +DECLARE_JOB_EXCEPTION(Base, RemovingFolderFailure, ErrorRemovingFolderFailure) + +DECLARE_JOB_EXCEPTION(Base, CopyIconFailed, ErrorUnknown) + +// Installation osp service +DECLARE_JOB_EXCEPTION(Base, RequestInstallOspsvc, ErrorInstallOspServcie) +DECLARE_JOB_EXCEPTION(Base, InstallOspsvcFailed, ErrorInstallOspServcie) +//UPDATE +DECLARE_JOB_EXCEPTION(Base, BackupFailed, ErrorUpdateWidget) +DECLARE_JOB_EXCEPTION(Base, InsertNewWidgetFailed, ErrorUpdateWidget) +DECLARE_JOB_EXCEPTION(Base, RemoveBackupFailed, ErrorUpdateWidget) +} //namespace +} //namespace +} //namespace + +#endif /* INSTALLER_ERRORS_H_ */ diff --git a/src/plugins-installer/jobs/widget_install/widget_installer_struct.h b/src/plugins-installer/jobs/widget_install/widget_installer_struct.h new file mode 100755 index 0000000..74d1f24 --- /dev/null +++ b/src/plugins-installer/jobs/widget_install/widget_installer_struct.h @@ -0,0 +1,121 @@ +/* + * 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 widget_installer_struct.h + * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com) + * @author Grzegorz Krawczyk (g.krawczyk@samsung.com) + * @version 1.0 + * @brief Implementation file for widget installer struct + */ +#ifndef WRT_SRC_INSTALLER_CORE_INSTALLER_TASKS_WIDGET_INSTALLER_STRUCT_H_ +#define WRT_SRC_INSTALLER_CORE_INSTALLER_TASKS_WIDGET_INSTALLER_STRUCT_H_ + +//SYSTEM INCLUDES +#include + +//WRT INCLUDES +#include +#include +#include +#include + +//Widget Installer typedefs +typedef void (*InstallerFinishedCallback)( + void *userParam, + WidgetHandle, + Jobs::WidgetInstall::Exceptions::Type); + +typedef void (*InstallerProgressCallback)(void *userParam, + ProgressPercent percent, + const ProgressDescription &); + +namespace WidgetUpdateMode { +enum Type +{ + Zero = 0, + + // Bits + NotInstalled = 1 << 0, + IncomingVersionNotStd = 1 << 1, + ExistingVersionNotStd = 1 << 2, + BothVersionsNotStd = 1 << 3, + ExistingVersionOlder = 1 << 4, + ExistingVersionEqual = 1 << 5, + ExistingVersionNewer = 1 << 6, + + // Policies + PolicyNeverUpdate = NotInstalled, + + PolicyWac = NotInstalled | + ExistingVersionOlder, + + PolicyAlwaysInstall = NotInstalled | + IncomingVersionNotStd | + ExistingVersionNotStd | + BothVersionsNotStd | + ExistingVersionOlder | + ExistingVersionEqual | + ExistingVersionNewer, + + PolicyForceInstall = PolicyAlwaysInstall +}; + +inline Type operator | (const Type &a, + const Type &b) +{ + return static_cast(static_cast(a) | + static_cast(b)); +} + +inline Type operator & (const Type &a, + const Type &b) +{ + return static_cast(static_cast(a) & + static_cast(b)); +} +} + +//TODO into namespace +//InstallationStruct +typedef Jobs::JobCallbacksBase +WidgetInstallCallbackBase; + +//Widget Installation Struct +struct WidgetInstallationStruct : public WidgetInstallCallbackBase +{ + WidgetUpdateMode::Type updateMode; + bool m_quiet; + + // It must be empty-constructible as a parameter of generic event + WidgetInstallationStruct() : updateMode(WidgetUpdateMode::Zero), + m_quiet(true) + { + } + + WidgetInstallationStruct(InstallerFinishedCallback finished, + InstallerProgressCallback progress, + void *param, + WidgetUpdateMode::Type mode, + bool quiet) : + WidgetInstallCallbackBase(finished, progress, param), + updateMode(mode), + m_quiet(quiet) + { + } +}; + +#endif // WRT_SRC_INSTALLER_CORE_INSTALLER_TASKS_WIDGET_INSTALLER_STRUCT_H_ diff --git a/src/plugins-installer/logic/installer_controller.cpp b/src/plugins-installer/logic/installer_controller.cpp new file mode 100644 index 0000000..61be7f2 --- /dev/null +++ b/src/plugins-installer/logic/installer_controller.cpp @@ -0,0 +1,107 @@ +/* + * 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. + */ +#include "installer_controller.h" +#include +#include + +IMPLEMENT_SINGLETON(Logic::InstallerController) + +namespace Logic +{ + +InstallerController::InstallerController() +{ +} + +//void InstallerController::OnEventReceived( +// const InstallerControllerEvents::InstallWidgetEvent &event) +//{ +// std::string fileName = event.GetArg0(); +// WidgetInstallationStruct installerStruct = event.GetArg1(); +// Jobs::JobHandle handle = +// m_installerLogic.InstallWidget(fileName, installerStruct); +// +// //TODO return handle to API +// (void)handle; +//} + +void InstallerController::OnEventReceived( + const InstallerControllerEvents::InstallPluginEvent &event) +{ + std::string dirName = event.GetArg0(); + PluginInstallerStruct installerStruct = event.GetArg1(); + + Jobs::JobHandle handle = + m_installerLogic.InstallPlugin(dirName, installerStruct); + + //TODO return handle to API + (void)handle; +} + +//void InstallerController::OnEventReceived( +// const InstallerControllerEvents::UninstallWidgetEvent &event) +//{ +// WidgetHandle widgetHandle = event.GetArg0(); +// WidgetUninstallationStruct uninstallerStruct = event.GetArg1(); +// Jobs::JobHandle handle = +// m_installerLogic.UninstallWidget(widgetHandle, uninstallerStruct); +// +// //TODO return handle to API +// (void)handle; +//} + +Eina_Bool InstallerController::AddNextStep(void *data) +{ + Jobs::Job* model = static_cast(data); + CONTROLLER_POST_EVENT(InstallerController, + InstallerControllerEvents::NextStepEvent(model)); + + return ECORE_CALLBACK_CANCEL; +} + +void InstallerController::OnEventReceived( + const InstallerControllerEvents::NextStepEvent &event) +{ + Jobs::Job* model = event.GetArg0(); + Assert(model != NULL); + + if (m_installerLogic.NextStep(model)) { + ecore_idler_add(AddNextStep, model); + } +} + +//void InstallerController::OnEventReceived( +// const InstallerControllerEvents::InstallDeferredWidgetPackagesEvent & +// event) +//{ +// (void)event; +// m_installerLogic.InstallDeferredWidgetPackages(); +//} + +void InstallerController::OnEventReceived( + const InstallerControllerEvents::InitializeEvent & /*event*/) +{ + m_installerLogic.Initialize(); +} + +void InstallerController::OnEventReceived( + const InstallerControllerEvents::TerminateEvent & /*event*/) +{ + m_installerLogic.Terminate(); +} + +} //Logic + diff --git a/src/plugins-installer/logic/installer_controller.h b/src/plugins-installer/logic/installer_controller.h new file mode 100644 index 0000000..7e8520c --- /dev/null +++ b/src/plugins-installer/logic/installer_controller.h @@ -0,0 +1,149 @@ +/* + * 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. + */ +#ifndef WRT_SRC_INSTALLER_CORE_INSTALLER_CONTROLLER_H_ +#define WRT_SRC_INSTALLER_CORE_INSTALLER_CONTROLLER_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * @brief holds events send to InstallControler + */ +namespace InstallerControllerEvents { +/** + * @brief Event for inicieting instalation process. + * + * This event holds std::string witch should be path to widget package + */ +//DECLARE_GENERIC_EVENT_2(InstallWidgetEvent, +// std::string, +// WidgetInstallationStruct) // (zipFileName, installerStruct) + +/** + * @brief Event for iniciating plugin instalation process. + * This event holds std::string witch should be path to plugin directory + * and PluginInstallerStruct which contain + * StatusCallack, progressCallback and private data for callbacks + */ +DECLARE_GENERIC_EVENT_2(InstallPluginEvent, std::string, PluginInstallerStruct) + +/** + * @brief Event for inicietig widget uninstallation. + * + * WidgetHandler is used to point witch widget shuld be uninstalled + */ +//DECLARE_GENERIC_EVENT_2(UninstallWidgetEvent, +// WidgetHandle, +// WidgetUninstallationStruct) +// +/** + * @brief Event for pushing installation process forward. + */ +DECLARE_GENERIC_EVENT_1(NextStepEvent, Jobs::Job *) + +//DECLARE_GENERIC_EVENT_0(InstallDeferredWidgetPackagesEvent) + +DECLARE_GENERIC_EVENT_0(InitializeEvent) +DECLARE_GENERIC_EVENT_0(TerminateEvent) + +} // namespace InstallerEvents + + +namespace Logic { + +/** + * @brief Controls Widget installation + * + * Main Controler of wiget installation/uninstallation, this is also used + * for pushing forward each of processes. + * It waits for three events: + *
    + *
  • InstallWidgetEvent
    • + *
  • UninstallWidgetEvent
    • + *
  • NextStepEvent
    • + *
+ */ + +typedef DPL::TypeListDecl< +// InstallerControllerEvents::InstallWidgetEvent, + InstallerControllerEvents::InstallPluginEvent, +// InstallerControllerEvents::UninstallWidgetEvent, + InstallerControllerEvents::NextStepEvent, +// InstallerControllerEvents::InstallDeferredWidgetPackagesEvent, + InstallerControllerEvents::InitializeEvent, + InstallerControllerEvents::TerminateEvent>::Type +InstallerControllerEventsSet; + +class InstallerController : public DPL::Event::Controller +{ + protected: + /** + * @brief Executed on InstallWidgetEvent received. + */ +// virtual void OnEventReceived( +// const InstallerControllerEvents::InstallWidgetEvent &event); +// + /** + * @brief Executed on InstallPluginEvent received. + */ + virtual void OnEventReceived( + const InstallerControllerEvents::InstallPluginEvent &event); + + /** + * @brief Executed on UninstallWidgetEvent received. + */ +// virtual void OnEventReceived( +// const InstallerControllerEvents::UninstallWidgetEvent &event); + /** + * @brief Executed on NextStepEvent received. + */ + virtual void OnEventReceived( + const InstallerControllerEvents::NextStepEvent &event); + +// virtual void OnEventReceived( +// const InstallerControllerEvents::InstallDeferredWidgetPackagesEvent +// &event); + + virtual void OnEventReceived( + const InstallerControllerEvents::InitializeEvent &event); + virtual void OnEventReceived( + const InstallerControllerEvents::TerminateEvent &event); + + private: + // Embedded logic + Logic::InstallerLogic m_installerLogic; + + InstallerController(); + + static Eina_Bool AddNextStep(void *data); + + friend class DPL::Singleton; +}; + +typedef DPL::Singleton InstallerControllerSingleton; + +} + +#endif // INSTALLER_CONTROLLER_H diff --git a/src/plugins-installer/logic/installer_logic.cpp b/src/plugins-installer/logic/installer_logic.cpp new file mode 100644 index 0000000..9d763c1 --- /dev/null +++ b/src/plugins-installer/logic/installer_logic.cpp @@ -0,0 +1,259 @@ +/* + * 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. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace WrtDB; + +namespace Logic { + +InstallerLogic::InstallerLogic() : + m_NextHandle(0) +{ +} + +InstallerLogic::~InstallerLogic() +{ + Assert(m_jobs.empty() && "There are still running jobs"); + //FIXME what should be done here? +} + +void InstallerLogic::Initialize() +{ + LogDebug("Done"); +} + +void InstallerLogic::Terminate() +{ + //TODO how to delete, if it is still running, paused and so on + FOREACH(it, m_jobs) + { + it->second->SetPaused(true); //FIXME this is not enough! + } + + LogDebug("Done"); +} + +Jobs::JobHandle InstallerLogic::AddAndStartJob(Jobs::Job *job) +{ + Jobs::JobHandle handle = GetNewJobHandle(); + job->SetJobHandle(handle); + + m_jobs.insert(std::make_pair(handle, job)); + + //Start job + CONTROLLER_POST_EVENT(InstallerController, + InstallerControllerEvents::NextStepEvent(job)); + + return handle; +} + +//InstallWidget, UninstallWidget InstallPlugin method are almost the same +// But each Job has different constructor, so creating new Job is specific +// i.e. widgetHandle, path etc... +//Jobs::JobHandle InstallerLogic::InstallWidget(std::string const & widgetPath, +// const WidgetInstallationStruct &installerStruct) +//{ +// LogDebug("New Widget Installation:"); +// +// Jobs::Job *job = +// new Jobs::WidgetInstall::JobWidgetInstall(widgetPath, installerStruct); +// +// return AddAndStartJob(job); +//} +// +//Jobs::JobHandle InstallerLogic::UninstallWidget(WidgetHandle widgetHandle, +// const WidgetUninstallationStruct &uninstallerStruct) +//{ +// LogDebug("New Widget Uninstallation"); +// +// Jobs::Job *job = +// new Jobs::WidgetUninstall::JobWidgetUninstall(widgetHandle, +// uninstallerStruct); +// +// return AddAndStartJob(job); +//} + +Jobs::JobHandle InstallerLogic::InstallPlugin(std::string const & pluginPath, + const PluginInstallerStruct &installerStruct) +{ + LogDebug("New Plugin Installation"); + + Jobs::Job *job = + new Jobs::PluginInstall::JobPluginInstall(pluginPath, installerStruct); + + return AddAndStartJob(job); +} + +#define TRANSLATE_JOB_EXCEPTION() \ + _rethrown_exception.getParam() +#define TRANSLATE_JOB_MESSAGE() \ + _rethrown_exception.GetMessage() + +bool InstallerLogic::NextStep(Jobs::Job *job) +{ + Try { + bool stepSucceded = job->NextStep(); + + job->SendProgress(); + + if (stepSucceded) { + return !job->IsPaused(); + } + + if (!job->GetUndoType()) { + //job successfully finished + + //send finished callback + job->SendFinishedSuccess(); + + switch (job->GetInstallationType()) { + case Jobs::PluginInstallation: + //todo move it somewhere + InstallWaitingPlugins(); + break; + default: //because of warning + break; + } + } else { + //job abort process completed + job->SendFinishedFailure(); + } + + //clean job + m_jobs.erase(job->GetJobHandle()); + delete job; + + return false; + } + catch (Jobs::JobExceptionBase &exc) { + //start revert job + LogInfo("Exception occured: " << exc.getParam() << + ". Reverting job..."); + bool hasAbortSteps = job->Abort(); + job->SetUndoType(true); + job->SaveExceptionData(exc); + + if (!hasAbortSteps) { + //no AbortSteps + job->SendFinishedFailure(); + + //clean job + m_jobs.erase(job->GetJobHandle()); + delete job; + } + return hasAbortSteps; + } +} + +//TODO this should be moved somewhere...when it should take place? after widget +//is closing? +//void InstallerLogic::InstallDeferredWidgetPackages() +//{ +// LogWarning("Not implemented"); +// // LogInfo("Installing deferred widget packages..."); +// // +// // WidgetPackageList packages = GlobalDAO::GetDefferedWidgetPackageInstallationList(); +// // +// // LogInfo(packages.size() << " widget package(s) to install"); +// // +// // // Make a copy of widget packages to install, because some +// // // widget packages may still fail because they are running +// // m_packagesToInstall = packages; +// // +// // // Start processing +// // InstallSingleDeferredPackage(); +//} +// +//void InstallerLogic::InstallSingleDeferredPackage() +//{ +// LogWarning("Not implemented"); +// // if (m_packagesToInstall.empty()) +// // return; +// // +// // // Take single package +// // DPL::String widgetPackage = m_packagesToInstall.front(); +// // m_packagesToInstall.pop_front(); +// // +// // // Remove it from DB +// // GlobalDAO::RemoveDefferedWidgetPackageInstallation(widgetPackage); +// // +// // // Begin installation +// // LogInfo("Installing deferred widget package: " << widgetPackage); +// // +// // // Post installation +// // CONTROLLER_POST_EVENT( +// // InstallerController, InstallerControllerEvents::InstallWidgetEvent( +// // DPL::ToUTF8String(widgetPackage).c_str(), WidgetInstallationStruct( +// // &DummyInstallCallback, &DummyProgressCallback, NULL, +// // WidgetUpdateMode::PolicyWac))); +//} + +void InstallerLogic::InstallWaitingPlugins() +{ + PluginHandleSetPtr waitingPlugins; + + waitingPlugins = + PluginDAO::getPluginHandleByStatus(PluginDAO::INSTALLATION_WAITING); + + FOREACH(it, *waitingPlugins) + { + resolvePluginDependencies(*it); + } +} + +bool InstallerLogic::resolvePluginDependencies(PluginHandle handle) +{ + PluginHandleSetPtr dependencies(new PluginHandleSet); + + PluginObjects::ObjectsPtr requiredObjects = + PluginDAO::getRequiredObjectsForPluginHandle(handle); + + PluginHandle depHandle = + Jobs::PluginInstall::JobPluginInstall::INVALID_HANDLE; + + FOREACH(requiredObject, *requiredObjects) + { + depHandle = + PluginDAO::getPluginHandleForImplementedObject(*requiredObject); + + if (depHandle == + Jobs::PluginInstall::JobPluginInstall::INVALID_HANDLE) { + LogError("Library implementing: " << + *requiredObject << " NOT FOUND"); + + //PluginDAO::SetPluginInstallationStatus(INSTALLATION_WAITING); + return false; + } + dependencies->insert(depHandle); + } + + PluginDAO::registerPluginLibrariesDependencies(handle, dependencies); + PluginDAO::setPluginInstallationStatus(handle, + PluginDAO::INSTALLATION_COMPLETED); + + return true; +} + +} + diff --git a/src/plugins-installer/logic/installer_logic.h b/src/plugins-installer/logic/installer_logic.h new file mode 100644 index 0000000..ec9677e --- /dev/null +++ b/src/plugins-installer/logic/installer_logic.h @@ -0,0 +1,78 @@ +/* + * 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. + */ +#ifndef WRT_SRC_INSTALLER_CORE_INSTALLER_LOGIC_H_ +#define WRT_SRC_INSTALLER_CORE_INSTALLER_LOGIC_H_ + +#include +#include +#include +#include +#include +#include + +namespace Logic { + +class InstallerLogic +{ + typedef std::map JobsContainer; + JobsContainer m_jobs; + +// void InstallDeferredWidgetPackages(); +// void InstallSingleDeferredPackage(); + + void InstallWaitingPlugins(); + bool resolvePluginDependencies(PluginHandle handle); + + Jobs::JobHandle m_NextHandle; + Jobs::JobHandle GetNewJobHandle() + { + return m_NextHandle++; + } + Jobs::JobHandle AddAndStartJob(Jobs::Job *job); + public: + virtual ~InstallerLogic(); + + void Initialize(); + + void Terminate(); + +// Jobs::JobHandle InstallWidget(std::string const & widgetPath, +// const WidgetInstallationStruct &installerStruct); +// +// Jobs::JobHandle UninstallWidget(WidgetHandle widgetHandle, +// const WidgetUninstallationStruct &uninstallerStruct); +// + Jobs::JobHandle InstallPlugin(std::string const & pluginPath, + const PluginInstallerStruct &installerStruct); + + bool NextStep(Jobs::Job* installModel); + + //TODO implement me + bool AbortJob(const Jobs::JobHandle & /*handle*/) + { + LogWarning("Not implemented"); + return true; + } + + private: + InstallerLogic(); + + friend class InstallerController; +}; + +} + +#endif // INSTALLER_LOGIC_H diff --git a/src/plugins-installer/misc/feature_logic.cpp b/src/plugins-installer/misc/feature_logic.cpp new file mode 100644 index 0000000..0c2f161 --- /dev/null +++ b/src/plugins-installer/misc/feature_logic.cpp @@ -0,0 +1,108 @@ +/* + * 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. + */ + +#include "feature_logic.h" + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace Jobs { +namespace WidgetInstall { + +FeatureLogic::FeatureLogic(WidgetHandle handle) + : m_rejected(false) +{ + WrtDB::WidgetDAOReadOnly widgetDao(handle); + WidgetFeatureSet featureSet = widgetDao.getFeaturesList(); + FOREACH(it, featureSet) { + LogInfo("Feature name : " << it->name); + WrtDB::DeviceCapabilitySet dcs = + WrtDB::GlobalDAOReadOnly::GetDeviceCapability(it->name); + FOREACH (devCap, dcs) { + LogInfo("--- dev cap : " << *devCap); + } + Feature feature(*it, dcs); + m_featureList.push_back(feature); + } + m_currentFeature = m_featureList.begin(); + + // ok we must set iterator on the first processable node + if (!isProcessable()) { + next(); + } +} + +bool FeatureLogic::isDone() const +{ + return m_currentFeature == m_featureList.end(); +} + +bool FeatureLogic::next() +{ + while (!isDone()) { + if (m_currentFeature->currentCap != m_currentFeature->devCapSet.end()) { + m_currentFeature->currentCap++; + } else { + ++m_currentFeature; + } + // we moved pointer + if (isProcessable()) { + return true; + } + } + return false; +} + + +void FeatureLogic::setAceResponse(bool allowed) +{ + Assert(isProcessable() && "Wrong usage"); + if (!allowed) { + m_currentFeature->rejected = true; + if (m_currentFeature->required) { + m_rejected = true; + } + } +} + +DPL::String FeatureLogic::getDevice() const +{ + return *(m_currentFeature->currentCap); +} + +bool FeatureLogic::isProcessable() const +{ + if (isDone()) { + return false; + } + + if (m_currentFeature->currentCap == m_currentFeature->devCapSet.end()) { + return false; + } + + return true; +} + +} // namespace WidgetInstall +} // namespace Jobs + diff --git a/src/plugins-installer/misc/feature_logic.h b/src/plugins-installer/misc/feature_logic.h new file mode 100644 index 0000000..5a95628 --- /dev/null +++ b/src/plugins-installer/misc/feature_logic.h @@ -0,0 +1,99 @@ +/* + * 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. + */ + +#ifndef SRC_INSTALLER_MISC_FEATURE_LOGIC +#define SRC_INSTALLER_MISC_FEATURE_LOGIC + +#include +#include + +#include +#include +#include + +#include +#include + +namespace Jobs { +namespace WidgetInstall { + +class FeatureLogic : DPL::Noncopyable { + public: + + FeatureLogic(WidgetHandle handle); + + bool isDone() const; + + bool next(); + + void setAceResponse(bool allowed); + + DPL::String getDevice() const; + + bool isRejected(void) const + { + return m_rejected; + } + + struct Feature : public WidgetFeature { + WrtDB::DeviceCapabilitySet devCapSet; + WrtDB::DeviceCapabilitySet::const_iterator currentCap; + + Feature(const WidgetFeature &wf, const WrtDB::DeviceCapabilitySet &set) + : WidgetFeature(wf) + , devCapSet(set) + { + currentCap = devCapSet.begin(); + } + + explicit Feature(const Feature &second) : WidgetFeature(second) + { + devCapSet = second.devCapSet; + currentCap = devCapSet.find(*second.currentCap); + rejected = second.rejected; + } + private: + void operator=(const Feature &second) { + name = second.name; + devCapSet = second.devCapSet; + required = second.required; + rejected = second.rejected; + pluginId = second.pluginId; + params = second.params; + currentCap = devCapSet.find(*second.currentCap); + } + }; + + typedef std::list FeatureList; + typedef FeatureList::const_iterator FeatureIterator; + + FeatureIterator resultBegin() { return m_featureList.begin(); } + FeatureIterator resultEnd() { return m_featureList.end(); } + + private: + bool isProcessable() const; + + FeatureList m_featureList; + FeatureList::iterator m_currentFeature; + bool m_rejected; +}; + +typedef DPL::SharedPtr FeatureLogicPtr; + +} // namespace WidgetInstall +} // namespace Jobs + +#endif // SRC_INSTALLER_MISC_FEATURE_LOGIC diff --git a/src/plugins-installer/misc/libxml_utils.cpp b/src/plugins-installer/misc/libxml_utils.cpp new file mode 100644 index 0000000..61aa5cc --- /dev/null +++ b/src/plugins-installer/misc/libxml_utils.cpp @@ -0,0 +1,54 @@ +/* + * 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 libxml_utils.cpp + * @author Tomasz Iwanek (t.iwanek@samsung.com) + */ + +#include "libxml_utils.h" + +#include + +IMPLEMENT_SINGLETON(LibxmlUtils) + +LibxmlUtils::LibxmlUtils() : isInitialized(false) +{ +} + +LibxmlUtils::~LibxmlUtils() +{ + if(isInitialized) + { + LogDebug("Libxml - cleaning"); + // Cleanup function for the XML library. + xmlCleanupParser(); + //this is to debug memory for regression tests + xmlMemoryDump(); + } +} + +void LibxmlUtils::init() +{ + if(!isInitialized) + { + LIBXML_TEST_VERSION + isInitialized = true; + LogDebug("Libxml have been initialized"); + } + LogDebug("Libxml already initialized"); +} + + diff --git a/src/plugins-installer/misc/libxml_utils.h b/src/plugins-installer/misc/libxml_utils.h new file mode 100644 index 0000000..d662bc7 --- /dev/null +++ b/src/plugins-installer/misc/libxml_utils.h @@ -0,0 +1,58 @@ +/* + * 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 libxml_utils.h + * @author Tomasz Iwanek (t.iwanek@samsung.com) + */ + +#ifndef LIBXML_UTILS_H +#define LIBXML_UTILS_H + +#include +#include + +#include +#include +#include +#include + +/** + * @brief The LibxmlUtils class + * + * Singleton for assurence for libxml2 initialization + * + * Use: LibxmlUtils::Instance().init(); to initialize library + * + */ +class LibxmlUtils +{ +public: + DECLARE_EXCEPTION_TYPE(DPL::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, Libxml2Error) + + LibxmlUtils(); + ~LibxmlUtils(); + + void init(); +private: + bool isInitialized; + + friend class DPL::Singleton; +}; + +typedef DPL::Singleton LibxmlSingleton; + +#endif // LIBXML_UTILS_H diff --git a/src/plugins-installer/misc/wac_widget_id.cpp b/src/plugins-installer/misc/wac_widget_id.cpp new file mode 100644 index 0000000..bc1f128 --- /dev/null +++ b/src/plugins-installer/misc/wac_widget_id.cpp @@ -0,0 +1,100 @@ +/* + * 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 + * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com) + * @version 1.0 + * @brief + */ +#include "wac_widget_id.h" + +#include +#include + +#include +#include + +#include +#include + +namespace { +const char *SCHEME_HTTP = "http"; +const char *SCHEME_HTTPS = "https"; +} + +WacWidgetId::WacWidgetId(const DPL::OptionalString &widgetId) : + m_schemaMatch(false) +{ + if (!widgetId.IsNull()) { + std::string wid = DPL::ToUTF8String(*widgetId); + parse(wid.c_str()); + } +} + +bool WacWidgetId::matchHost(const DPL::String &second) const +{ + LogDebug("m_schemaMatch is: " << m_schemaMatch); + if (!m_schemaMatch) { + return false; + } + + LogDebug("Matching DNS identity: " << m_host << + " " << DPL::ToUTF8String(second)); + + return m_host == DPL::ToUTF8String(second); +} + +void WacWidgetId::parse(const char *url) +{ + LogDebug("Widget id to parse: " << url); + + std::unique_ptr > + iri(iri_parse(url), iri_destroy); + + if (!iri.get()) { + LogDebug("Error in parsing widget id."); + return; // m_schemaMatch == false; + } + + std::string scheme; + + if (iri.get()->scheme) { + scheme = iri.get()->scheme; + } else { + LogWarning("Error. No scheme in widget id."); + return; // m_schemaMatch == false; + } + + // should we support HTTP and HTTPS? wac says nothing + // std::transform(m_scheme.begin(), m_scheme.end(), m_scheme.begin(), tolower); + + // We only match "http" and "https" schemas + if ((scheme != SCHEME_HTTP) && (scheme != SCHEME_HTTPS)) { + LogWarning("Unknown scheme in widget id." << scheme); + return; // m_schemaMatch == false; + } else { + m_schemaMatch = true; + } + + if (iri.get()->host) { + m_host = iri.get()->host; + LogDebug("Host has been set to: " << m_host); + } + + // What to do when host is empty? No info in wac documentation. + + // Any post processing algorithm? No info in wac documentation. +} diff --git a/src/plugins-installer/misc/wac_widget_id.h b/src/plugins-installer/misc/wac_widget_id.h new file mode 100644 index 0000000..dba5f36 --- /dev/null +++ b/src/plugins-installer/misc/wac_widget_id.h @@ -0,0 +1,42 @@ +/* + * 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 + * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com) + * @version 1.0 + * @brief + */ +#ifndef WRT_ENGINE_SRC_INSTALLER_CORE_MISC_WAC_WIDGET_ID_H +#define WRT_ENGINE_SRC_INSTALLER_CORE_MISC_WAC_WIDGET_ID_H + +#include +#include + +class WacWidgetId +{ + public: + explicit WacWidgetId(const DPL::OptionalString &widgetId); + bool matchHost(const DPL::String &second) const; + + private: + void parse(const char *url); + + bool m_schemaMatch; + std::string m_host; +}; + +#endif // WRT_ENGINE_SRC_INSTALLER_CORE_MISC_WAC_WIDGET_ID_H + diff --git a/src/plugins-installer/misc/widget_location.cpp b/src/plugins-installer/misc/widget_location.cpp new file mode 100644 index 0000000..c5465a7 --- /dev/null +++ b/src/plugins-installer/misc/widget_location.cpp @@ -0,0 +1,174 @@ +/* + * 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 widget_location.cpp + * @author Iwanek Tomasz (t.iwanek@smasung.com) + */ +#include "widget_location.h" + +#include +#include +#include +#include +#include +#include + +#include + + +WidgetLocation::DirectoryDeletor::DirectoryDeletor() +{ + m_dirpath = Jobs::WidgetInstall::createTempPath(); +} + +WidgetLocation::DirectoryDeletor::~DirectoryDeletor() +{ + LogDebug("Removing widget installation temporary directory: " << m_dirpath.c_str()); + _WrtUtilRemoveDir(m_dirpath.c_str()); +} + +std::string WidgetLocation::DirectoryDeletor::getTempPath() const +{ + return m_dirpath; +} + +WidgetLocation::WidgetLocation() : m_browser(false) +{ +} + +WidgetLocation::WidgetLocation(const std::string & widgetname) : m_pkgname(widgetname), m_browser(false) +{ +} + +WidgetLocation::~WidgetLocation() +{ +} + +WidgetLocation::WidgetLocation(const std::string & widgetname, + std::string sourcePath, + bool browserRequest, + WrtDB::PkgType t): + m_pkgname(widgetname), + m_widgetSource(sourcePath), + m_browser(browserRequest), + m_type(t), + m_temp(new WidgetLocation::DirectoryDeletor()) +{ +} + +// TODO cache all these paths +std::string WidgetLocation::getInstallationDir() const +{ + return std::string(WrtDB::GlobalConfig::GetUserInstalledWidgetPath()); +} + +std::string WidgetLocation::getPackageInstallationDir() const +{ + return std::string(WrtDB::GlobalConfig::GetUserInstalledWidgetPath()) + "/" + + m_pkgname; +} + +std::string WidgetLocation::getSourceDir() const +{ + return std::string(WrtDB::GlobalConfig::GetUserInstalledWidgetPath()) + "/" + + m_pkgname + WrtDB::GlobalConfig::GetWidgetSrcPath(); +} + +std::string WidgetLocation::getBinaryDir() const +{ + return std::string(WrtDB::GlobalConfig::GetUserInstalledWidgetPath()) + "/" + + m_pkgname + WrtDB::GlobalConfig::GetUserWidgetExecPath(); +} + +std::string WidgetLocation::getBackupDir() const +{ + return getPackageInstallationDir() + "/backup"; +} + +std::string WidgetLocation::getBackupSourceDir() const +{ + return getBackupDir() + WrtDB::GlobalConfig::GetWidgetSrcPath(); +} + +std::string WidgetLocation::getBackupBinaryDir() const +{ + return getBackupDir() + WrtDB::GlobalConfig::GetUserWidgetExecPath(); +} + +std::string WidgetLocation::getTemporaryPackageDir() const +{ + return m_temp->getTempPath(); +} + +bool WidgetLocation::browserRequest() const +{ + return m_browser; +} + +std::string WidgetLocation::getTemporaryRootDir() const +{ + if(m_type == WrtDB::PKG_TYPE_TIZEN_WITHSVCAPP) + { + return getTemporaryPackageDir() + WrtDB::GlobalConfig::GetWidgetSrcPath(); + } + else + { + return getTemporaryPackageDir(); + } +} + +std::string WidgetLocation::getConfigurationDir() const +{ + if(m_browser) + { + std::string path = "."; + int index = m_widgetSource.find_last_of("\\/"); + if (index != std::string::npos) + { + path = m_widgetSource.substr(0, index); + } + return path; + } + else + { + return getTemporaryRootDir(); + } +} + +std::string WidgetLocation::getInstalledIconPath() const +{ + return m_iconPath; +} + +std::string WidgetLocation::getWidgetSource() const +{ + return m_widgetSource; +} + +void WidgetLocation::setIconTargetFilenameForLocale(const std::string & icon) +{ + m_iconPath = icon; +} + +void WidgetLocation::registerExternalLocation(const std::string & file) +{ + m_externals.push_back(file); +} + +WrtDB::ExternalLocationList WidgetLocation::listExternalLocations() const +{ + return m_externals; +} diff --git a/src/plugins-installer/misc/widget_location.h b/src/plugins-installer/misc/widget_location.h new file mode 100644 index 0000000..2f20bcd --- /dev/null +++ b/src/plugins-installer/misc/widget_location.h @@ -0,0 +1,182 @@ +/* + * 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 widget_location.h + * @author Iwanek Tomasz (t.iwanek@smasung.com) + */ +#ifndef WRT_INSTALLER_SRC_MISC_WIDGET_LOCATION_H +#define WRT_INSTALLER_SRC_MISC_WIDGET_LOCATION_H + +#include + +#include +#include +#include + +/** + * @brief The WidgetLocation class + * + * Object that stores locations of several files/directories according + * to package name + * + * Current package layout (of installed package) is following: + * + * /opt/apps/[package_name] + * \_____________ /data + * \_____________ /bin + * \_____________ /bin/[id_of_installed_package] + * \_____________ /res/wgt/ + * \___ config.xml + * \___ [widgets_archive_content] + * + * 1) Normal Widget + * Developer provides content of res/wgt directory (package contains that directory as root). + * + * 2) For OSP Service Hybrid App is actually a bit different: + * Root is OSP Service directory, WebApp content is located in [root]/res/wgt + * + * Temporary directory is directory when widget is placed at the begining + * of installation process. After parsing process of config.xml, destination directory is created. + */ +class WidgetLocation +{ + class DirectoryDeletor + { + public: + DirectoryDeletor(); + ~DirectoryDeletor(); + std::string getTempPath() const; + private: + std::string m_dirpath; + }; + +public: + DECLARE_EXCEPTION_TYPE(DPL::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, NoTemporaryPath) + /** + * @brief WidgetLocation + * + * Creates useless object. Needed by DPL::Optional + */ + WidgetLocation(); + /** + * @brief WidgetLocation Builds paths for widget location during uninstallation + * + * Uninstallation process needs only installed package directory. + * + * @param widgetname name of widget + */ + WidgetLocation(const std::string & widgetname); + /** + * @brief WidgetLocation Builds paths for widget location during installation + * + * @param widgetname name of widget + * @param browserRequest is browser Request + * @param sourcePath given source path + * @param t declaraced type of widget if type is needed + * + * In destruction removes temporary directory + */ + WidgetLocation(const std::string & widgetname, std::string sourcePath, + bool browserRequest = false, WrtDB::PkgType t = WrtDB::PKG_TYPE_TIZEN_WEBAPP); + ~WidgetLocation(); + + // Installed paths + std::string getInstallationDir() const; // /opt/apps + std::string getPackageInstallationDir() const; // /opt/apps/[package] + std::string getSourceDir() const; // /opt/apps/[package]/res/wgt + std::string getBinaryDir() const; // /opt/apps/[package]/bin + std::string getBackupDir() const; // /opt/apps/[package]/backup + std::string getBackupSourceDir() const; // /opt/apps/[package]/backup/res/wgt + std::string getBackupBinaryDir() const; // /opt/apps/[package]/backup/bin + + bool browserRequest() const; + + // Temporary paths + /** + * @brief getTemporaryRootDir + * @return value of root for developer's provide package (root of unpacked .wgt file) + */ + std::string getTemporaryPackageDir() const; + /** + * @brief getTemporaryRootDir + * + * Value of this will differs according to type of installed widget. + * + * @return value of root for content in temporary directory to be copied into 'res/wgt' + */ + std::string getTemporaryRootDir() const; + /** + * @brief getConfigurationDir Returns rott directory for configuration requirements + * + * 1) For packed widgets it is just root of unpacked sources + * 2) For browser installation it is directory name of widget passed to installer + * + * @return configuration directory + */ + std::string getConfigurationDir() const; + + //icons + /** + * @brief setIconTargetFilenameForLocale set installed ion path according to locale + * @param icon path of application icon + */ + void setIconTargetFilenameForLocale(const std::string &icon); + /** + * @brief getIconTargetFilename gets icon path suffix for locale + * @param languageTag language tag + * @return value of suffix of path + */ + DPL::String getIconTargetFilename(const DPL::String& languageTag) const; + /** + * @brief getIconTargetFilename gets icon full path + * @param languageTag language tag + * @return value of full path + */ + std::string getInstalledIconPath() const; + + /** + * @brief getWidgetSourcePath return widget's source path given to installer + * @return value of source path + */ + std::string getWidgetSource() const; + + //external files + /** + * @brief registerExternalFile Registers file for database registration + * @param file + * + * Registered file will be stored in database and removed automatically a + * + * @return + */ + void registerExternalLocation(const std::string & file); + /** + * @brief listExternalFile list all file to be registered + */ + WrtDB::ExternalLocationList listExternalLocations() const; + +private: + std::string m_widgetSource; // Source widget zip file/widget url + bool m_browser; // is browser request installation + std::string m_pkgname; //name of package + std::string m_iconPath; //installed icon path + WrtDB::PkgType m_type; + DPL::SharedPtr m_temp; //directory + WrtDB::ExternalLocationList m_externals; +}; + +#endif // WRT_INSTALLER_SRC_MISC_WIDGET_LOCATION_H diff --git a/src/plugins-installer/wrt-installer/CMakeLists.txt b/src/plugins-installer/wrt-installer/CMakeLists.txt new file mode 100644 index 0000000..994a44d --- /dev/null +++ b/src/plugins-installer/wrt-installer/CMakeLists.txt @@ -0,0 +1,72 @@ +# 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 CMakeLists.txt +# @author Lukasz Wrzosek (l.wrzosek@samsung.com) +# @version 1.0 +# + +SET(WRT_INSTALLER_DIR + ${INSTALLER_SRC_DIR}/wrt-installer + ) + +#SET(PKG_MANAGER_DIR +# ${INSTALLER_SRC_DIR}/pkg-manager +# ) + +SET(WRT_INSTALLER_SOURCES + ${WRT_INSTALLER_DIR}/wrt_installer.cpp + ${WRT_INSTALLER_DIR}/wrt_installer_api.cpp + ${WRT_INSTALLER_DIR}/installer_callbacks_translate.cpp + ${WRT_INSTALLER_DIR}/plugin_utils.cpp + ${WRT_INSTALLER_DIR}/language_subtag_rst_tree.cpp + ${WRT_INSTALLER_DIR}/installer_main_thread.cpp + ${WRT_INSTALLER_DIR}/option_parser.cpp + # ${PKG_MANAGER_DIR}/pkgmgr_signal.cpp +) + +PKG_CHECK_MODULES(WRT_INSTALLER_DEPS + # pkgmgr-installer + libpcrecpp + # ace-install + REQUIRED) + +INCLUDE_DIRECTORIES( + # ${PKG_MANAGER_DIR} + ${WRT_INSTALLER_DEP_INCLUDES} + ${WRT_INSTALLER_INCLUDES} + ${WRT_INSTALLER_DEPS_INCLUDE_DIRS} +) + +ADD_EXECUTABLE(${TARGET_INSTALLER} + ${TARGET_INSTALLER_STATIC_SRC} + ${WRT_INSTALLER_SOURCES} +) + +ADD_DEFINITIONS(${WRT_INSTALLER_DEPS_CFLAGS}) + +TARGET_LINK_LIBRARIES(${TARGET_INSTALLER} + ${TARGET_INSTALLER_STATIC} + ${WRT_INSTALLER_DEPS_LIBRARIES} +) + + +SET_TARGET_PROPERTIES(${TARGET_INSTALLER} PROPERTIES + LINK_FLAGS "-Wl,--as-needed -Wl,--hash-style=both -Wl" + BUILD_WITH_INSTALL_RPATH ON + INSTALL_RPATH_USE_LINK_PATH ON +) + +INSTALL(TARGETS ${TARGET_INSTALLER} DESTINATION bin) diff --git a/src/plugins-installer/wrt-installer/installer_callbacks_translate.cpp b/src/plugins-installer/wrt-installer/installer_callbacks_translate.cpp new file mode 100644 index 0000000..978daa5 --- /dev/null +++ b/src/plugins-installer/wrt-installer/installer_callbacks_translate.cpp @@ -0,0 +1,282 @@ +/* + * 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 api_callbacks_translate.h + * @author Pawel Sikorski (p.sikorski@samsung.com) + * @version 1.0 + * @brief Source file for api callbacks translate functions + */ + +#include +#include + +namespace InstallerCallbacksTranslate { +WrtErrStatus TranslateError(CommonError::Type status) +{ + switch (status) { + case CommonError::WrtSuccess: + return WRT_SUCCESS; + + case CommonError::HandleNotFound: + return WRT_ERROR_HANDLE_NOT_FOUND; + + case CommonError::AlreadyRunning: + return WRT_ERROR_ALREADY_RUNNING; + + case CommonError::InvalidLanguage: + return WRT_ERROR_INVALID_LANGUAGE; + + case CommonError::AlreadyStopped: + return WRT_ERROR_ALREADY_STOPPED; + + case CommonError::StillAuthorizing: + return WRT_ERROR_STILL_AUTHORIZING; + + case CommonError::EarlyKilled: + return WRT_ERROR_EARLY_KILLED; + + case CommonError::AccessDenied: + return WRT_ERROR_ACCESS_DENIED; + + default: + LogError("Untranslatable error: " << status); + return WRT_ERROR_INTERNAL; + } +} + +void StatusCallback(int widget_handle, + CommonError::Type result, + void *data) +{ + LogDebug("StatusCallback called " << widget_handle << " | " << result); + Assert(data != NULL); + + WrtErrStatus error = TranslateError(result); + StatusCallbackStruct* statusCallbackStruct = + static_cast(data); + + if (statusCallbackStruct->status_callback) { + statusCallbackStruct->status_callback(widget_handle, + error, + statusCallbackStruct->userdata); + } else { + LogInfo("StatusCallback: ignoring NULL callback pointer"); + } + + delete statusCallbackStruct; +} + +//// callback for finished install +//void installFinishedCallback(void *userParam, +// WidgetHandle widget_handle, +// Jobs::WidgetInstall::Exceptions::Type status) +//{ +// Assert(userParam != NULL); +// +// StatusCallbackStruct *apiStr = +// static_cast(userParam); +// +// if (apiStr->status_callback) { +// // Translate error +// WrtErrStatus errorStatus; +// +// switch (status) { +// case Jobs::WidgetInstall::Exceptions::Success: +// errorStatus = WRT_SUCCESS; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorInvalidWidgetPackage: +// errorStatus = WRT_INSTALLER_ERROR_INVALID_WIDGET_PACKAGE; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorWidgetDoesNotExist: +// errorStatus = WRT_INSTALLER_ERROR_WIDGET_DOES_NOT_EXIST; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorFactoryWidget: +// errorStatus = WRT_INSTALLER_ERROR_FACTORY_WIDGET; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorAreadyUninstalling: +// errorStatus = WRT_INSTALLER_ERROR_ALREADY_UNINSTALLING; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorOutOfDiskSpace: +// errorStatus = WRT_INSTALLER_ERROR_OUT_OUT_DISK_SPACE; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorInvalidPackage: +// errorStatus = WRT_INSTALLER_ERROR_INVALID_CERTIFICATE; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorAlreadyInstalled: +// errorStatus = WRT_INSTALLER_ERROR_ALREADY_INSTALLED; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorInternal: +// errorStatus = WRT_INSTALLER_ERROR_INTERNAL; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorNotAllowed: +// errorStatus = WRT_INSTALLER_ERROR_NOT_ALLOWED; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorDeferred: +// errorStatus = WRT_INSTALLER_ERROR_DEFERRED; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorDatabaseFailure: +// errorStatus = WRT_INSTALLER_ERROR_DATABASE_FAILURE; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorInstallOspServcie: +// errorStatus = WRT_INSTALLER_ERROR_OSPSVC; +// break; +// +// case Jobs::WidgetInstall::Exceptions::ErrorUnknown: +// errorStatus = WRT_INSTALLER_ERROR_UNKNOWN; +// break; +// +// default: +// errorStatus = WRT_INSTALLER_ERROR_UNKNOWN; +// break; +// } +// +// // Callback +// apiStr->status_callback(widget_handle, errorStatus, apiStr->userdata); +// } else { +// LogInfo("installFinishedCallback: No callback"); +// } +//} + +// callback for finished install +//void uninstallFinishedCallback(void *userParam, +// WidgetHandle widget_handle, +// Jobs::WidgetUninstall::Exceptions::Type status) +//{ +// Assert(userParam != NULL); +// +// StatusCallbackStruct *apiStr = +// static_cast(userParam); +// +// if (apiStr->status_callback) { +// // Translate error +// WrtErrStatus errorStatus; +// +// switch (status) { +// case Jobs::WidgetUninstall::Exceptions::Success: +// errorStatus = WRT_SUCCESS; +// break; +// +// case Jobs::WidgetUninstall::Exceptions::ErrorAlreadyUninstalling: +// errorStatus = WRT_INSTALLER_ERROR_ALREADY_UNINSTALLING; +// break; +// +// case Jobs::WidgetUninstall::Exceptions::ErrorWidgetDoesNotExist: +// errorStatus = WRT_INSTALLER_ERROR_WIDGET_DOES_NOT_EXIST; +// break; +// +// case Jobs::WidgetUninstall::Exceptions::ErrorDatabaseFailure: +// errorStatus = WRT_INSTALLER_ERROR_DATABASE_FAILURE; +// break; +// +// case Jobs::WidgetUninstall::Exceptions::ErrorUninstallOspSvcFailed: +// errorStatus = WRT_INSTALLER_ERROR_OSPSVC; +// break; +// +// case Jobs::WidgetUninstall::Exceptions::ErrorUnknown: +// errorStatus = WRT_INSTALLER_ERROR_UNKNOWN; +// break; +// +// default: +// errorStatus = WRT_INSTALLER_ERROR_UNKNOWN; +// break; +// } +// +// // Callback +// apiStr->status_callback(widget_handle, errorStatus, apiStr->userdata); +// } else { +// LogInfo("uninstallFinishedCallback: No callback"); +// } +//} + +void pluginInstallFinishedCallback(void *userParam, + Jobs::PluginInstall::Exceptions::Type status) +{ + Assert(userParam); + + PluginStatusCallbackStruct *apiStr = + static_cast(userParam); + + if (apiStr->statusCallback) { + // Translate error + WrtErrStatus errorStatus; + + switch (status) { + case Jobs::PluginInstall::Exceptions::Success: + errorStatus = WRT_SUCCESS; + break; + case Jobs::PluginInstall::Exceptions::WrongPluginPath: + errorStatus = WRT_PLUGIN_INSTALLER_ERROR_WRONG_PATH; + break; + case Jobs::PluginInstall::Exceptions::MetafileError: + errorStatus = WRT_PLUGIN_INSTALLER_ERROR_METAFILE; + break; + case Jobs::PluginInstall::Exceptions::AlreadyInstalled: + errorStatus = WRT_PLUGIN_INSTALLER_ERROR_ALREADY_INSTALLED; + break; + case Jobs::PluginInstall::Exceptions::LoadingLibraryError: + errorStatus = WRT_PLUGIN_INSTALLER_ERROR_LIBRARY_ERROR; + break; + case Jobs::PluginInstall::Exceptions::InstallationWaiting: + errorStatus = WRT_PLUGIN_INSTALLER_ERROR_WAITING; + break; + default: + errorStatus = WRT_INSTALLER_ERROR_UNKNOWN; + break; + } + + apiStr->statusCallback(errorStatus, apiStr->userdata); + } else { + LogInfo("PluginInstallFinishedCallback: No callback"); + } + + delete apiStr; +} + +// callback for progress of install OR uninstall +void installProgressCallback(void *userParam, + ProgressPercent percent, + const ProgressDescription &description) +{ + Assert(userParam != NULL); + + StatusCallbackStruct *apiStr = + static_cast(userParam); + + if (apiStr->progress_callback) { + //CALLBACK EXEC + LogInfo("Entered " << percent << "% " << description); + apiStr->progress_callback(static_cast(percent), + description.c_str(), + apiStr->userdata); + } else { + LogInfo("installProgressCallback: ignoring NULL callback pointer"); + } +} + +} //namespace + diff --git a/src/plugins-installer/wrt-installer/installer_callbacks_translate.h b/src/plugins-installer/wrt-installer/installer_callbacks_translate.h new file mode 100644 index 0000000..224aee9 --- /dev/null +++ b/src/plugins-installer/wrt-installer/installer_callbacks_translate.h @@ -0,0 +1,87 @@ +/* + * 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 api_callbacks_translate.h + * @author Pawel Sikorski (p.sikorski@samsung.com) + * @version 1.0 + * @brief Header file for api callbacks translate functions + */ +#ifndef WRT_SRC_API_API_CALLBACKS_TRANSLATE_H_ +#define WRT_SRC_API_API_CALLBACKS_TRANSLATE_H_ + +#include +#include +//#include +//#include +#include +#include + +namespace InstallerCallbacksTranslate { +struct StatusCallbackStruct +{ + void* userdata; + WrtInstallerStatusCallback status_callback; + WrtProgressCallback progress_callback; + + StatusCallbackStruct(void* u, + WrtInstallerStatusCallback s, + WrtProgressCallback p) : + userdata(u), + status_callback(s), + progress_callback(p) + { + } +}; + +struct PluginStatusCallbackStruct +{ + void* userdata; + WrtPluginInstallerStatusCallback statusCallback; + WrtProgressCallback progressCallback; + + PluginStatusCallbackStruct(void* u, + WrtPluginInstallerStatusCallback s, + WrtProgressCallback p) : + userdata(u), + statusCallback(s), + progressCallback(p) + { + } +}; + +void StatusCallback(int widget_handle, + CommonError::Type result, + void *data); + +//void installFinishedCallback(void *userParam, +// WidgetHandle widget_handle, +// Jobs::WidgetInstall::Exceptions::Type status); +// +//void uninstallFinishedCallback(void *userParam, +// WidgetHandle widget_handle, +// Jobs::WidgetUninstall::Exceptions::Type status); + +void pluginInstallFinishedCallback(void *userParam, + Jobs::PluginInstall::Exceptions::Type status); + +// callback for progress of install OR uninstall +void installProgressCallback(void *userParam, + ProgressPercent percent, + const ProgressDescription &description); + +} //namespace + +#endif /* WRT_SRC_API_API_CALLBACKS_TRANSLATE_H_ */ diff --git a/src/plugins-installer/wrt-installer/installer_main_thread.cpp b/src/plugins-installer/wrt-installer/installer_main_thread.cpp new file mode 100755 index 0000000..4977dca --- /dev/null +++ b/src/plugins-installer/wrt-installer/installer_main_thread.cpp @@ -0,0 +1,77 @@ +/* + * 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 installer_main_thread.cpp + * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com) + * @version 1.0 + */ + +#include "installer_main_thread.h" +#include +#include +#include +#include +#include +#include +//#include +//#include +//#include + +IMPLEMENT_SINGLETON(InstallerMainThread) + +using namespace WrtDB; +//using namespace DPL::Popup; + +InstallerMainThread::InstallerMainThread() : m_attached(false) { +} + +InstallerMainThread::~InstallerMainThread() { + Assert(!m_attached); +} + +void InstallerMainThread::AttachDatabases() +{ + Assert(!m_attached); + // Attach databases + ValidationCore::AttachToThreadRW(); +// ace_return_t ret = ace_install_initialize(); +// Assert(ACE_OK == ret); // to be changed to exception in the future + WrtDB::WrtDatabase::attachToThreadRW(); + m_attached = true; +} + +void InstallerMainThread::DetachDatabases() +{ + Assert(m_attached); + m_attached = false; + // Detach databases + ValidationCore::DetachFromThread(); +// ace_return_t ret = ace_install_shutdown(); +// Assert(ACE_OK == ret); // to be changed to exception in the future + WrtDB::WrtDatabase::detachFromThread(); +} + +void InstallerMainThread::TouchArchitecture() +{ + // Touch controller + Logic::InstallerControllerSingleton::Instance().Touch(); +} + +void InstallerMainThread::TouchArchitectureOnlyInstaller() +{ + // Touch controller + Logic::InstallerControllerSingleton::Instance().Touch(); +} diff --git a/src/plugins-installer/wrt-installer/installer_main_thread.h b/src/plugins-installer/wrt-installer/installer_main_thread.h new file mode 100755 index 0000000..67c1937 --- /dev/null +++ b/src/plugins-installer/wrt-installer/installer_main_thread.h @@ -0,0 +1,45 @@ +/* + * 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 installer_main_thread.h + * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com) + * @version 1.0 + */ + +#ifndef INSTALLER_MAINTHREAD_H_ +#define INSTALLER_MAINTHREAD_H_ + +#include + +class InstallerMainThread { + public: + void AttachDatabases(); + void DetachDatabases(); + void TouchArchitecture(); + void TouchArchitectureOnlyInstaller(); + + private: + friend class DPL::Singleton; + + InstallerMainThread(); + virtual ~InstallerMainThread(); + + bool m_attached; +}; + +typedef DPL::Singleton InstallerMainThreadSingleton; + +#endif /* INSTALLER_MAINTHREAD_H_ */ diff --git a/src/plugins-installer/wrt-installer/language_subtag_rst_tree.cpp b/src/plugins-installer/wrt-installer/language_subtag_rst_tree.cpp new file mode 100644 index 0000000..119d5c6 --- /dev/null +++ b/src/plugins-installer/wrt-installer/language_subtag_rst_tree.cpp @@ -0,0 +1,170 @@ +/* + * 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 language_subtag_rst_tree.cpp + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 1.0 + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +IMPLEMENT_SINGLETON(LanguageSubtagRstTree) + +bool LanguageSubtagRstTree::ValidateLanguageTag(const std::string &tag_input) +{ + std::string tag = tag_input; + std::transform(tag.begin(), tag.end(), tag.begin(), &tolower); + + std::vector parts; + DPL::Tokenize(DPL::FromUTF8String(tag), + '-', + std::back_inserter(parts), + false); + std::vector::iterator token = parts.begin(); + if (token == parts.end()) { + return false; + } + if (WrtDB::GlobalDAOReadOnly::IsValidSubTag(*token, RECORD_TYPE_LANGUAGE)) { + ++token; + } else { + return false; + } + + if (token == parts.end()) { + return true; + } + if (WrtDB::GlobalDAOReadOnly::IsValidSubTag(*token, RECORD_TYPE_EXTLANG)) { + ++token; + } + + if (token == parts.end()) { + return true; + } + if (WrtDB::GlobalDAOReadOnly::IsValidSubTag(*token, RECORD_TYPE_SCRIPT)) { + ++token; + } + + if (token == parts.end()) { + return true; + } + if (WrtDB::GlobalDAOReadOnly::IsValidSubTag(*token, RECORD_TYPE_REGION)) { + ++token; + } + + if (token == parts.end()) { + return true; + } + while (token != parts.end()) { + if (WrtDB::GlobalDAOReadOnly::IsValidSubTag( + *token, RECORD_TYPE_VARIANT)) + { + ++token; + } else { + break; + } + } + + //'u' - unicode extension - only one BCP47 extension is registered. + //TODO: unicode extension should be also validated (l.wrzosek) + if (token == parts.end()) { + return true; + } + if (*token == L"u") { + ++token; + bool one_or_more = false; + while (token != parts.end() && + token->size() > 1 && + token->size() <= 8) { + one_or_more = true; + ++token; + } + if (!one_or_more) { + return false; + } + } + + //'x' - privateuse + if (token == parts.end()) { + return true; + } + if (*token == L"x") { + ++token; + bool one_or_more = false; + while (token != parts.end() && + !token->empty() && + token->size() <= 8) { + one_or_more = true; + ++token; + } + if (!one_or_more) { + return false; + } + } + + if (token == parts.end()) { + return true; + } + + //Try private use now: + token = parts.begin(); + if (*token == L"x") { + ++token; + bool one_or_more = false; + while (token != parts.end() && + !token->empty() && + token->size() <= 8) { + one_or_more = true; + ++token; + } + return one_or_more; + } + + //grandfathered is always rejected + return false; +} + +#define TEST_LANG(str, cond) \ + if (LanguageSubtagRstTreeSingleton::Instance().\ + ValidateLanguageTag(str) == cond) {\ + LogDebug("Good validate status for lang: " << str);\ + } else {\ + LogError("Wrong validate status for lang: " << str\ + << ", should be " << cond);\ + } + +void LanguageSubtagRstTree::Initialize() +{ + /* Temporarily added unit test. Commented out due to performance drop. + TEST_LANG("zh", true); + TEST_LANG("esx-al", true); + TEST_LANG("zh-Hant", true); + TEST_LANG("zh-Hant-CN", true); + TEST_LANG("zh-Hant-CN-x-private1-private2", true); + TEST_LANG("plxxx", false); + TEST_LANG("pl-x-private111", false); + TEST_LANG("x-private1", false); //do not support pure private ones + TEST_LANG("x-private22", false); + TEST_LANG("i-private22", false); //do not support i-* + */ +} + +#undef TEST_LANG diff --git a/src/plugins-installer/wrt-installer/language_subtag_rst_tree.h b/src/plugins-installer/wrt-installer/language_subtag_rst_tree.h new file mode 100644 index 0000000..b057059 --- /dev/null +++ b/src/plugins-installer/wrt-installer/language_subtag_rst_tree.h @@ -0,0 +1,47 @@ +/* + * 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 language_subtag_rst_tree.h + * @author Lukasz Wrzosek (l.wrzosek@samsung.com) + * @version 1.0 + */ +#ifndef LANGUAGE_SUBTAG_RST_TREE_H +#define LANGUAGE_SUBTAG_RST_TREE_H + +#include +#include +#include +class LanguageSubtagRstTree : DPL::Noncopyable +{ + public: + void Initialize(); + bool ValidateLanguageTag(const std::string &tag); +}; + +typedef DPL::Singleton LanguageSubtagRstTreeSingleton; + +enum iana_record_types_e +{ + RECORD_TYPE_LANGUAGE, + RECORD_TYPE_SCRIPT, + RECORD_TYPE_REGION, + RECORD_TYPE_VARIANT, + RECORD_TYPE_GRANDFATHERED, + RECORD_TYPE_REDUNDANT, + RECORD_TYPE_EXTLANG +}; + +#endif //LANGUAGE_SUBTAG_RST_TREE_H diff --git a/src/plugins-installer/wrt-installer/option_parser.cpp b/src/plugins-installer/wrt-installer/option_parser.cpp new file mode 100644 index 0000000..334fbb4 --- /dev/null +++ b/src/plugins-installer/wrt-installer/option_parser.cpp @@ -0,0 +1,57 @@ +/* + * 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 option_parser.cpp + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + * @brief Implementation file for OptionParser. + */ + +#include +#include +#include +#include "option_parser.h" + +DPL::OptionalString OptionParser::QueryOption(int argc, + char* argv[], + const std::string& name) +{ + DPL::OptionalString result; + + std::vector args(argv, (argv + argc)); + + auto it = std::find_if(args.begin(), + args.end(), + [&name](const std::string& option){ + return (option == name); + }); + + if (it != args.end()) + { + std::string value; + while ((++it != args.end()) && !IsOption(*it)) + { + value += *it + " "; + } + result = DPL::FromUTF8String(value); + } + + return result; +} + +bool OptionParser::IsOption(const std::string& name) +{ + return (name.find('-') == 0); +} diff --git a/src/plugins-installer/wrt-installer/option_parser.h b/src/plugins-installer/wrt-installer/option_parser.h new file mode 100644 index 0000000..599bc59 --- /dev/null +++ b/src/plugins-installer/wrt-installer/option_parser.h @@ -0,0 +1,39 @@ +/* + * 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 option_parser.h + * @author Zbigniew Kostrzewa (z.kostrzewa@samsung.com) + * @brief Header file for OptionParser. + */ + +#ifndef WRT_INSTALLER_SRC_WRT_INSTALLER_OPTION_PARSER_H_ +#define WRT_INSTALLER_SRC_WRT_INSTALLER_OPTION_PARSER_H_ + +#include +#include + +class OptionParser +{ +public: + static DPL::OptionalString QueryOption(int argc, + char* argv[], + const std::string& name); + +private: + static bool IsOption(const std::string& name); +}; + +#endif diff --git a/src/plugins-installer/wrt-installer/plugin_utils.cpp b/src/plugins-installer/wrt-installer/plugin_utils.cpp new file mode 100644 index 0000000..ae29f5e --- /dev/null +++ b/src/plugins-installer/wrt-installer/plugin_utils.cpp @@ -0,0 +1,109 @@ +/* + * 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 plugin-utils.cpp + * @author + * @version 1.0 + * @brief Header file for plugin util + */ + +#include "plugin_utils.h" +#include +#include +#include +#include + +using namespace WrtDB; + +namespace PluginUtils { +const char PLUGIN_INSTALL_SEMAPHORE[] = "/.wrt_plugin_install_lock"; + +static DPL::Semaphore semaphore(PLUGIN_INSTALL_SEMAPHORE); + +bool lockPluginInstallation() +{ + Try { + semaphore.Lock(); + return true; + } + Catch(DPL::Semaphore::Exception::Base){ + return false; + } +} + +bool unlockPluginInstallation() +{ + Try { + semaphore.Unlock(); + return true; + } + Catch(DPL::Semaphore::Exception::Base){ + return false; + } +} + +bool checkPluginInstallationRequired() +{ + std::string installRequest = + std::string(GlobalConfig::GetPluginInstallInitializerName()); + + FileState::Type installationRequest = + checkFile(installRequest); + + switch (installationRequest) { + case FileState::FILE_EXISTS: + return true; + case FileState::FILE_NOT_EXISTS: + return false; + default: + LogWarning("Opening installation request file failed"); + return false; + } +} + +bool removeInstallationRequiredFlag() +{ + std::string installRequest = + std::string(GlobalConfig::GetPluginInstallInitializerName()); + + return removeFile(installRequest); +} + +//checks if file exists and is regular file +FileState::Type checkFile(const std::string& filename) +{ + struct stat tmp; + + if (-1 == stat(filename.c_str(), &tmp)) { + if (ENOENT == errno) { + return FileState::FILE_NOT_EXISTS; + } + return FileState::FILE_READ_DATA_ERROR; + } else if (!S_ISREG(tmp.st_mode)) { + return FileState::FILE_EXISTS_NOT_REGULAR; + } + return FileState::FILE_EXISTS; +} + +bool removeFile(const std::string& filename) +{ + if (0 != unlink(filename.c_str())) { + return false; + } + + return true; +} +} //namespace PluginUtils diff --git a/src/plugins-installer/wrt-installer/plugin_utils.h b/src/plugins-installer/wrt-installer/plugin_utils.h new file mode 100755 index 0000000..659e627 --- /dev/null +++ b/src/plugins-installer/wrt-installer/plugin_utils.h @@ -0,0 +1,48 @@ +/* + * 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 plugin-utils.h + * @author + * @version 1.0 + * @brief Header file for plugin util + */ +#ifndef PLUGIN_UTILS_H +#define PLUGIN_UTILS_H + +#include +#include + +namespace PluginUtils { +struct FileState +{ + enum Type + { + FILE_EXISTS, + FILE_EXISTS_NOT_REGULAR, + FILE_NOT_EXISTS, + FILE_READ_DATA_ERROR + }; +}; + +bool lockPluginInstallation(); +bool unlockPluginInstallation(); +bool checkPluginInstallationRequired(); +bool removeInstallationRequiredFlag(); +FileState::Type checkFile(const std::string& filename); +bool removeFile(const std::string& filename); + +} +#endif // PLUGIN_UTILS_H diff --git a/src/plugins-installer/wrt-installer/wrt_installer.cpp b/src/plugins-installer/wrt-installer/wrt_installer.cpp new file mode 100644 index 0000000..9af169b --- /dev/null +++ b/src/plugins-installer/wrt-installer/wrt_installer.cpp @@ -0,0 +1,896 @@ +/* + * 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 wrt_installer.cpp + * @version 1.0 + * @brief Implementation file for installer + */ + +#include "wrt_installer.h" +#include "plugin_utils.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "option_parser.h" +#include +#include +#include +//#include + +#define NOFILE_CNT_FOR_INSTALLER 9999 + +using namespace WrtDB; + +namespace { // anonymous +const char AUL_ARG_KEY[] = "widget_arg"; +const char * const PKGMGR_INSTALL_MSG = "Install widget"; +const char * const PKGMGR_UNINSTALL_MSG = "Uninstall widget"; + +const double BASE_LAYOUT_W = 720.0f; +const double BASE_LAYOUT_H = 1280.0f; + +const char * const CONFIG_XML = "config.xml"; + +struct PluginInstallerData +{ + void* wrtInstaller; + std::string pluginPath; +}; +} // namespace anonymous + +WrtInstaller::WrtInstaller(int argc, char **argv) : + Application(argc, argv, "backend", false), + DPL::TaskDecl(this), + m_packagePath(), + m_handle(-1), + m_initialized(false), + m_numPluginsToInstall(0), + m_totalPlugins(0), + m_returnStatus(-1), +// m_installByPkgmgr(false), + m_quiet(true), +// m_popup(NULL), + m_startupPluginInstallation(false) +{ + Touch(); + LogDebug("App Created"); +} + +WrtInstaller::~WrtInstaller() +{ + LogDebug("App Finished"); +} + +void WrtInstaller::OnStop() +{ + LogInfo("Stopping Dummy Client"); +} + +void WrtInstaller::OnCreate() +{ + LogInfo("Creating DummyClient"); + + AddStep(&WrtInstaller::initStep); + + std::string arg = m_argv[0]; + + if (arg.empty()) { + return showHelpAndQuit(); + } + + installNewPlugins(); + + if (arg.find("wrt-installer") != std::string::npos) + { + if (m_argc <= 1) { + return showHelpAndQuit(); + } + + arg = m_argv[1]; + if (arg == "-h" || arg == "--help") { + if (m_argc != 2) { + return showHelpAndQuit(); + } + + // Just show help + return showHelpAndQuit(); + } else if (arg == "-p" || arg == "--install-plugins") { + if (m_argc != 2) { + return showHelpAndQuit(); + } + if (!m_startupPluginInstallation) { + AddStep(&WrtInstaller::installPluginsStep); + } else { + LogInfo("Plugin installation alredy started"); + } + } + else + { + LogError("Unknown option"); + return showHelpAndQuit(); + } + } + + AddStep(&WrtInstaller::shutdownStep); + DPL::Event::ControllerEventHandler< + WRTInstallerNS::NextStepEvent>::PostEvent( + WRTInstallerNS::NextStepEvent()); +} + +//void WrtInstaller::OnReset(bundle *b) +//{ +// const char * bundledVal = bundle_get_val(b, AUL_ARG_KEY); +// if (bundledVal != NULL) { +// m_bundleValue = bundledVal; +// LogInfo("Bundled value for (" << AUL_ARG_KEY << ") key received: " << +// m_bundleValue); +// } +//} + +int WrtInstaller::getReturnStatus() const +{ + if (!m_returnStatus) { + return RE_SUCCESS; + } else { + return RE_FAIL; + } +} + +void WrtInstaller::OnTerminate() +{ + LogDebug("Wrt Shutdown now"); + PluginUtils::unlockPluginInstallation(); + if (m_initialized) { + wrt_installer_shutdown(); + } +// delete m_popup; +} + +void WrtInstaller::showHelpAndQuit() +{ + printf("Usage: wrt-installer [OPTION]... [WIDGET: ID/NAME/GUID/PATH]...\n" + "Operate with WebRuntime daemon: install, uninstall" + " and launch widgets.\n" + "Query list of installed widgets and setup up debugging support.\n" + "\n" + "Exactly one option must be selected.\n" + "Mandatory arguments to long options are mandatory for short " + "options too.\n" + " -h, --help show this help\n" + " -p, --install-plugins install plugins\n" + "\n"); + + Quit(); +} + +void WrtInstaller::OnEventReceived(const WRTInstallerNS::QuitEvent& /*event*/) +{ + LogDebug("Quiting"); + + if (m_initialized) { + LogDebug("Wrt Shutdown now"); + SwitchToStep(&WrtInstaller::shutdownStep); + DPL::Event::ControllerEventHandler::PostEvent( + WRTInstallerNS::NextStepEvent()); + } else { + LogDebug("Quiting application"); + return Quit(); + } +} + +void WrtInstaller::OnEventReceived( + const WRTInstallerNS::NextStepEvent& /*event*/) +{ + LogDebug("Executing next step"); + NextStep(); +} + +void WrtInstaller::OnEventReceived( + const WRTInstallerNS::InstallPluginEvent& /*event*/) +{ + PluginInstallerData* privateData = new PluginInstallerData; + privateData->wrtInstaller = this; + + if (!(*m_pluginsPaths).empty()) { + privateData->pluginPath = (*m_pluginsPaths).front(); + (*m_pluginsPaths).pop_front(); + + wrt_install_plugin(privateData->pluginPath.c_str(), + static_cast(privateData), + &staticWrtPluginInstallationCallback, + &staticWrtPluginInstallProgressCb); + } else { + delete privateData; + } +} + +void WrtInstaller::initStep() +{ + wrt_installer_init(this, staticWrtInitCallback); +} + +//void WrtInstaller::installStep() +//{ +// LogDebug("Installing widget ..."); +// DPL::ScopedFree packagePath(canonicalize_file_name( +// m_packagePath.c_str())); +// +// wrt_install_widget(packagePath ? packagePath.Get() : m_packagePath.c_str(), +// this, &staticWrtStatusCallback, +// (!m_quiet || m_installByPkgmgr) +// ? &staticWrtInstallProgressCallback : NULL, +// m_installPolicy, +// m_quiet); +//} + +void WrtInstaller::installPluginsStep() +{ + LogDebug("Installing plugins ..."); + + if (m_startupPluginInstallation) { + LogInfo("Plugin installation started because new plugin package found"); + } else if (!PluginUtils::lockPluginInstallation()) { + LogError("Failed to open plugin installation lock file" + " Plugins are currently installed by other process"); + staticWrtPluginInstallationCallback(WRT_PLUGIN_INSTALLER_ERROR_LOCK, + this); + return; + } + + std::string PLUGIN_PATH = std::string(GlobalConfig::GetDevicePluginPath()); + + DIR *dir; + dir = opendir(PLUGIN_PATH.c_str()); + + if (!dir) { + return; + } + + LogInfo("Plugin DIRECTORY IS" << PLUGIN_PATH); + struct dirent* libdir; + + errno = 0; + + std::list pluginsPaths; + + while ((libdir = readdir(dir)) != 0) { + if (strcmp(libdir->d_name, ".") == 0 || + strcmp(libdir->d_name, "..") == 0) + { + continue; + } + + std::string path = PLUGIN_PATH; + path += "/"; + path += libdir->d_name; + + struct stat tmp; + + if (stat(path.c_str(), &tmp) == -1) { + LogError("Failed to open file" << path); + continue; + } + + if (!S_ISDIR(tmp.st_mode)) { + LogError("Not a directory" << path); + continue; + } + + pluginsPaths.push_back(path); + } + + //set nb of plugins to install + //this value indicate how many callbacks are expected + m_numPluginsToInstall = pluginsPaths.size(); + LogInfo("Plugins to install: " << m_numPluginsToInstall); + m_pluginsPaths = pluginsPaths; + + m_totalPlugins = m_numPluginsToInstall; + DPL::Event::ControllerEventHandler + ::PostEvent(WRTInstallerNS::InstallPluginEvent()); + + if (-1 == TEMP_FAILURE_RETRY(closedir(dir))) { + LogError("Failed to close dir: " << dir); + } +} + +//void WrtInstaller::uninstallStep() +//{ +// LogDebug("Uninstalling widget ..."); +// wrt_uninstall_widget(m_handle, this, &staticWrtStatusCallback, +// (!m_quiet || m_installByPkgmgr) +// ? &staticWrtUninstallProgressCallback : NULL); +//} + +//void WrtInstaller::uninstallPkgNameStep() +//{ +// LogDebug("Uninstalling widget ..."); +// WrtErrStatus status = wrt_get_widget_by_pkgname(m_name, &m_handle); +// if (status == WRT_SUCCESS) { +// LogDebug("Get Widget Handle by package name : " << m_handle); +// wrt_uninstall_widget(m_handle, this, &staticWrtStatusCallback, +// (!m_quiet || m_installByPkgmgr) +// ? &staticWrtUninstallProgressCallback : NULL); +// } else { +// printf("failed: can not uninstall widget\n"); +// LogError("Fail to uninstalling widget... "); +// m_returnStatus = -1; +// DPL::Event::ControllerEventHandler::PostEvent( +// WRTInstallerNS::QuitEvent()); +// } +//} + +//void WrtInstaller::uninstallGuidStep() +//{ +// LogDebug("Uninstalling widget ..."); +// WrtErrStatus status = wrt_get_widget_by_guid(m_name, &m_handle); +// if (status == WRT_SUCCESS) { +// LogDebug("Get Widget Handle by guid : " << m_handle); +// wrt_uninstall_widget(m_handle, this, &staticWrtStatusCallback, +// !m_quiet ? &staticWrtUninstallProgressCallback : NULL); +// } else { +// printf("failed: can not uninstall widget\n"); +// LogError("Fail to uninstalling widget... "); +// m_returnStatus = -1; +// DPL::Event::ControllerEventHandler::PostEvent( +// WRTInstallerNS::QuitEvent()); +// } +//} +// +//void WrtInstaller::unistallWgtFileStep() +//{ +// LogDebug("Uninstalling widget ..."); +// +// Try { +// // Parse config +// ParserRunner parser; +// ConfigParserData configInfo; +// +// // Open zip file +// DPL::ScopedPtr zipFile( +// new DPL::ZipInput(m_packagePath)); +// +// // Open config.xml file +// DPL::ScopedPtr configFile( +// zipFile->OpenFile(CONFIG_XML)); +// +// // Extract config +// DPL::BinaryQueue buffer; +// DPL::AbstractWaitableInputAdapter inputAdapter(configFile.Get()); +// DPL::AbstractWaitableOutputAdapter outputAdapter(&buffer); +// DPL::Copy(&inputAdapter, &outputAdapter); +// parser.Parse(&buffer, +// ElementParserPtr( +// new RootParser(configInfo, +// DPL::FromUTF32String( +// L"widget")))); +// +// DPL::OptionalString widgetGUID = configInfo.widget_id; +// +// std::string guid = DPL::ToUTF8String(*widgetGUID); +// +// WrtErrStatus status = wrt_get_widget_by_guid(guid, &m_handle); +// if (status == WRT_SUCCESS) { +// LogDebug("Get Widget Handle by guid : " << m_handle); +// wrt_uninstall_widget(m_handle, this, &staticWrtStatusCallback, +// !m_quiet ? &staticWrtUninstallProgressCallback : NULL); +// } else { +// LogError("Fail to uninstalling widget... "); +// m_returnStatus = -1; +// DPL::Event::ControllerEventHandler::PostEvent( +// WRTInstallerNS::QuitEvent()); +// } +// } +// Catch(DPL::ZipInput::Exception::OpenFailed) +// { +// LogError("Failed to open widget package"); +// printf("failed: widget package does not exist\n"); +// m_returnStatus = -1; +// DPL::Event::ControllerEventHandler::PostEvent( +// WRTInstallerNS::QuitEvent()); +// } +// Catch(DPL::ZipInput::Exception::OpenFileFailed) +// { +// printf("failed: widget config file does not exist\n"); +// LogError("Failed to open config.xml file"); +// m_returnStatus = -1; +// DPL::Event::ControllerEventHandler::PostEvent( +// WRTInstallerNS::QuitEvent()); +// } +// Catch(ElementParser::Exception::ParseError) +// { +// printf("failed: can not parse config file\n"); +// LogError("Failed to parse config.xml file"); +// m_returnStatus = -1; +// DPL::Event::ControllerEventHandler::PostEvent( +// WRTInstallerNS::QuitEvent()); +// } +//} + +void WrtInstaller::shutdownStep() +{ + LogDebug("Closing Wrt connection ..."); + if (m_initialized) { + wrt_installer_shutdown(); + m_initialized = false; + DPL::Event::ControllerEventHandler::PostEvent( + WRTInstallerNS::QuitEvent()); + } +} + +void WrtInstaller::staticWrtInitCallback(WrtErrStatus status, + void* userdata) +{ + WrtInstaller *This = static_cast(userdata); + Assert(This); + + if (status == WRT_SUCCESS) { + LogDebug("Init succesfull"); + This->m_initialized = true; + This->m_returnStatus = 0; + +// if (!This->m_quiet) { +// This->m_popup = new InstallerPopup; +// This->m_popup->init(); +// } + + This->DPL::Event::ControllerEventHandler + ::PostEvent(WRTInstallerNS::NextStepEvent()); + } else { + LogError("Init unsuccesfull"); + This->m_returnStatus = -1; + This->DPL::Event::ControllerEventHandler::PostEvent( + WRTInstallerNS::QuitEvent()); + } +} +// +//void WrtInstaller::staticWrtStatusCallback(int handle, +// WrtErrStatus status, +// void* userdata) +//{ +// WrtInstaller *This = static_cast(userdata); +// Assert(This); +// +// Step current = This->GetCurrentStep(); +// DPL::String resultMsg; +// std::string printMsg; +// +// if (current == &WrtInstaller::installStep) +// { +// resultMsg = DPL::FromUTF8String(PKGMGR_INSTALL_MSG); +// printMsg = "installed"; +// } else if (current == &WrtInstaller::uninstallStep || +// current == &WrtInstaller::uninstallPkgNameStep || +// current == &WrtInstaller::uninstallGuidStep || +// current == &WrtInstaller::unistallWgtFileStep) +// { +// resultMsg = DPL::FromUTF8String(PKGMGR_UNINSTALL_MSG); +// printMsg = "uninstalled"; +// } +// +// if (WRT_SUCCESS != status) { +// // Failure +// LogDebug("Step failed"); +// This->m_returnStatus = -1; +// +// if (!This->m_quiet) { +// resultMsg += L" : " + DPL::FromUTF8String(PKGMGR_END_FAILURE); +// This->m_popup->showPopup(This, resultMsg, failResultCallback); +// } else { +// This->DPL::Event::ControllerEventHandler +// ::PostEvent(WRTInstallerNS::QuitEvent()); +// } +// +// switch (status) { +// case WRT_INSTALLER_ERROR_INVALID_WIDGET_PACKAGE: +// This->m_returnStatus = 1; //this status is specific +// printf("failed: invalid widget package\n"); +// break; +// +// case WRT_INSTALLER_ERROR_WIDGET_DOES_NOT_EXIST: +// printf("failed: widget package does not exist\n"); +// break; +// +// case WRT_INSTALLER_ERROR_FACTORY_WIDGET: +// printf("failed: factory widget\n"); +// break; +// +// case WRT_INSTALLER_ERROR_ALREADY_UNINSTALLING: +// printf("failed: already uninstalling\n"); +// break; +// +// case WRT_INSTALLER_ERROR_OUT_OUT_DISK_SPACE: +// printf("failed: out of disk space\n"); +// break; +// +// case WRT_INSTALLER_ERROR_INVALID_CERTIFICATE: +// printf("failed: invalid certificate\n"); +// break; +// +// case WRT_INSTALLER_ERROR_ALREADY_INSTALLED: +// printf("failed: already installed\n"); +// break; +// +// case WRT_INSTALLER_ERROR_INTERNAL: +// printf("failed: internal error\n"); +// break; +// +// case WRT_INSTALLER_ERROR_NOT_ALLOWED: +// printf("failed: installation or update not allowed; invalid" +// " mode\n"); +// break; +// +// case WRT_INSTALLER_ERROR_DEFERRED: +// printf("deferred: widget update will continue after the widget" +// " has been stopped\n"); +// break; +// +// case WRT_INSTALLER_ERROR_DATABASE_FAILURE: +// printf("failed: database failure\n"); +// break; +// +// case WRT_INSTALLER_ERROR_OSPSVC: +// printf("failed: during installation or uninstallation osp service\n"); +// break; +// +// case WRT_INSTALLER_ERROR_UNKNOWN: +// printf("failed: unknown error\n"); +// break; +// +// default: +// break; +// } +// } else { +// +// printf("%s : %d\n", printMsg.c_str(), handle); +// LogDebug("Status succesfull"); +// This->m_handle = handle; +// This->m_returnStatus = 0; +// resultMsg += L" : " + DPL::FromUTF8String(PKGMGR_END_SUCCESS); +// +// if (!This->m_quiet) { +// This->m_popup->showPopup(This, resultMsg, showResultCallback); +// } else { +// This->DPL::Event::ControllerEventHandler +// ::PostEvent(WRTInstallerNS::NextStepEvent()); +// } +// } +//} + +void WrtInstaller::staticWrtPluginInstallationCallback(WrtErrStatus status, + void* userdata) +{ + Assert(userdata); + + PluginInstallerData* data = static_cast(userdata); + + WrtInstaller *This = static_cast(data->wrtInstaller); + + std::string path = std::string(data->pluginPath); + delete data; + + This->m_numPluginsToInstall--; + LogDebug("Plugins to install: " << This->m_numPluginsToInstall); + + if (This->m_numPluginsToInstall < 1) { + LogDebug("All plugins installation completed"); + + //remove installation request + if (!PluginUtils::removeInstallationRequiredFlag()) { + LogInfo("Failed to remove file initializing plugin installation"); + } + + //remove lock file + if (!PluginUtils::unlockPluginInstallation()) { + LogInfo("Failed to remove installation lock"); + } + +// if (!This->m_quiet) { +// This->m_popup->init(); +// elm_progressbar_value_set(This->m_popup->m_progressbar, 100.0); +// evas_object_show(This->m_popup->m_popup); +// } + + This->DPL::Event::ControllerEventHandler + ::PostEvent(WRTInstallerNS::NextStepEvent()); + } else { +// if (!This->m_quiet) { +// This->m_popup->init(); +// float percent = (This->m_totalPlugins - This->m_numPluginsToInstall)/(float)This->m_totalPlugins; +// elm_progressbar_value_set(This->m_popup->m_progressbar, percent); +// evas_object_show(This->m_popup->m_popup); +// } + + This->DPL::Event::ControllerEventHandler::PostEvent( + WRTInstallerNS::InstallPluginEvent()); + } + + if (WRT_SUCCESS == status) { + This->m_returnStatus = 0; + LogDebug("One plugin Installation succesfull: " << path); + return; + } + + // Failure + LogWarning("One of the plugins installation failed!: " << path); + + if (WRT_PLUGIN_INSTALLER_ERROR_WAITING == status) { + LogInfo("Plugin installation is waiting for dependencies"); + } + + switch (status) { + case WRT_PLUGIN_INSTALLER_ERROR_WRONG_PATH: + LogError("failed: wrong path to plugin directory\n"); + break; + + case WRT_PLUGIN_INSTALLER_ERROR_METAFILE: + LogError("failed: plugin metafile error\n"); + break; + + case WRT_PLUGIN_INSTALLER_ERROR_ALREADY_INSTALLED: + LogError("failed: plugin already installed\n"); + break; + + case WRT_PLUGIN_INSTALLER_ERROR_LIBRARY_ERROR: + LogError("failed: plugin library: missing symbols or structures\n"); + break; + + case WRT_PLUGIN_INSTALLER_ERROR_UNKNOWN: + LogError("failed: unknown error\n"); + break; + + default: + break; + } +} + +void WrtInstaller::staticWrtPluginInstallProgressCb(float percent, + const char* description, + void* userdata) +{ + PluginInstallerData* data = static_cast(userdata); + + std::string path = std::string(data->pluginPath); + + LogInfo("Plugin Installation: " << path << + " progress: " << percent << + "description " << description); +} + +//void WrtInstaller::staticWrtInstallProgressCallback(float percent, +// const char* description, void* userdata) +//{ +// WrtInstaller *This = static_cast(userdata); +// std::stringstream percentStr; +// LogInfo(" progress: " << percent << +// " description: " << description); +// +// if (!This->m_quiet) { +// This->m_popup->init(); +// elm_progressbar_value_set(This->m_popup->m_progressbar, percent/100.0); +// evas_object_show(This->m_popup->m_popup); +// } +//} +//void WrtInstaller::staticWrtUninstallProgressCallback(float percent, +// const char* description, void* userdata) +//{ +// WrtInstaller *This = static_cast(userdata); +// std::stringstream percentStr; +// LogInfo(" progress: " << percent << +// " description: " << description); +// +// if (!This->m_quiet) { +// This->m_popup->init(); +// elm_progressbar_value_set(This->m_popup->m_progressbar, percent/100.0); +// evas_object_show(This->m_popup->m_popup); +// } +//} + +#if 0 +WrtInstaller::InstallerPopup::InstallerPopup() : + m_win(NULL), + m_popup(NULL), + m_progressbar(NULL) +{ +} + +WrtInstaller::InstallerPopup::~InstallerPopup() +{ + LogDebug("App Finished"); +} + +void WrtInstaller::InstallerPopup::init() +{ + LogDebug("Window Init"); + + if (m_win == NULL) { + // create window + m_win = createWin("wrt-installer"); + + // create popup + m_popup = elm_popup_add(m_win); + + // create progressbar + m_progressbar = elm_progressbar_add(m_popup); + elm_object_style_set(m_progressbar, "list_progress"); + elm_progressbar_horizontal_set(m_progressbar, EINA_TRUE); + evas_object_size_hint_align_set(m_progressbar, EVAS_HINT_FILL, + EVAS_HINT_FILL); + evas_object_size_hint_weight_set(m_progressbar, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + elm_object_content_set(m_popup, m_progressbar); + elm_progressbar_value_set(m_progressbar, 0.0); + evas_object_show(m_progressbar); + + evas_object_show(m_popup); + evas_object_show(m_win); + } +} + +Evas_Object* WrtInstaller::InstallerPopup::createWin(const char *name) +{ + Evas_Object *win; + win = elm_win_add(NULL, name, ELM_WIN_DIALOG_BASIC); + + int w, h; + if(!win) + return NULL; + + elm_win_alpha_set(win, EINA_TRUE); + elm_win_title_set(win, name); + elm_win_borderless_set(win, EINA_TRUE); + elm_win_raise(win); + + ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h); + evas_object_resize(win, w, h); + return win; +} + +void WrtInstaller::InstallerPopup::showPopup(void* userdata, + const DPL::String& pkgMsg, + ShowResultCallback callback) +{ + Evas_Object *btn; + + + LogDebug("Result Popup Created"); + evas_object_del(m_popup); + m_popup = NULL; + + m_popup = elm_popup_add(m_win); + if (!m_popup) + return; + + btn = elm_button_add(m_popup); + if (!btn) { + evas_object_del(m_popup); + return; + } + elm_object_text_set(btn, "OK"); + evas_object_smart_callback_add(btn, "clicked", callback, userdata); + elm_object_part_content_set(m_popup, "button1", btn); + elm_object_part_text_set(m_popup, "title,text", "RESULT"); + elm_object_text_set(m_popup, DPL::ToUTF8String(pkgMsg).c_str()); + + evas_object_show(m_popup); + evas_object_show(m_win); + +} +#endif + +//void WrtInstaller::showResultCallback(void *data, Evas_Object* /*obj*/, +// void* /*event_info*/) +//{ +// WrtInstaller *This = static_cast(data); +// Assert(This); +// +// This->DPL::Event::ControllerEventHandler +// ::PostEvent(WRTInstallerNS::NextStepEvent()); +//} +// +//void WrtInstaller::failResultCallback(void *data, Evas_Object* /*obj*/, +// void* /*event_info*/) +//{ +// WrtInstaller *This = static_cast(data); +// Assert(This); +// +// This->DPL::Event::ControllerEventHandler +// ::PostEvent(WRTInstallerNS::QuitEvent()); +//} + +void WrtInstaller::installNewPlugins() +{ + LogDebug("Install new plugins"); + + if (!PluginUtils::lockPluginInstallation()) { + LogInfo("Lock NOT created"); + return; + } + + if (!PluginUtils::checkPluginInstallationRequired()) { + LogDebug("Plugin installation not required"); + PluginUtils::unlockPluginInstallation(); + return; + } + + m_startupPluginInstallation = true; + AddStep(&WrtInstaller::installPluginsStep); +} + +int main(int argc, char *argv[]) +{ + // Output on stdout will be flushed after every newline character, + // even if it is redirected to a pipe. This is useful for running + // from a script and parsing output. + // (Standard behavior of stdlib is to use full buffering when + // redirected to a pipe, which means even after an end of line + // the output may not be flushed). + setlinebuf(stdout); + + // Check and re-set the file open limitation + struct rlimit rlim; + if (getrlimit(RLIMIT_NOFILE, &rlim) != -1) { + LogDebug("RLIMIT_NOFILE sft(" << rlim.rlim_cur << ")" ); + LogDebug("RLIMIT_NOFILE hrd(" << rlim.rlim_max << ")" ); + + if (rlim.rlim_cur < NOFILE_CNT_FOR_INSTALLER) { + rlim.rlim_cur = NOFILE_CNT_FOR_INSTALLER; + rlim.rlim_max = NOFILE_CNT_FOR_INSTALLER; + if (setrlimit(RLIMIT_NOFILE, &rlim) == -1) { + LogError("setrlimit is fail!!"); + } + } + } else { + LogError("getrlimit is fail!!"); + } + + // set evas backend type for emulator + // popup isn't showed in the emulator, + // if backend isn't set to SW backend +// if (GlobalSettings::IsEmulator()) { +// if (setenv("ELM_ENGINE", "x11", 1)) { +// LogDebug("Enable backend"); +// } +// } + + WrtInstaller app(argc, argv); + int ret = app.Exec(); + LogDebug("App returned: " << ret); + ret = app.getReturnStatus(); + LogDebug("WrtInstaller returned: " << ret); + return ret; +} diff --git a/src/plugins-installer/wrt-installer/wrt_installer.h b/src/plugins-installer/wrt-installer/wrt_installer.h new file mode 100644 index 0000000..097a746 --- /dev/null +++ b/src/plugins-installer/wrt-installer/wrt_installer.h @@ -0,0 +1,155 @@ +/* + * 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 wrt_installer.h + * @version 1.0 + * @brief Implementation file for installer + */ +#ifndef WRT_CLIENT_H +#define WRT_CLIENT_H + +#include +#include +#include +#include +#include +#include +#include +#include +//#include +#include +//#include + +namespace WRTInstallerNS { //anonymous +DECLARE_GENERIC_EVENT_0(QuitEvent) +DECLARE_GENERIC_EVENT_0(NextStepEvent) +DECLARE_GENERIC_EVENT_0(InstallPluginEvent) +} + +typedef void (*ShowResultCallback)(void *data, Evas_Object *obj, + void *event_info); + +enum ReturnValue +{ + RE_SUCCESS, + RE_FAIL +}; + +class WrtInstaller : + public DPL::Application, + private DPL::Event::Controller::Type>, + public DPL::TaskDecl +{ + public: + WrtInstaller(int argc, + char **argv); + virtual ~WrtInstaller(); + + + int getReturnStatus() const; + + class InstallerPopup + { + public: + InstallerPopup(); + virtual ~InstallerPopup(); + + void init(); + Evas_Object* createWin(const char* name); + void showPopup(void* userdata, const DPL::String& pkgMsg, + ShowResultCallback callback); + + Evas_Object* m_win; + Evas_Object* m_popup; + Evas_Object* m_progressbar; + }; + + protected: + virtual void OnStop(); + virtual void OnCreate(); +// virtual void OnReset(bundle *b); + virtual void OnTerminate(); + + private: + void showHelpAndQuit(); + + // Events + virtual void OnEventReceived(const WRTInstallerNS::QuitEvent &event); + virtual void OnEventReceived(const WRTInstallerNS::NextStepEvent& event); + virtual void OnEventReceived(const WRTInstallerNS::InstallPluginEvent& event); + + // Installation steps + void initStep(); +// void installStep(); + void installNewPlugins(); + void installPluginsStep(); +// void uninstallStep(); +// void uninstallPkgNameStep(); +// void uninstallGuidStep(); +// void unistallWgtFileStep(); + void shutdownStep(); + void registerCallbackStep(); +// void queryListStep(); + + + // Static callbacks + static void staticWrtInitCallback(WrtErrStatus status, + void* userdata); +// static void staticWrtStatusCallback(int handle, +// WrtErrStatus status, +// void* userdata); + static void staticWrtPluginInstallationCallback(WrtErrStatus status, + void* userdata); + static void staticWrtPluginInstallProgressCb(float percent, + const char* description, + void* userdata); +// static void staticWrtInstallProgressCallback(float percent, +// const char* description, +// void* userdata); +// +// static void staticWrtUninstallProgressCallback(float percent, +// const char* description, +// void* userdata); +// +// static void showResultCallback(void *data, Evas_Object *obj, +// void *event_info); +// static void failResultCallback(void *data, Evas_Object *obj, +// void *event_info); + + // Private data + wrt_widget_install_mode_e m_installPolicy; + std::string m_bundleValue; + std::string m_packagePath; + int m_handle; + std::string m_name; + bool m_initialized; + size_t m_numPluginsToInstall; + size_t m_totalPlugins; + int m_returnStatus; +// bool m_installByPkgmgr; + bool m_quiet; + InstallerPopup *m_popup; + bool m_startupPluginInstallation; + std::string m_webAppConfig; + std::string m_webAppIcon; + + typedef std::list PluginPathList; + DPL::Optional m_pluginsPaths; +}; +#endif // WRT_CLIENT_H diff --git a/src/plugins-installer/wrt-installer/wrt_installer_api.cpp b/src/plugins-installer/wrt-installer/wrt_installer_api.cpp new file mode 100755 index 0000000..2ef0353 --- /dev/null +++ b/src/plugins-installer/wrt-installer/wrt_installer_api.cpp @@ -0,0 +1,652 @@ +/* + * 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 wrt_installer_api.cpp + * @author Chung Jihoon (jihoon.chung@samsung.com) + * @version 1.0 + * @brief This file contains definitions of wrt installer api + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace WrtDB; + +#undef TRUE +#undef FALSE +#define TRUE 0 +#define FALSE -1 + +#ifdef __cplusplus + +#define EXPORT_API __attribute__((visibility("default"))) +extern "C" +{ +#endif +// inline WidgetUpdateMode::Type translateWidgetUpdateMode( +// wrt_widget_update_mode_t updateMode) +// { +// WidgetUpdateMode::Type result = WidgetUpdateMode::Zero; +// +// if (updateMode & WRT_WIM_NOT_INSTALLED) { +// result = result | WidgetUpdateMode::NotInstalled; +// } +// +// if (updateMode & WRT_WIM_INCOMING_VERSION_NOT_STD) { +// result = result | WidgetUpdateMode::IncomingVersionNotStd; +// } +// +// if (updateMode & WRT_WIM_EXISTING_VERSION_NOT_STD) { +// result = result | WidgetUpdateMode::ExistingVersionNotStd; +// } +// +// if (updateMode & WRT_WIM_BOTH_VERSIONS_NOT_STD) { +// result = result | WidgetUpdateMode::BothVersionsNotStd; +// } +// +// if (updateMode & WRT_WIM_EXISTING_VERSION_OLDER) { +// result = result | WidgetUpdateMode::ExistingVersionOlder; +// } +// +// if (updateMode & WRT_WIM_EXISTING_VERSION_EQUAL) { +// result = result | WidgetUpdateMode::ExistingVersionEqual; +// } +// +// if (updateMode & WRT_WIM_EXISTING_VERSION_NEWER) { +// result = result | WidgetUpdateMode::ExistingVersionNewer; +// } +// +// return result; +// } +// +// void localizationSetting() +// { +// char* lang = vconf_get_str(VCONFKEY_LANGSET); +// if (!lang) { +// LogError("Cannot get locale settings from vconf"); +// } else { +// LogDebug("Language set to: " << lang); +// +// using namespace LocalizationUtils; +// +// LanguageTagsList list; +// list.push_back(DPL::FromUTF8String(lang)); +// SetSystemLanguageTags(list); +// +// LogDebug("LanguageChanged to " << lang); +// } +// } + + const char PLUGIN_INSTALL_SEMAPHORE[] = "/.wrt_plugin_install_lock"; + static int wrt_count_plugin; + + static std::string cutOffFileName(const std::string& path) + { + size_t found = path.find_last_of("/"); + if (found == std::string::npos) { + return path; + } else { + return path.substr(0, found); + } + } + + static bool checkPath(const std::string& path) + { + struct stat st; + if (0 == stat(path.c_str(), &st) && S_ISDIR(st.st_mode)) { + return true; + } + LogError("Cannot access directory [ " << path << " ]"); + return false; + } + + static bool checkPaths() + { + bool if_ok = true; + if_ok &= (checkPath(cutOffFileName( + GlobalConfig::GetWrtDatabaseFilePath()))); + if (!if_ok) { + LogError( + "Path <" << GlobalConfig::GetWrtDatabaseFilePath() << + "> does not exist."); + } + + if_ok &= (checkPath(GlobalConfig::GetDevicePluginPath())); + if (!if_ok) { + LogError( + "Path <" << GlobalConfig::GetDevicePluginPath() << + "> does not exist."); + } + + if_ok &= (checkPath(GlobalConfig::GetFactoryInstalledWidgetPath())); + if (!if_ok) { + LogError( + "Path <" << GlobalConfig::GetFactoryInstalledWidgetPath() << + "> does not exist."); + } + + if_ok &= (checkPath(GlobalConfig::GetUserInstalledWidgetPath())); + if (!if_ok) { + LogError( + "Path <" << GlobalConfig::GetUserInstalledWidgetPath() << + "> does not exist."); + } + return if_ok; + } + + void plugin_install_status_cb(WrtErrStatus status, + void* userparam) + { + Assert(userparam); + + wrt_plugin_data *plugin_data = static_cast(userparam); + + if (--wrt_count_plugin < 1) { + LogDebug("All plugins installation completed"); + + LogDebug("Call SetAllinstallpluginsCallback"); + plugin_data->plugin_installed_cb(plugin_data->user_data); + } + + if (status == WRT_SUCCESS) { + LogInfo( + "plugin installation is successful: " << + plugin_data->plugin_path); + return; + } + + LogError("Fail to install plugin : " << plugin_data->plugin_path); + + switch (status) { + case WRT_PLUGIN_INSTALLER_ERROR_WRONG_PATH: + LogError("Failed : Plugin install path is wrong"); + break; + case WRT_PLUGIN_INSTALLER_ERROR_METAFILE: + LogError("Failed : Plugin Metafile Error"); + break; + case WRT_PLUGIN_INSTALLER_ERROR_ALREADY_INSTALLED: + LogError("Failed : This Plugin is already installed"); + break; + case WRT_PLUGIN_INSTALLER_ERROR_LIBRARY_ERROR: + LogError("Failed : Library Error. Missing symbol or structures"); + break; + case WRT_PLUGIN_INSTALLER_ERROR_WAITING: + LogError("Failed : Waiting for plugin dependencies"); + break; + case WRT_PLUGIN_INSTALLER_ERROR_LOCK: + LogError("Failed : Lock Error"); + break; + case WRT_PLUGIN_INSTALLER_ERROR_UNKNOWN: + LogError("Failed : Unkown Error"); + break; + default: + break; + } + } + + void plugin_install_progress_cb(float percent, + const char* description, + void* userdata) + { + char *plugin_path = static_cast(userdata); + + LogInfo("Install plugin : " << plugin_path << + ", Progress : " << percent << + ", Description : " << description); + } + + EXPORT_API int wrt_installer_init(void *userdata, + WrtInstallerInitCallback callback) + { + // Set DPL/LOG MID + DPL::Log::LogSystemSingleton::Instance().SetTag("WRT"); + + try + { + LogInfo("[WRT-API] INITIALIZING WRT INSTALLER..."); + LogInfo("[WRT-API] BUILD: " << __TIMESTAMP__); + + // Touch InstallerController Singleton + InstallerMainThreadSingleton::Instance().TouchArchitecture(); + + // Check paths + if (!checkPaths()) { + if (callback) { + callback(WRT_ERROR_NO_PATH, userdata); + } + return TRUE; + } + + // Initialize ValidationCore - this must be done before AttachDatabases + ValidationCore::VCoreInit( + std::string(GlobalConfig::GetFingerprintListFile()), + std::string(GlobalConfig::GetFingerprintListSchema()), + std::string(GlobalConfig::GetVCoreDatabaseFilePath())); + + InstallerMainThreadSingleton::Instance().AttachDatabases(); + + //checking for correct DB version +// if (!WrtDB::WrtDatabase::CheckTableExist(DB_CHECKSUM_STR)) { +// LogError("WRONG VERSION OF WRT DATABASE"); +// Assert(false && "WRONG VERSION OF WRT DATABASE"); +// return FALSE; +// } + LogWarning("Database check not implemented!"); + + LogInfo("Prepare libxml2 to work in multithreaded program."); + xmlInitParser(); + + // Initialize Language Subtag registry + LanguageSubtagRstTreeSingleton::Instance().Initialize(); +// localizationSetting(); + + // Installer init + CONTROLLER_POST_SYNC_EVENT( + Logic::InstallerController, + InstallerControllerEvents:: + InitializeEvent()); + + // Install deferred widget packages +// CONTROLLER_POST_EVENT( +// Logic::InstallerController, +// InstallerControllerEvents:: +// InstallDeferredWidgetPackagesEvent()); + + if (callback) { + LogInfo("[WRT-API] WRT INSTALLER INITIALIZATION CALLBACK"); + callback(WRT_SUCCESS, userdata); + } + } + catch (const DPL::Exception& ex) + { + LogError("Internal Error during Init:"); + DPL::Exception::DisplayKnownException(ex); + if (callback) { + callback(WRT_ERROR_INTERNAL, userdata); + } + return FALSE; + } + // OK + return TRUE; + } + + EXPORT_API void wrt_installer_shutdown() + { + try + { + LogInfo("[WRT-API] DEINITIALIZING WRT INSTALLER..."); + + // Installer termination + CONTROLLER_POST_SYNC_EVENT( + Logic::InstallerController, + InstallerControllerEvents:: + TerminateEvent()); + + InstallerMainThreadSingleton::Instance().DetachDatabases(); + + // This must be done after DetachDatabase + ValidationCore::VCoreDeinit(); + + // Global deinit check + LogInfo("Cleanup libxml2 global values."); + xmlCleanupParser(); + + } + catch (const DPL::Exception& ex) + { + LogError("Internal Error during Shutdown:"); + DPL::Exception::DisplayKnownException(ex); + } + } + +// EXPORT_API void wrt_install_widget(const char *path, +// void* userdata, +// WrtInstallerStatusCallback status_cb, +// WrtProgressCallback progress_cb, +// wrt_widget_update_mode_t update_mode, +// bool quiet) +// { +// UNHANDLED_EXCEPTION_HANDLER_BEGIN +// { +// LogInfo("[WRT-API] INSTALL WIDGET: " << path); +// // Post installation event +// CONTROLLER_POST_EVENT( +// Logic::InstallerController, +// InstallerControllerEvents::InstallWidgetEvent( +// path, WidgetInstallationStruct( +// InstallerCallbacksTranslate::installFinishedCallback, +// InstallerCallbacksTranslate::installProgressCallback, +// new InstallerCallbacksTranslate::StatusCallbackStruct( +// userdata, status_cb, progress_cb), +// translateWidgetUpdateMode(update_mode), +// quiet))); +// } +// UNHANDLED_EXCEPTION_HANDLER_END +// } +// +// EXPORT_API void wrt_uninstall_widget(int widget_handle, +// void* userdata, +// WrtInstallerStatusCallback status_cb, +// WrtProgressCallback progress_cb) +// { +// UNHANDLED_EXCEPTION_HANDLER_BEGIN +// { +// LogInfo("[WRT-API] UNINSTALL WIDGET: " << widget_handle); +// // Post uninstallation event +// CONTROLLER_POST_EVENT( +// Logic::InstallerController, +// InstallerControllerEvents::UninstallWidgetEvent( +// widget_handle, +// WidgetUninstallationStruct( +// InstallerCallbacksTranslate::uninstallFinishedCallback, +// InstallerCallbacksTranslate::installProgressCallback, +// new InstallerCallbacksTranslate::StatusCallbackStruct( +// userdata, status_cb, progress_cb)))); +// } +// UNHANDLED_EXCEPTION_HANDLER_END +// } + + EXPORT_API void wrt_install_plugin( + const char *pluginDir, + void *user_param, + WrtPluginInstallerStatusCallback status_cb, + WrtProgressCallback progress_cb) + { + UNHANDLED_EXCEPTION_HANDLER_BEGIN + { + LogInfo("[WRT-API] INSTALL PLUGIN: " << pluginDir); + //Private data for status callback + //Resource is free in pluginInstallFinishedCallback + InstallerCallbacksTranslate::PluginStatusCallbackStruct* + callbackStruct = + new InstallerCallbacksTranslate::PluginStatusCallbackStruct( + user_param, status_cb, progress_cb); + + CONTROLLER_POST_EVENT( + Logic::InstallerController, + InstallerControllerEvents::InstallPluginEvent( + std::string(pluginDir), + PluginInstallerStruct( + InstallerCallbacksTranslate:: + pluginInstallFinishedCallback, + InstallerCallbacksTranslate:: + installProgressCallback, callbackStruct))); + } + UNHANDLED_EXCEPTION_HANDLER_END + } + + EXPORT_API void wrt_install_all_plugins( + WrtAllPluginInstalledCallback installed_cb, + void *user_param) + { + UNHANDLED_EXCEPTION_HANDLER_BEGIN + { + std::string installRequest = + std::string(GlobalConfig::GetPluginInstallInitializerName()); + + LogDebug("Install new plugins"); + + Try { + DPL::Semaphore lock(PLUGIN_INSTALL_SEMAPHORE); + } + Catch(DPL::Semaphore::Exception::Base){ + LogError("Failed to create installation lock"); + return; + } + + struct stat tmp; + + if (-1 == stat(installRequest.c_str(), &tmp) || + !S_ISREG(tmp.st_mode)) + { + if (ENOENT == errno) { + LogDebug("Plugin installation not required"); + + LogDebug("Call SetAllinstallPluginCallback"); + installed_cb(user_param); + + DPL::Semaphore::Remove(PLUGIN_INSTALL_SEMAPHORE); + return; + } + LogWarning("Opening installation request file failed"); + } + + std::string PLUGIN_PATH = + std::string(GlobalConfig::GetDevicePluginPath()); + + DIR *dir; + dir = opendir(PLUGIN_PATH.c_str()); + if (!dir) { + DPL::Semaphore::Remove(PLUGIN_INSTALL_SEMAPHORE); + return; + } + + LogInfo("Plugin DIRECTORY IS" << PLUGIN_PATH); + struct dirent* libdir; + + errno = 0; + + std::list pluginsPaths; + + while ((libdir = readdir(dir)) != 0) { + if (strcmp(libdir->d_name, ".") == 0 || + strcmp(libdir->d_name, "..") == 0) + { + continue; + } + + std::string path = PLUGIN_PATH; + path += "/"; + path += libdir->d_name; + + struct stat tmp; + + if (stat(path.c_str(), &tmp) == -1) { + LogError("Failed to open file" << path); + continue; + } + + if (!S_ISDIR(tmp.st_mode)) { + LogError("Not a directory" << path); + continue; + } + + pluginsPaths.push_back(path); + } + + wrt_count_plugin = pluginsPaths.size(); + + FOREACH(it, pluginsPaths) { + wrt_plugin_data *plugin_data = new wrt_plugin_data; + + plugin_data->plugin_installed_cb = installed_cb; + plugin_data->plugin_path = const_cast(it->c_str()); + plugin_data->user_data = user_param; + + wrt_install_plugin( + it->c_str(), static_cast(plugin_data), + plugin_install_status_cb, + plugin_install_progress_cb); + } + + if (-1 == TEMP_FAILURE_RETRY(closedir(dir))) { + LogError("Failed to close dir: " << dir); + } + + if (0 != unlink(installRequest.c_str())) { + LogError("Failed to remove file initializing plugin " + "installation"); + } + + Try { + DPL::Semaphore::Remove(PLUGIN_INSTALL_SEMAPHORE); + } + Catch(DPL::Semaphore::Exception::Base){ + LogInfo("Failed to remove installation lock"); + } + } + UNHANDLED_EXCEPTION_HANDLER_END + } + + EXPORT_API int wrt_installer_init_for_tests(void *userdata, + WrtInstallerInitCallback callback) + { + // Set DPL/LOG MID + DPL::Log::LogSystemSingleton::Instance().SetTag("WRT"); + + try + { + LogInfo("[WRT-API] INITIALIZING WRT INSTALLER..."); + LogInfo("[WRT-API] BUILD: " << __TIMESTAMP__); + + // Touch InstallerController Singleton + InstallerMainThreadSingleton::Instance(). + TouchArchitectureOnlyInstaller(); + + // Check paths + if (!checkPaths()) { + if (callback) { + callback(WRT_ERROR_NO_PATH, userdata); + } + return TRUE; + } + + CONTROLLER_POST_SYNC_EVENT( + Logic::InstallerController, + InstallerControllerEvents:: + InitializeEvent()); + + if (callback) { + LogInfo("[WRT-API] WRT INSTALLER INITIALIZATION CALLBACK"); + callback(WRT_SUCCESS, userdata); + } + } + catch (const DPL::Exception& ex) + { + LogError("Internal Error during Init:"); + DPL::Exception::DisplayKnownException(ex); + if (callback) { + callback(WRT_ERROR_INTERNAL, userdata); + } + return FALSE; + } + + // OK + return TRUE; + } + + EXPORT_API void wrt_installer_shutdown_for_tests() + { + try + { + LogInfo("[WRT-API] DEINITIALIZING WRT INSTALLER..."); + + // Installer termination + CONTROLLER_POST_SYNC_EVENT( + Logic::InstallerController, + InstallerControllerEvents:: + TerminateEvent()); + + // Global deinit check + LogInfo("Cleanup libxml2 global values."); + xmlCleanupParser(); + } + catch (const DPL::Exception& ex) + { + LogError("Internal Error during Shutdown:"); + DPL::Exception::DisplayKnownException(ex); + } + } + + EXPORT_API WrtErrStatus wrt_get_widget_by_pkgname(const std::string pkgname, + int *widget_handle) + { + try + { + LogInfo("[WRT-API] GETTING WIDGET HANDLE BY PKG NAME : " + << pkgname); + + WidgetHandle handle = WidgetDAOReadOnly::getHandle( + DPL::FromASCIIString(pkgname)); + *widget_handle = static_cast(handle); + return WRT_SUCCESS; + } + catch (WidgetDAOReadOnly::Exception::WidgetNotExist) + { + LogError("Error package name is not found"); + return WRT_ERROR_PKGNAME_NOT_FOUND; + } + catch (const DPL::Exception& ex) + { + LogError("Internal Error during get widget id by package name"); + DPL::Exception::DisplayKnownException(ex); + return WRT_ERROR_INTERNAL; + } + } + + EXPORT_API WrtErrStatus wrt_get_widget_by_guid(const std::string guid, + int *widget_handle) + { + try + { + LogInfo("[WRT-API] GETTING WIDGET HANDLE BY WidgetID : " + << guid); + + WidgetGUID widget_guid = DPL::FromUTF8String(guid); + WidgetHandle handle = WidgetDAOReadOnly::getHandle(widget_guid); + *widget_handle = static_cast(handle); + return WRT_SUCCESS; + } + catch (WidgetDAOReadOnly::Exception::WidgetNotExist) + { + LogError("Error package name is not found"); + return WRT_ERROR_PKGNAME_NOT_FOUND; + } + catch (const DPL::Exception& ex) + { + LogError("Internal Error during get widget id by package name"); + DPL::Exception::DisplayKnownException(ex); + return WRT_ERROR_INTERNAL; + } + } +#ifdef __cplusplus +} +#endif diff --git a/src/plugins-installer/wrt-installer/wrt_installer_api.h b/src/plugins-installer/wrt-installer/wrt_installer_api.h new file mode 100755 index 0000000..8d8a814 --- /dev/null +++ b/src/plugins-installer/wrt-installer/wrt_installer_api.h @@ -0,0 +1,338 @@ +/* + * 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 wrt_installer_api.h + * @author Chung Jihoon (jihoon.chung@samsung.com) + * @version 1.0 + * @brief This file contains declarations of wrt_installer_api + */ + +/* + * @defgroup wrt_engine_group WebRunTime engine Library + * @ingroup internet_FW + * Functions to APIs to access wrt-engine + */ + +#ifndef WRT_INSTALLER_API_H_ +#define WRT_INSTALLER_API_H_ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Callback function type invoked after async init function + */ +typedef void (*WrtInstallerInitCallback)(WrtErrStatus status, + void *data); + +/** + * Callback function type invoked after async functions + */ +typedef void (*WrtPluginInstallerStatusCallback)(WrtErrStatus status, + void *data); + +/** + * Callback function type invoked after async functions + */ +typedef void (*WrtInstallerStatusCallback)(int widget_handle, + WrtErrStatus status, + void *data); + +/** + * Callback function type invoked after async functions + */ +typedef void (*WrtProgressCallback)(float percent, + const char *description, + void *data); + +/** + * Callback function type invoked when all plugin installations are finished + */ +typedef void (*WrtAllPluginInstalledCallback)(void *userdata); + +typedef struct +{ + WrtAllPluginInstalledCallback plugin_installed_cb; + char *plugin_path; + void *user_data; +} wrt_plugin_data; + +/** + * @fn int wrt_installer_init(void *userdata, WrtInstallerInitCallback callback) + * @brief Initializes WRT + * + * This method is used to initialize wrt-engine. + * It connects to database, initializes webkit, widget and plugin logic. + * + * @param [in] userdata - User parameters to be passed to the callback + * @param [in] callback - The callback function that is launched, after + * wrt initialization. + * The callback is called in the context of the + * application's main loop. + * + * @return 0 on success, -1 on failure + * + * Sample code: + * @code + * int main (int argc, char *argv[]) + * { + * init_loop(argc, argv); + * printf("Initializing WRT"); + * wrt_init(NULL, &init_cb); + * + * wait_for_wrt_init(); + * printf("Starting tests"); + * + * int status = DPL_TestRunnerSingleton_Instance().ExecTestRunner(argc, + * argv); + * + * wrt_installer_shutdown(); + * quit_loop(); + * return status; + * } + * @endcode + * + * @see wrt_installer_shutdown + */ +typedef enum wrt_widget_install_mode_e +{ + /** + * Raw install bit flags + */ + WRT_WIM_NOT_INSTALLED = (1 << 0), + WRT_WIM_INCOMING_VERSION_NOT_STD = (1 << 1), + WRT_WIM_EXISTING_VERSION_NOT_STD = (1 << 2), + WRT_WIM_BOTH_VERSIONS_NOT_STD = (1 << 3), + WRT_WIM_EXISTING_VERSION_OLDER = (1 << 4), + WRT_WIM_EXISTING_VERSION_EQUAL = (1 << 5), + WRT_WIM_EXISTING_VERSION_NEWER = (1 << 6), + + /** + * Update default policies + */ + + /* Never update policy + */ + WRT_WIM_POLICY_NEVER_UPDATE = WRT_WIM_NOT_INSTALLED, + + /* WAC update policy + */ + WRT_WIM_POLICY_WAC = WRT_WIM_NOT_INSTALLED | + WRT_WIM_EXISTING_VERSION_OLDER, + + /* Always update policy + */ + WRT_WIM_POLICY_ALWAYS_INSTALL = WRT_WIM_NOT_INSTALLED | + WRT_WIM_INCOMING_VERSION_NOT_STD | + WRT_WIM_EXISTING_VERSION_NOT_STD | + WRT_WIM_BOTH_VERSIONS_NOT_STD | + WRT_WIM_EXISTING_VERSION_OLDER | + WRT_WIM_EXISTING_VERSION_EQUAL | + WRT_WIM_EXISTING_VERSION_NEWER, + + /* Force install policy + */ + WRT_WIM_POLICY_FORCE_INSTALL = WRT_WIM_POLICY_ALWAYS_INSTALL +} wrt_widget_update_mode_t; + +int wrt_installer_init(void *userdata, + WrtInstallerInitCallback callback); + +/** + * @fn void wrt_installer_shutdown(void) + * @brief Deinitializes WRT + * + * This method is used to deinitialize wrt-engine. + * It deinitializes widget logic, plugin logic, shuts down connection to + * database, switchs back to single thread and does deinit checks. + * + * @return nothing + * + * Sample code: + * @code + * int main (int argc, char *argv[]) + * { + * init_loop(argc, argv); + * printf("Initializing WRT"); + * wrt_init(NULL, &init_cb); + * + * wait_for_wrt_init(); + * printf("Starting tests"); + * + * int status = DPL_TestRunnerSingleton_Instance().ExecTestRunner(argc, + * argv); + * + * wrt_installer_shutdown(); + * quit_loop(); + * return status; + * } + * @endcode + * + * @see wrt_init + */ +void wrt_installer_shutdown(void); + +/** + * @fn void wrt_install_widget(const char *widget_package_path, + * void *user_parameter, + * WrtInstallerStatusCallback status_callback, + * WrtProgressCallback progress_callback, + * wrt_widget_update_mode_t update_mode); + * + * @brief Installs widget from given path + * + * This method is used to install widget from a given path. + * + * @param [in] widget_package_path Path of the widget package. + * @param [in] user_parameter User parameters to be passed to the callback + * @param [in] status_cb Call to this one will be done at the end of + * operation + * The callback is called in the context of the + * application's + * @param [in] progress_cb Callback function to get data of install + * progress + * If you don't want to get progress data, this + * should be NULL + * @param [in] install_mode Installation mode + * @return Nothing (status returned in callback). + * + * Sample code: + * @code + * wrt_install_widget(path.c_str(), + * NULL, + * install_cb, + * progress_cb, + * WRT_WIM_POLICY_WAC); + * @endcode + * + * @see wrt_installer_uninstall_widget + */ +void wrt_install_widget(const char *path, + void *user_parameter, + WrtInstallerStatusCallback status_callback, + WrtProgressCallback progress_callback, + wrt_widget_update_mode_t update_mode, + bool quiet); + +/** + * @fn void wrt_installer_uninstall_widget (int widget_handle, + * void* userdata, + * WrtInstallerStatusCallback cb) + * @brief Uninstalls widget using its id + * + * This method is used to uninstall the widget specified by its handle. + * The callback function is called when the uninstall operation is done. + * + * @param [in] widget_handle - widget id + * @param [in] userdata - user parameters to be passed to the callback + * @param [in] status_cb - Call to this one will be done at the end of + * operation + * The callback is called in the context of the + application's + * @param [in] progress_cb - Callback function to get data of install progress + * If you don't want to get progress data, this + * should be NULL + * + * @return nothing (status returned in callback). + * + * Sample code: + * @code //TODO SAMPLE + * wrt_installer_uninstall_widget( appId, NULL, uninstall_cb, progress_cb); + * @endcode + * + * @see wrt_installer_install_widget + */ +void wrt_uninstall_widget (int widget_handle, + void* userdata, + WrtInstallerStatusCallback status_cb, + WrtProgressCallback progress_cb); + +/** + * @fn void wrt_install_plugin(const char *pluginDirectory, + * void *userData, + * WrtInstallerStatusCallback statusCallback, + * WrtProgressCallback progressCallback) + * + * @brief Installs plugin from given path + * + * This method installs new plugin from specified location and calls a callback + * function when the operation is done. + * + * @param [in] pluginDirectory - plugin directory + * @param [in] userData - user parameters to be passed to the callback + * @param [in] statusCallback - user callback to call after installation + * @param [in] progressCallback - user callback to call when plugin + * installation progress has changed + * + * @return nothing (status returned in callback). + * + * Sample code: + * @code + * wrt_install_plugin("/usr/lib/wrt-plugins/",NULL,NULL,NULL); + * @endcode + * + * @see wrt_install_plugin + */ +void wrt_install_plugin(const char *pluginDirectory, + void *userData, + WrtPluginInstallerStatusCallback statusCallback, + WrtProgressCallback progressCallback); + +/** + * @brief To install plugins for first excution + * + * This method install plugins + * + * @return nothing + */ +void wrt_install_all_plugins(WrtAllPluginInstalledCallback installed_cb, + void *user_param); + +/** + * @brief To initialize for tests + * + * This method is wrt init for tests + * + * @return int + */ +int wrt_installer_init_for_tests(void *userdata, + WrtInstallerInitCallback callback); + +/** + * @brief To shutdown for tests + * + * This method is wrt shutdown for tests + * + * @return int + */ +void wrt_installer_shutdown_for_tests(); + +WrtErrStatus wrt_get_widget_by_pkgname(const std::string pkgname, + int *widget_handle); + +WrtErrStatus wrt_get_widget_by_guid(const std::string guid, + int *widget_handle); +#ifdef __cplusplus +} +#endif + +#endif /* WRT_INSTALLER_API_H_ */ diff --git a/src/plugins-installer/wrt-installer/wrt_type.h b/src/plugins-installer/wrt-installer/wrt_type.h new file mode 100755 index 0000000..9bc27c0 --- /dev/null +++ b/src/plugins-installer/wrt-installer/wrt_type.h @@ -0,0 +1,255 @@ +/* + * 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 wrt_type.h + * @author jihoon Chung (jihoon.Chung@samsung.com) + * @version 1.0 + * @brief This file contains declarations of wrt api + */ + +/* + * @defgroup wrt_engine_group WebRunTime engine Library + * @ingroup internet_FW + * Functions to APIs to access wrt-engine + */ + +#ifndef WRT_TYPE_H_ +#define WRT_TYPE_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define WRT_DEPRECATED __attribute__((deprecated)) + +typedef enum +{ + /* Generic success */ + WRT_SUCCESS = 0, /*< Success*/ + WRT_ALREADY_INIT, /*< Wrt already initialized*/ + WRT_UPDATE_NEED, /*< Widget data has been updated*/ + WRT_SHUTDOWN, /*InstallAllPlugins(); + * + * if (This->m_argc == 2) + * wrt_install_widget(This->m_argv[1], This, InstallCallback); + * } + * else if(wrt_has_failed(status)) + * printf("[LAUNCH-WIDGET] INITIALIZATION HAS FAILED"); + * } + * @endcode + * + * @see wrt_has_failed + */ +inline bool wrt_has_succeded(WrtErrStatus err) +{ + return (err >= 0); +} + +/** + * @fn inline bool wrt_has_failed(WrtErrStatus err) + * @brief Checks whether call failed + * + * This function checks whether call failed. + * If call failed it returns TRUE. + * + * @param [in] err WrtErrStatus to check + * + * @return Result of the test + * @retval TRUE - the call failed + * @retval FALSE - the call was successful + * + * Sample code: + * @code + * static void InitCallback(WrtErrStatus status, void *data) + * { + * MyApplication *This = (MyApplication *)(data); + * + * printf("[LAUNCH-WIDGET] init callback"); + * + * if (wrt_has_succeded(status) && status!=WRT_UPDATE_NEED) + * { + * This->InstallAllPlugins(); + * + * if (This->m_argc == 2) + * wrt_install_widget(This->m_argv[1], This, InstallCallback); + * } + * else if(wrt_has_failed(status)) + * printf("[LAUNCH-WIDGET] INITIALIZATION HAS FAILED"); + * } + * @endcode + * + * @see wrt_has_succeded + */ +inline bool wrt_has_failed(WrtErrStatus err) +{ + return (err < 0); +} + +namespace CommonError { +enum Type +{ + WrtSuccess, ///< Success + + HandleNotFound, ///< Widget handle was not found + AlreadyRunning, ///< Widget is already running + AlreadyStopped, ///< Widget is already stopped + InvalidLanguage, ///< Widget is invalid in current locales + StillAuthorizing, ///< Widget is still autorizing and has not yet finished it + EarlyKilled, ///< Widget was early killed during launch + AccessDenied, ///< Access denied from ACE + CertificateRevoked, ///< Some certificate was revoked. + /// Widget is not allowed to run. + + Unknown ///< Temporary error. Try to not use this. +}; +} + +#ifdef __cplusplus +} +#endif + +#endif /* WRT_TYPE_H_ */ diff --git a/src/standards/W3C/Widget/JSWidget.cpp b/src/standards/W3C/Widget/JSWidget.cpp index 3f3f8c3..fdb70ba 100644 --- a/src/standards/W3C/Widget/JSWidget.cpp +++ b/src/standards/W3C/Widget/JSWidget.cpp @@ -134,10 +134,7 @@ WrtDeviceApis::Widget::Api::IWidgetPtr getIWidget(JSObjectRef arg) LocalStorage::Api::ILocalStoragePtr getLocalStorage(int widgetId) { - static int id = widgetId; - Assert(id == widgetId && "SPA is not longer supported"); - - static LocalStorage::Api::ILocalStoragePtr storage( + LocalStorage::Api::ILocalStoragePtr storage( LocalStorage::Api::getLocalStorage(widgetId)); return storage; diff --git a/src/wrt-popup/CMakeLists.txt b/src/wrt-popup/CMakeLists.txt new file mode 100755 index 0000000..2ecd23d --- /dev/null +++ b/src/wrt-popup/CMakeLists.txt @@ -0,0 +1,2 @@ +ADD_SUBDIRECTORY(popup-bin) +ADD_SUBDIRECTORY(popup-runner) diff --git a/src/wrt-popup/popup-bin/CMakeLists.txt b/src/wrt-popup/popup-bin/CMakeLists.txt new file mode 100644 index 0000000..4c2b381 --- /dev/null +++ b/src/wrt-popup/popup-bin/CMakeLists.txt @@ -0,0 +1,64 @@ +# 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 CMakeLists.txt +# @author Janusz Kozerski (j.kozerski@samsung.com) +# +# @version 1.0 +# + +PKG_CHECK_MODULES(WRT_POPUP_DEP + dpl-efl + elementary + security-client + security-popup-validation + REQUIRED) + +set(WRT_POPUP_SRC_DIR ${PROJECT_SOURCE_DIR}/src/wrt-popup/popup-bin) + +set(WRT_POPUP_SOURCES + ${WRT_POPUP_SRC_DIR}/Popup.cpp +) + +ADD_DEFINITIONS(${WRT_POPUP_DEP_CFLAGS}) + +INCLUDE_DIRECTORIES( + ${WRT_POPUP_SRC_DIR} + ${WRT_POPUP_DEP_INCLUDE_DIRS} +) + +ADD_EXECUTABLE(${TARGET_WRT_POPUP} + ${WRT_POPUP_SOURCES} +) + +SET_TARGET_PROPERTIES(${TARGET_WRT_POPUP} PROPERTIES + COMPILE_FLAGS -fPIC +) + +SET_TARGET_PROPERTIES(${TARGET_WRT_POPUP} PROPERTIES + #LINK_FLAGS "-Wl,--as-needed -Wl" + SOVERSION ${PROJECT_API_VERSION} + VERSION ${PROJECT_VERSION} +) + +target_link_libraries(${TARGET_WRT_POPUP} + ${WRT_POPUP_DEP_LIBRARIES} + ${TARGET_WRT_POPUP_RUNNER_LIB} + ${WRT_POPUP_DEP_LDFLAGS} +) + +INSTALL(TARGETS ${TARGET_WRT_POPUP} + DESTINATION bin +) diff --git a/src/wrt-popup/popup-bin/Popup.cpp b/src/wrt-popup/popup-bin/Popup.cpp new file mode 100644 index 0000000..cbeec8d --- /dev/null +++ b/src/wrt-popup/popup-bin/Popup.cpp @@ -0,0 +1,406 @@ +/* + * 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 Popup.c + * @author Janusz Kozerski (j.kozerski@samsung.com) + * @version 1.0 + */ + +/* + * This is just a example pop-up that shows how to use a new C-API in wrt-security. + * This pop-up should be re-implemented by members of NGWAP. + */ + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +#include "popup-runner.h" +#include "Popup.h" + +namespace { // anonymous + +static void set_validity_from_checkbox(struct ace_popup_data *pdp) { + + if(NULL == pdp){ + LogError("pdp is NULL; return"); + return; + } + + if (pdp->always) { + LogDebug("Remember ALWAYS"); + pdp->remember_choice = ACE_ALWAYS; + return; + } + if (pdp->per_session) { + LogDebug("Remember PER_SESSION"); + pdp->remember_choice = ACE_PER_SESSION; + return; + } + LogDebug("Remember ONCE"); + pdp->remember_choice = ACE_ONCE; + return; +} + +static void on_done(void) { + // Quit the efl-mainloop + LogDebug("elm_exit()"); + elm_exit(); +} + +static void grant_answer(void *data, Evas_Object * /* obj */, void * /* event_info */) { + + LogDebug("grant_answer"); + if(NULL == data){ + LogError("data is NULL; return"); + return; + } + struct ace_popup_data *pdp = static_cast (data); + + set_validity_from_checkbox(pdp); + + ace_popup_validation_initialize(); + pdp->validation_return = ace_validate_answer( + ACE_TRUE, + pdp->remember_choice, + pdp->resource_name, + pdp->session_id, + &(pdp->param_list), + pdp->handle, + &(pdp->validation_result)); + ace_popup_validation_shutdown(); + + on_done(); +} + +static void deny_answer(void *data, Evas_Object * /* obj */, void * /* event_info */) { + + LogDebug("deny_answer"); + if(NULL == data){ + LogError("data is NULL; return"); + return; + } + struct ace_popup_data *pdp = static_cast (data); + + set_validity_from_checkbox(pdp); + + ace_popup_validation_initialize(); + pdp->validation_return = ace_validate_answer( + ACE_FALSE, + pdp->remember_choice, + pdp->resource_name, + pdp->session_id, + &(pdp->param_list), + pdp->handle, + &(pdp->validation_result)); + ace_popup_validation_shutdown(); + + on_done(); +} + +static int _ace_params_deserializer(ace_param_list_t* ace_param_list, Wrt::Popup::BinaryStream *stream){ + + LogDebug("_ace_params_deserializer"); + + if(NULL == ace_param_list || NULL == stream){ + LogError("ace_param_list or stream is NULL; return -1"); + return -1; + } + + // deserialize ace_param_list->count; + size_t count = 0; + DPL::Deserialization::Deserialize(*stream, count); + ace_param_list->count = count; + LogDebug("count : " << count); + + std::string name; + std::string value; + if(count == 0){ + ace_param_list->items = NULL; + return 0; + } + ace_param_list->items = static_cast (malloc(count * sizeof(ace_param_t))); + + for(size_t i=0; i < count; ++i){ + DPL::Deserialization::Deserialize(*stream, name); + ace_param_list->items[i].name = const_cast (name.c_str()); + + DPL::Deserialization::Deserialize(*stream, value); + ace_param_list->items[i].value = const_cast (value.c_str()); + } + return 0; +} + +static void show_popup(struct ace_popup_data *pdp) { + LogDebug("show_popup()"); + + if(NULL == pdp){ + LogError("pdp is NULL; return"); + return; + } + + const char *resource_type = static_cast (pdp->resource_name); + + Evas_Object *win = NULL; + Evas_Object *cb_session = NULL; + Evas_Object *cb_always = NULL; + Evas_Object *box = NULL; + Evas_Object *label = NULL; + Evas_Object *grant_button = NULL; + Evas_Object *deny_button = NULL; + pdp->per_session = EINA_FALSE; + pdp->always = EINA_FALSE; + + win = elm_win_add(NULL, "The wrt-client popup", ELM_WIN_NOTIFICATION); + elm_win_autodel_set(win, EINA_TRUE); + elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED); + evas_object_show(win); + elm_win_indicator_opacity_set(win, ELM_WIN_INDICATOR_TRANSLUCENT); + + pdp->popup = elm_popup_add(win); + + box = elm_box_add(pdp->popup); + evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, 0); + evas_object_size_hint_align_set(box, EVAS_HINT_FILL, 0.0); + + label = elm_label_add(pdp->popup); + elm_object_style_set(label, "popup_description/default"); + elm_label_line_wrap_set(label, ELM_WRAP_MIXED); + char *buff = NULL; + if(-1 == asprintf(&buff, "Application need an access to %s.
Grant or deny?", resource_type)){ + LogError("asprintf failed - returned -1"); + evas_object_del(label); + evas_object_del(pdp->popup); + evas_object_del(win); + return; + } + elm_object_text_set(label, buff); + free(buff); + evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0); + evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(label); + elm_box_pack_end(box, label); + + LogDebug("popup_type == " << pdp->popup_type); + if (pdp->popup_type == ACE_SESSION || pdp->popup_type == ACE_BLANKET) { + LogDebug("popup_type == ACE_SESSION || ACE_BLANKET"); + cb_session = elm_check_add(pdp->popup); + elm_object_text_set(cb_session, "Remember choice for this session"); + elm_check_state_pointer_set(cb_session, &(pdp->per_session)); + evas_object_smart_callback_add(cb_session, "changed", NULL, NULL); + evas_object_size_hint_align_set(cb_session, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_size_hint_weight_set(cb_session, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_show(cb_session); + elm_box_pack_end(box, cb_session); + + if (pdp->popup_type == ACE_BLANKET) { + LogDebug("popup_type == ACE_BLANKET"); + cb_always = elm_check_add(pdp->popup); + elm_object_text_set(cb_always, "Remember choice forever"); + elm_check_state_pointer_set(cb_always, &(pdp->always)); + evas_object_smart_callback_add(cb_always, "changed", NULL, NULL); + evas_object_size_hint_align_set(cb_always, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_size_hint_weight_set(cb_always, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_show(cb_always); + elm_box_pack_end(box, cb_always); + } + } + + elm_object_part_content_set(pdp->popup, "default", box); + + grant_button = elm_button_add(pdp->popup); + elm_object_text_set(grant_button, "Grant"); + elm_object_part_content_set(pdp->popup, "button1", grant_button); + evas_object_smart_callback_add(grant_button, "clicked", grant_answer, pdp); + + deny_button = elm_button_add(pdp->popup); + elm_object_text_set(deny_button, "Deny"); + elm_object_part_content_set(pdp->popup, "button2", deny_button); + evas_object_smart_callback_add(deny_button, "clicked", deny_answer, pdp); + + evas_object_show(pdp->popup); + + // Showing the popup window + evas_object_show(win); + + // Run the efl mainloop + elm_run(); +} + +} // anonymous + + +EAPI_MAIN int +elm_main(int argc , char ** argv) +{ +// int pipe_in and int pipe_out should be passed to Popup via args. + +// These parameters should be passed to Popup via pipe: +// ace_popup_t popup_type +// const ace_resource_t resource_name +// const ace_session_id_t session_id +// ace_widget_handle_t handle +// const ace_param_list_t param_list + + + DPL::Log::LogSystemSingleton::Instance().SetTag("WRT-POPUP-BIN"); + LogDebug("############################ popup binary ################################"); + + if(argc < 3){ + LogError("To few args passed in exec to popup-bin - should be at least 3:"); + LogError("(binary-name, pipe_in, pipe_out)"); + LogError("return ACE_INTERNAL_ERROR"); + return ACE_INTERNAL_ERROR; + } + LogDebug("Passed args: " << argv[0] <<", " << argv[1] << ", " << argv[2]); + + int pipe_in; + int pipe_out; + + // Parsing args (pipe_in, pipe_out) + if ( 0 == sscanf(argv[1], "%d", &pipe_in) ){ + LogError("Error while parsing pipe_in; return ACE_INTERNAL_ERROR"); + return ACE_INTERNAL_ERROR; + } + if ( 0 == sscanf(argv[2], "%d", &pipe_out) ){ + LogError("Error while parsing pipe_out; return ACE_INTERNAL_ERROR"); + return ACE_INTERNAL_ERROR; + } + LogDebug("Parsed pipes: IN: " << pipe_in <<", OUT: " << pipe_out); + + int buff_size = 1024; + char line[buff_size]; + + struct ace_popup_data pd; + struct ace_popup_data *pdp = &pd; + + pdp->popup = NULL; + + ssize_t count = 0; + time_t time_start; + time(&time_start); // now + double timeout = 10.0; + // try to read parameters from pipe_in + // timeout is set for 10 seconds + do { + count = TEMP_FAILURE_RETRY(read(pipe_in, line, buff_size)); + if ( timeout < difftime(time(NULL), time_start) ) { + LogError("Timeout reached! Exit popup - ACE_INTERNAL_ERROR"); + close(pipe_in); + close(pipe_out); + return ACE_INTERNAL_ERROR; + } + } while (0 == count); + if(count < 0){ + close(pipe_in); + close(pipe_out); + LogError("read returned a negative value (" << count <<")"); + LogError("errno: " << strerror( errno ) ); + LogError("Exit popup - ACE_INTERNAL_ERROR"); + return ACE_INTERNAL_ERROR; + } + LogDebug("Read bytes : " << count << " (in " << difftime(time_start, time(NULL)) << " seconds)"); + close(pipe_in); // cleanup + + Wrt::Popup::BinaryStream stream; + stream.Write(count, static_cast (line)); + int popup_type = ACE_ONESHOT; + std::string resource_name_str; + std::string session_id_str; + int handle = 0; + + LogDebug("------- Deserialization -------"); + // Deserialization order: + // popup_type, resource_name, session_id, handle, param_list + + DPL::Deserialization::Deserialize(stream, popup_type); + LogDebug("popup_type_int : " << popup_type); + pdp->popup_type = static_cast (popup_type); + + DPL::Deserialization::Deserialize(stream, resource_name_str); + LogDebug("resource_name_char : " << resource_name_str.c_str()); + pdp->resource_name = const_cast (resource_name_str.c_str()); + + DPL::Deserialization::Deserialize(stream, session_id_str); + LogDebug("session_id_char : " << session_id_str.c_str()); + pdp->session_id = const_cast (session_id_str.c_str()); + + DPL::Deserialization::Deserialize(stream, handle); + LogDebug("handle_int : " << handle); + pdp->handle = static_cast (handle); + + if(_ace_params_deserializer(&(pdp->param_list), &stream)){ + return ACE_INTERNAL_ERROR; + } + + pdp->per_session = EINA_FALSE; + pdp->always = EINA_FALSE; + pdp->validation_return = ACE_ACE_UNKNOWN_ERROR; + + show_popup(pdp); // Showing popup + + // sending validation_result to popup-runner + Wrt::Popup::BinaryStream stream_out; + + LogDebug("pdp->validation_result : " << pdp->validation_result); + int validation_result_int = (int) pdp->validation_result; + LogDebug("validation_result_int : " << validation_result_int); + DPL::Serialization::Serialize(stream_out, validation_result_int); + if(-1 == TEMP_FAILURE_RETRY(write(pipe_out, stream_out.char_pointer(), stream_out.size()))){ + LogError("Write to pipe failed!"); + close(pipe_out); + return ACE_INTERNAL_ERROR; + } + close(pipe_out); + + if (pdp->validation_return == ACE_OK) { + LogDebug("ACE_OK"); + } + else if (pdp->validation_return == ACE_INVALID_ARGUMENTS) { + LogError("ACE_INVALID_ARGUMENTS"); + } + else if (pdp->validation_return == ACE_INTERNAL_ERROR) { + LogError("ACE_INTERNAL_ERROR"); + } + else if (pdp->validation_return == ACE_ACE_UNKNOWN_ERROR) { + LogError("ACE_ACE_UNKNOWN_ERROR"); + } + else { + LogError("Really unknown error!!!"); + } + + LogDebug("############################ /popup binary ################################"); + + // Shutdown elementary + //LogDebug("elm_shutdown()"); + //elm_shutdown(); + // This is commented because, it causes that popup exits with 139 code (Segmentatation violation). + // Not calling elm_shutdown() should not have any negative consequences because this binary ends + // in next line, and system should clear the memory. + + return pdp->validation_return; +} +ELM_MAIN() diff --git a/src/wrt-popup/popup-bin/Popup.h b/src/wrt-popup/popup-bin/Popup.h new file mode 100644 index 0000000..8c841d6 --- /dev/null +++ b/src/wrt-popup/popup-bin/Popup.h @@ -0,0 +1,39 @@ +/* + * 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 Popup.h + * @author Janusz Kozerski (j.kozerski@samsung.com) + * @version 1.0 + */ + +#include +#include + +struct ace_popup_data { + ace_popup_t popup_type; + ace_resource_t resource_name; + ace_session_id_t session_id; + ace_param_list_t param_list; + ace_widget_handle_t handle; + ace_bool_t validation_result; + ace_return_t validation_return; + + Evas_Object *popup; + Eina_Bool per_session; + Eina_Bool always; + + ace_validity_t remember_choice; +}; diff --git a/src/wrt-popup/popup-runner/CMakeLists.txt b/src/wrt-popup/popup-runner/CMakeLists.txt new file mode 100644 index 0000000..5a45dfe --- /dev/null +++ b/src/wrt-popup/popup-runner/CMakeLists.txt @@ -0,0 +1,65 @@ +# 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 CMakeLists.txt +# @author Janusz Kozerski (j.kozerski@samsung.com) +# +# @version 1.0 +# + +PKG_CHECK_MODULES(WRT_POPUP_RUNNER_LIB_DEP + dpl-efl + elementary + security-client + REQUIRED) + +set(WRT_POPUP_RUNNER_LIB_SRC_DIR ${PROJECT_SOURCE_DIR}/src/wrt-popup/popup-runner) + +set(WRT_POPUP_RUNNER_LIB_SOURCES + ${WRT_POPUP_RUNNER_LIB_SRC_DIR}/popup-runner.cpp +) + +ADD_DEFINITIONS(${WRT_POPUP_RUNNER_LIB_DEP_CFLAGS}) + +INCLUDE_DIRECTORIES( + ${WRT_POPUP_RUNNER_LIB_SRC_DIR} + ${WRT_POPUP_RUNNER_LIB_DEP_INCLUDE_DIRS} +) + +ADD_LIBRARY(${TARGET_WRT_POPUP_RUNNER_LIB} SHARED + ${WRT_POPUP_RUNNER_LIB_SOURCES} +) + +SET_TARGET_PROPERTIES(${TARGET_WRT_POPUP_RUNNER_LIB} PROPERTIES + COMPILE_FLAGS -fPIC +) + +SET_TARGET_PROPERTIES(${TARGET_WRT_POPUP_RUNNER_LIB} PROPERTIES + SOVERSION ${CMAKE_PROJECT_API_VERSION} + VERSION ${CMAKE_PROJECT_VERSION} +) + +target_link_libraries(${TARGET_WRT_POPUP_RUNNER_LIB} + ${WRT_POPUP_RUNNER_LIB_DEP_LIBRARIES} + ${WRT_POPUP_RUNNER_LIB_DEP_LDFLAGS} +) + +INSTALL(TARGETS ${TARGET_WRT_POPUP_RUNNER_LIB} + DESTINATION lib +) + +INSTALL(FILES ${PROJECT_SOURCE_DIR}/src/wrt-popup/popup-runner/popup-runner.h + DESTINATION ${DESTINATION_HEADERS_WRT_POPUP_RUNNER} +) diff --git a/src/wrt-popup/popup-runner/popup-runner.cpp b/src/wrt-popup/popup-runner/popup-runner.cpp new file mode 100644 index 0000000..1551fba --- /dev/null +++ b/src/wrt-popup/popup-runner/popup-runner.cpp @@ -0,0 +1,283 @@ +/* + * 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 popup-runner.cpp + * @author Janusz Kozerski (j.kozerski@samsung.com) + * @version 1.0 + */ + +/* + * This is just a example pop-up that shows how to use a new C-API in wrt-security. + * This pop-up should be re-implemented by members of NGWAP. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "popup-runner.h" + +namespace { // anonymous + +const char *POPUP_EXEC = "/usr/bin/wrt-popup-runtime"; // wrt-popup-runtime + +void _ace_params_serializer (const ace_param_list_t* ace_param_list, Wrt::Popup::BinaryStream *stream){ + + LogDebug("_ace_params_serializer"); + + if(NULL == ace_param_list || NULL == stream){ + LogError("*ace_param_list or *stream is NULL; return"); + return; + } + LogDebug("Param count : " << ace_param_list->count); + + // serialize ace_param_list->count; + size_t count = static_cast (ace_param_list->count); + DPL::Serialization::Serialize(*stream, count); + + for(size_t i=0; i < count; ++i){ + std::string name(ace_param_list->items[i].name); + DPL::Serialization::Serialize(*stream, name); + + std::string value(ace_param_list->items[i].value); + DPL::Serialization::Serialize(*stream, value); + } +} + +} // anonymous namespace + +namespace Wrt{ +namespace Popup{ + +// BinaryStream class implementation +void BinaryStream::Read(size_t num, void * bytes) { + size_t max_size = m_data.size(); + for (size_t i = 0; i < num; ++i) { + if( i + m_readPosition >= max_size){ + return; + } + static_cast (bytes)[i] = m_data[i + m_readPosition]; + } + m_readPosition += num; +} + +void BinaryStream::Write(size_t num, const void * bytes) { + for (size_t i = 0; i < num; ++i) { + m_data.push_back(static_cast (bytes)[i]); + } +} + +BinaryStream::BinaryStream() { + m_readPosition = 0; +} + +BinaryStream::~BinaryStream() { +} + +const unsigned char* BinaryStream::char_pointer() const { + return &m_data[0]; +} + +size_t BinaryStream::size() const { + return m_data.size(); +} +// BinaryStream + +ace_return_t run_popup( + ace_popup_t popup_type, + const ace_resource_t resource_name, + const ace_session_id_t session_id, + const ace_param_list_t* ace_param_list, + ace_widget_handle_t handle, + ace_bool_t* validation_result) +{ + if ( NULL == resource_name || + NULL == session_id || + NULL == ace_param_list || + NULL == validation_result ) + { + LogError("run_popup : ACE_INVALID_ARGUMENTS"); + return ACE_INVALID_ARGUMENTS; + } + LogDebug("popup_type : " << popup_type); + LogDebug("resource_name : " << resource_name); + LogDebug("session_id : " << session_id); + LogDebug("widget handle : " << handle); + + int popup_type_int = static_cast (popup_type); + char *resource_name_char = static_cast (resource_name); + char *session_id_char = static_cast (session_id); + int handle_int = static_cast (handle); + + // serialization + Wrt::Popup::BinaryStream stream; + DPL::Serialization::Serialize(stream, popup_type_int); + + std::string resource_name_str(resource_name_char); + DPL::Serialization::Serialize(stream, resource_name_str); + + std::string session_id_str(session_id_char); + DPL::Serialization::Serialize(stream, session_id_str); + + DPL::Serialization::Serialize(stream, handle_int); + + _ace_params_serializer (ace_param_list, &stream); + + int fd_send_to_child[2]; + int fd_send_to_parent[2]; + pid_t childpid; + + if(0 != pipe(fd_send_to_child)){ + LogError("Cannot create pipes!"); + return ACE_INTERNAL_ERROR; + } + if(0 != pipe(fd_send_to_parent)){ + LogError("Cannot create pipes!"); + return ACE_INTERNAL_ERROR; + } + + if ((childpid = fork()) == -1) { + LogError("Fork() ERROR"); + return ACE_ACE_UNKNOWN_ERROR; + } + + if(childpid == 0) { // Child process + LogDebug("Child"); + + // read data from parent + close(fd_send_to_child[1]); + + // send data to parent + close(fd_send_to_parent[0]); + + std::stringstream pipe_in_buff; + std::stringstream pipe_out_buff; + pipe_in_buff << fd_send_to_parent[1]; + pipe_out_buff << fd_send_to_child[0]; + std::string pipe_in = pipe_in_buff.str(); + std::string pipe_out = pipe_out_buff.str(); + + LogDebug("Passed file descriptors: " << fd_send_to_child[0] << ", "<< fd_send_to_parent[1]); + + if (execl(POPUP_EXEC, POPUP_EXEC, pipe_out.c_str(), pipe_in.c_str(), NULL) < 0){ + LogError("execlp FAILED"); + } + + LogError("This should not happened!!!"); + + } // end of child process - from now you can use DEBUG LOGS + else { // Parent process + LogDebug("Parent"); + + int buff_size = 1024; + char result[buff_size]; + // send data to child + close(fd_send_to_child[0]); + + //writing to child + LogDebug("Sending message to popup-bin process"); + if(-1 == TEMP_FAILURE_RETRY(write(fd_send_to_child[1], stream.char_pointer(), stream.size()))){ + LogError("Write to pipe failed!"); + return ACE_INTERNAL_ERROR; + } + close(fd_send_to_child[1]); // cleanup + LogDebug("Message has been sent"); + + // read data from child + close(fd_send_to_parent[1]); + + int status; + wait(&status); + LogDebug("STATUS EXIT ON POPUP (CHILD): " << status); + switch (status){ + + case ACE_OK: + LogDebug("ACE_OK"); + break; + + case ACE_INVALID_ARGUMENTS: + LogDebug("ACE_INVALID_ARGUMENTS"); + close(fd_send_to_parent[0]); + return static_cast (status); + break; + + case ACE_INTERNAL_ERROR: + LogDebug("ACE_INTERNAL_ERROR"); + close(fd_send_to_parent[0]); + return static_cast (status); + break; + + case ACE_ACE_UNKNOWN_ERROR: + LogDebug("ACE_ACE_UNKNOWN_ERROR"); + close(fd_send_to_parent[0]); + return static_cast (status); + break; + + default: + LogDebug("UNKNOWN_ERROR"); + close(fd_send_to_parent[0]); + status = (int) ACE_ACE_UNKNOWN_ERROR; + return static_cast (status); + break; + } + + int count; + count = TEMP_FAILURE_RETRY(read(fd_send_to_parent[0], result, buff_size)); + close(fd_send_to_parent[0]); // cleanup + int validation_result_int; + + if(0 < count){ + BinaryStream stream_in; + stream_in.Write(count, result); + LogDebug("RESULT FROM POPUP (CHILD) : [ " << count << " ]"); + DPL::Deserialization::Deserialize(stream_in, validation_result_int); + *validation_result = static_cast (validation_result_int); + + LogDebug("validation_result :"); + switch (*validation_result){ + case ACE_FALSE: + LogDebug("ACE_FALSE"); + break; + case ACE_TRUE: + LogDebug("ACE_TRUE"); + break; + default: + LogDebug("UNKNOWN - DEFAULT"); + break; + } + } + else { + LogDebug("count = " << count); + LogDebug("UNKNOWN_ERROR"); + return ACE_ACE_UNKNOWN_ERROR; + } + + LogDebug("popup-runner: EXIT"); + return (ace_return_t) status; + } + + LogError("This should not happend!!!"); + return ACE_ACE_UNKNOWN_ERROR; +} + +} // Popup +} // Wrt diff --git a/src/wrt-popup/popup-runner/popup-runner.h b/src/wrt-popup/popup-runner/popup-runner.h new file mode 100644 index 0000000..9da8c38 --- /dev/null +++ b/src/wrt-popup/popup-runner/popup-runner.h @@ -0,0 +1,56 @@ +/* + * 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 popup-runner.h + * @author Janusz Kozerski (j.kozerski@samsung.com) + * @version 1.0 + */ + +#include +#include + +#include + +namespace Wrt{ +namespace Popup{ + +class BinaryStream : public DPL::IStream { + public: + void Read (size_t num, void * bytes); + void Write(size_t num, const void * bytes); + + BinaryStream(); + ~BinaryStream(); + + const unsigned char* char_pointer() const; + size_t size() const; + + private: + std::vector m_data; + size_t m_readPosition; +}; + +ace_return_t run_popup( + ace_popup_t popup_type, + const ace_resource_t resource_name, + const ace_session_id_t session_id, + const ace_param_list_t* ace_param_list, + ace_widget_handle_t handle, + ace_bool_t* validation_result + ); + +} // Popup +} // Wrt diff --git a/wrt-plugins-common.manifest b/wrt-plugins-common.manifest new file mode 100644 index 0000000..f717929 --- /dev/null +++ b/wrt-plugins-common.manifest @@ -0,0 +1,11 @@ + + + + + + + + + + -- 2.7.4