Parse legacy splash screens

Parse legacy splash screens from:
 - ui-application's attributes
 - metadata

Submit with:
 - https://review.tizen.org/gerrit/102617

Change-Id: I6289e1e4798be7111c1f284c50926f2831347600
Signed-off-by: Sangyoon Jang <s89.jang@samsung.com>

diff --git a/src/common/step/configuration/step_parse_manifest.cc b/src/common/step/configuration/step_parse_manifest.cc
index 15ebe20d5dc7543872813e14326e851ab0abf3dd..02867346733d6326a47842e673420a8acd2f5330 100644 (file)
--- a/src/common/step/configuration/step_parse_manifest.cc
+++ b/src/common/step/configuration/step_parse_manifest.cc
@@ -4,6 +4,8 @@
 
 #include "common/step/configuration/step_parse_manifest.h"
 
+#include <boost/tokenizer.hpp>
+
 #include <pkgmgr/pkgmgr_parser.h>
 #include <pkgmgr-info.h>
 
@@ -48,8 +50,15 @@ namespace {
 
 const char kManifestFileName[] = "tizen-manifest.xml";
 const char kInstalledInternally[] = "installed_internal";
+const char kPortraitOrientation[] = "portrait";
+const char kLandscapeOrientation[] = "landscape";
+const char kOperationEffectKey[] = "operation_effect";
+const char kLaunchEffectKey[] = "launch_effect";
+const char kPortraitEffectImageValue[] = "portrait-effectimage";
+const char kLandscapeEffectImageValue[] = "landscape-effectimage";
+const char kIndicatorDisplayValue[] = "indicatordisplay";
 
-}  // namepsace
+}  // namespace
 
 namespace common_installer {
 namespace configuration {
@@ -525,12 +534,20 @@ bool StepParseManifest::FillUIApplication(manifest_x* manifest) {
     if (!application.app_info.effectimage_type().empty())
       ui_app->effectimage_type =
           strdup(application.app_info.effectimage_type().c_str());
-    if (!application.app_info.portrait_image().empty())
+    if (!application.app_info.portrait_image().empty()) {
       ui_app->portraitimg =
           strdup(application.app_info.portrait_image().c_str());
-    if (!application.app_info.landscape_image().empty())
+      AppendSplashScreen(ui_app, application.app_info.portrait_image(),
+          application.app_info.effectimage_type(), {}, kPortraitOrientation,
+          application.app_info.indicator_display(), {}, {});
+    }
+    if (!application.app_info.landscape_image().empty()) {
       ui_app->landscapeimg =
           strdup(application.app_info.landscape_image().c_str());
+      AppendSplashScreen(ui_app, application.app_info.portrait_image(),
+          application.app_info.effectimage_type(), {}, kLandscapeOrientation,
+          application.app_info.indicator_display(), {}, {});
+    }
     ui_app->submode_mainid =
         strdup(application.app_info.submode_mainid().c_str());
     ui_app->hwacceleration =
@@ -762,6 +779,8 @@ bool StepParseManifest::FillMetadata(application_x* app,
     metadata->key = strdup(meta.key().c_str());
     metadata->value = strdup(meta.val().c_str());
     app->metadata = g_list_append(app->metadata, metadata);
+
+    GetLegacySplashScreenFromMetadata(app, meta.key(), meta.val());
   }
   return true;
 }
@@ -793,41 +812,103 @@ bool StepParseManifest::FillCategories(application_x* manifest,
   return true;
 }
 
+void StepParseManifest::AppendSplashScreen(application_x* app,
+    const std::string& src, const std::string& type, const std::string& dpi,
+    const std::string& orientation, const std::string& indicatordisplay,
+    const std::string& operation, const std::string& color_depth) {
+  splashscreen_x* splashscreen =
+      static_cast<splashscreen_x*>(calloc(1, sizeof(splashscreen_x)));
+  if (bf::path(src).is_absolute()) {
+    splashscreen->src = strdup(src.c_str());
+  } else {
+    bf::path full_path = context_->pkg_path.get() / src;
+    splashscreen->src = strdup(full_path.string().c_str());
+  }
+  if (src.substr(src.find_last_of(".") + 1) == "edj")
+    splashscreen->type = strdup("edj");
+  else if (type == "edj")
+    splashscreen->type = strdup("edj");
+  else
+    splashscreen->type = strdup("img");
+  if (!dpi.empty())
+    splashscreen->dpi = strdup(dpi.c_str());
+  splashscreen->orientation = strdup(orientation.c_str());
+  if (!indicatordisplay.empty())
+    splashscreen->indicatordisplay = strdup(indicatordisplay.c_str());
+  else
+    splashscreen->indicatordisplay = strdup("true");
+  if (operation == "launch_effect")
+    splashscreen->operation = strdup("launch-effect");
+  else if (!operation.empty())
+    splashscreen->operation = strdup(operation.c_str());
+  else
+    splashscreen->operation = strdup("launch-effect");
+  if (!color_depth.empty())
+    splashscreen->color_depth = strdup(color_depth.c_str());
+  else
+    splashscreen->color_depth = strdup("24");
+  app->splashscreens = g_list_append(app->splashscreens, splashscreen);
+}
+
 template <typename T>
 bool StepParseManifest::FillSplashScreen(application_x* app,
                                      const T& splashscreens_info) {
   for (auto& splash_screen : splashscreens_info.splashscreens()) {
-    splashscreen_x* splashscreen =
-        static_cast<splashscreen_x*>(calloc(1, sizeof(splashscreen_x)));
+    std::string src;
     if (context_->is_readonly_package.get())
-      splashscreen->src = strdup(splash_screen.src().c_str());
-    else
-      splashscreen->src = strdup((context_->root_application_path.get()
-        / app->package / "shared" / "res" / splash_screen.src()).c_str());
-
-    splashscreen->type = strdup(splash_screen.type().c_str());
-    if (!splash_screen.dpi().empty())
-      splashscreen->dpi = strdup(splash_screen.dpi().c_str());
-    splashscreen->orientation = strdup(splash_screen.orientation().c_str());
-    if (!splash_screen.indicatordisplay().empty())
-      splashscreen->indicatordisplay = strdup(
-          splash_screen.indicatordisplay().c_str());
+      src = splash_screen.src();
     else
-      splashscreen->indicatordisplay = strdup("true");
+      src = bf::path(context_->root_application_path.get()
+        / app->package / "shared" / "res" / splash_screen.src()).string();
 
-    if (!splash_screen.operation().empty())
-      splashscreen->operation = strdup(splash_screen.operation().c_str());
-    else
-      splashscreen->operation = strdup("launch-effect");
+    AppendSplashScreen(app, src, splash_screen.type(), splash_screen.dpi(),
+        splash_screen.orientation(), splash_screen.indicatordisplay(),
+        splash_screen.operation(), splash_screen.colordepth());
+  }
+  return true;
+}
 
-    if (!splash_screen.colordepth().empty())
-      splashscreen->color_depth = strdup(splash_screen.colordepth().c_str());
-    else
-      splashscreen->color_depth = strdup("24");
+void StepParseManifest::GetLegacySplashScreenFromMetadata(application_x* app,
+    const std::string& key, const std::string& val) {
+  std::string operation;
+  if (key.find(kOperationEffectKey) != std::string::npos) {
+    boost::char_separator<char> sep("=");
+    boost::tokenizer<boost::char_separator<char>> tokens(key, sep);
+    auto iter = tokens.begin();
+    iter++;
+    operation = *iter;
+  } else if (key.find(kLaunchEffectKey) != std::string::npos) {
+    operation = std::string("launch-effect");
+  } else {
+    // not a metadata splashscreen
+    return;
+  }
 
-    app->splashscreens = g_list_append(app->splashscreens, splashscreen);
+  boost::char_separator<char> sep("=|");
+  boost::tokenizer<boost::char_separator<char>> tokens(val, sep);
+  auto iter = tokens.begin();
+  std::string portrait_src;
+  std::string landscape_src;
+  std::string indicatordisplay;
+  while (iter != tokens.end()) {
+    if (!(*iter).compare(kPortraitEffectImageValue)) {
+      iter++;
+      portrait_src = *iter;
+    } else if (!(*iter).compare(kLandscapeEffectImageValue)) {
+      iter++;
+      landscape_src = *iter;
+    } else if (!(*iter).compare(kIndicatorDisplayValue)) {
+      iter++;
+      indicatordisplay = *iter;
+    }
+    iter++;
   }
-  return true;
+  if (!portrait_src.empty())
+    AppendSplashScreen(app, portrait_src, {}, {}, kPortraitOrientation,
+        indicatordisplay, operation, {});
+  if (!landscape_src.empty())
+    AppendSplashScreen(app, landscape_src, {}, {}, kLandscapeOrientation,
+        indicatordisplay, operation, {});
 }
 
 bool StepParseManifest::FillImage(application_x* app,

diff --git a/src/common/step/configuration/step_parse_manifest.h b/src/common/step/configuration/step_parse_manifest.h
index 34c3cf294213aef39769e5d9af508ebf6636a05c..7bd8d5864c096df6d5e17c0059deb53442517b85 100644 (file)
--- a/src/common/step/configuration/step_parse_manifest.h
+++ b/src/common/step/configuration/step_parse_manifest.h
@@ -72,6 +72,12 @@ class StepParseManifest : public common_installer::Step {
   bool FillWatchApplication(manifest_x* manifest);
   int GetSupportModeVal(std::string support_mode);
   bool CheckFeatures();
+  void AppendSplashScreen(application_x* app, const std::string& src,
+      const std::string& type, const std::string& dpi,
+      const std::string& orientation, const std::string& indicatordisplay,
+      const std::string& operation, const std::string& color_depth);
+  void GetLegacySplashScreenFromMetadata(application_x* manifest,
+      const std::string& key, const std::string& val);
 
   template <typename T>
       bool FillAppControl(application_x* manifest, const T& app_control_list);