Add flags to the install plugin to avoid duplicate execution

[platform/core/dotnet/launcher.git] / NativeLauncher / installer-plugin / prefer_dotnet_aot_plugin.cc

diff --git a/NativeLauncher/installer-plugin/prefer_dotnet_aot_plugin.cc b/NativeLauncher/installer-plugin/prefer_dotnet_aot_plugin.cc
index 83a018e..9e09ad1 100644 (file)
--- a/NativeLauncher/installer-plugin/prefer_dotnet_aot_plugin.cc
+++ b/NativeLauncher/installer-plugin/prefer_dotnet_aot_plugin.cc
@@ -14,36 +14,52 @@
  * limitations under the License.
  */
 
-#include "common.h"
+#include "ni_common.h"
 #include "log.h"
 #include "utils.h"
 
-#ifdef  LOG_TAG
-#undef  LOG_TAG
-#endif
-#define LOG_TAG "NETCORE_INSTALLER_PLUGIN"
-
 #include <cstring>
 #include <vector>
 #include <sstream>
 #include <glib.h>
+#include <pkgmgr_installer_info.h>
+
+#ifdef  LOG_TAG
+#undef  LOG_TAG
+#endif
+#define LOG_TAG "DOTNET_INSTALLER_PLUGIN"
 
 typedef struct Metadata {
        const char *key;
        const char *value;
 } Metadata;
 
-const std::string valueType = "true";
-const std::string mdKey = "http://tizen.org/metadata/prefer_dotnet_aot";
+bool aotPluginInstalled = false;
+
 extern "C" int PKGMGR_MDPARSER_PLUGIN_INSTALL(const char *pkgId, const char *appId, GList *list)
 {
+       // Can be multiple apps in one package
+       if (aotPluginInstalled) {
+               _INFO("AOT plugin already installed");
+               return 0;
+       }
+       aotPluginInstalled = true;
+
+       int skipOpt = false;
+       if (!pkgmgr_installer_info_get_skip_optimization(&skipOpt)) {
+               if (skipOpt) {
+                       _DBG("Skip dotnet AOT");
+                       return 0;
+               }
+       }
+
        GList *tag = NULL;
        bool mdValue = false;
        Metadata *mdInfo = NULL;
        tag = g_list_first(list);
        while (tag) {
                mdInfo = (Metadata*)tag->data;
-               if (mdInfo->key == mdKey && mdInfo->value == valueType) {
+               if (strcmp(mdInfo->key, AOT_METADATA_KEY) == 0 && strcmp(mdInfo->value, METADATA_VALUE) == 0) {
                        _DBG("Prefer dotnet application AOT set TRUE");
                        mdValue = true;
                }
@@ -51,11 +67,61 @@ extern "C" int PKGMGR_MDPARSER_PLUGIN_INSTALL(const char *pkgId, const char *app
        }
 
        if (mdValue) {
-               if (createNiUnderPkgRoot(pkgId) != 0) {
+               NiCommonOption option = {std::string(), std::string(), std::string()};
+               if (initNICommon(&option) < 0) {
+                       _ERR("Fail to initialize NI Common");
+                       return -1;
+               }
+
+               if (createNiUnderPkgRoot(pkgId, 0) != NI_ERROR_NONE) {
                        _ERR("Failed to get root path from [%s]", pkgId);
                        return -1;
                } else {
-                       _DBG("Complete make application to native image");
+                       _INFO("Complete make application to native image");
+               }
+
+               std::string pkgRoot;
+               if (getRootPath(pkgId, pkgRoot) < 0) {
+                       _ERR("Failed to get root path from [%s]", pkgId);
+                       return 0;
+               }
+
+               std::string binDir = concatPath(pkgRoot, "bin");
+               std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
+               if (bf::exists(tacDir)) {
+                       uid_t g_uid = 0;
+                       gid_t g_gid = 0;
+                       if (pkgmgr_installer_info_get_target_uid(&g_uid) < 0) {
+                               _ERR("Failed to get UID");
+                               return 0;
+                       }
+                       try {
+                               for (auto& symlinkAssembly : bf::recursive_directory_iterator(tacDir)) {
+                                       std::string symPath = symlinkAssembly.path().string();
+                                       if (!isNativeImage(symPath)) {
+                                               std::string originPath = bf::read_symlink(symPath).string();
+                                               std::string originNiPath = originPath.substr(0, originPath.rfind(".dll")) + ".ni.dll";
+                                               if (!bf::exists(originNiPath)) {
+                                                       if(createNiDllUnderPkgRoot(pkgId, originPath, 0) != NI_ERROR_NONE) {
+                                                               _ERR("Failed to create NI file [%s]", originPath.c_str());
+                                                               return -1;
+                                                       }
+                                               }
+                                               std::string setNiPath = symPath.substr(0, symPath.rfind(".dll")) + ".ni.dll";
+                                               if (!bf::exists(setNiPath)) {
+                                                       bf::create_symlink(originNiPath, setNiPath);
+                                                       _INFO("%s symbolic link file generated successfully.", setNiPath.c_str());
+                                                       if (lchown(setNiPath.c_str(), g_uid, g_gid)) {
+                                                               _ERR("Failed to change owner of: %s", setNiPath.c_str());
+                                                               return -1;
+                                                       }
+                                               }
+                                       }
+                               }
+                       } catch (const bf::filesystem_error& error) {
+                               _ERR("File system error while interating files: %s", error.what());
+                               return -1;
+                       }
                }
        }
        return 0;
@@ -65,3 +131,23 @@ extern "C" int PKGMGR_MDPARSER_PLUGIN_UPGRADE(const char *pkgId, const char *app
 {
        return PKGMGR_MDPARSER_PLUGIN_INSTALL(pkgId, appId, list);
 }
+
+extern "C" int PKGMGR_MDPARSER_PLUGIN_UNINSTALL(const char *pkgId, const char *appId, GList *list)
+{
+       return 0;
+}
+
+extern "C" int PKGMGR_MDPARSER_PLUGIN_REMOVED(const char *pkgId, const char *appId, GList *list)
+{
+       return PKGMGR_MDPARSER_PLUGIN_UPGRADE(pkgId, appId, list);
+}
+
+extern "C" int PKGMGR_MDPARSER_PLUGIN_CLEAN(const char *pkgId, const char *appId, GList *list)
+{
+       return 0;
+}
+
+extern "C" int PKGMGR_MDPARSER_PLUGIN_UNDO(const char *pkgId, const char *appId, GList *list)
+{
+       return 0;
+}