NativeLauncher/util/path_manager.cc

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <vector>
  18 #include <iterator>
  19 #include <sstream>
  20 #include <vconf.h>
  21 #include <fstream>
  22
  23 #include "utils.h"
  24 #include "plugin_manager.h"
  25 #include "log.h"
  26
  27 static const char* __TIZEN_API_PATH_KEY = "db/dotnet/tizen_api_path";
  28
  29 #define __XSTR(x) #x
  30 #define __STR(x) __XSTR(x)
  31 static const char* __DEVICE_API_DIR = __STR(DEVICE_API_DIR);
  32 static const char* __RUNTIME_DIR = __STR(RUNTIME_DIR);
  33 #undef __STR
  34 #undef __XSTR
  35
  36 typedef struct DllPath {
  37         std::string runtime_dir;
  38         std::string tizenfx_dir;
  39         std::string tizenfx_ref_dir;
  40         std::vector <std::string>extra_dirs;
  41 } DllPath;
  42
  43 static DllPath* __dllPath = nullptr;
  44 static std::string __tpa;
  45 bool initializedPathManager = false;
  46
  47 // on success, return 0. otherwise return -1.
  48 int initializePathManager(const std::string& runtimeDir, const std::string& tizenFXDir, const std::string& extraDir)
  49 {
  50         if (initializedPathManager) {
  51                 _INFO("Path manager already initialized");
  52                 return 0;
  53         }
  54
  55         __dllPath = new DllPath();
  56         if (!__dllPath) {
  57                 _ERR("fail to allocate memory for dll path structure\n");
  58                 return -1;
  59         }
  60
  61         if (!runtimeDir.empty()) {
  62                 __dllPath->runtime_dir = absolutePath(runtimeDir);
  63         } else {
  64                 __dllPath->runtime_dir = absolutePath(__RUNTIME_DIR);
  65         }
  66
  67         if (!tizenFXDir.empty()) {
  68                 __dllPath->tizenfx_dir = absolutePath(tizenFXDir);
  69         } else {
  70                 char* tmp = vconf_get_str(__TIZEN_API_PATH_KEY);
  71                 if (tmp) {
  72                         __dllPath->tizenfx_dir = std::string(tmp);
  73                         _DBG("Device API Directory is set by vconf : %s", tmp);
  74                         free(tmp);
  75                 } else {
  76                         __dllPath->tizenfx_dir = absolutePath(__DEVICE_API_DIR);
  77                 }
  78         }
  79
  80         __dllPath->tizenfx_ref_dir = __dllPath->tizenfx_dir + "/ref";
  81
  82         // ":" seperated extra directories
  83         if (!extraDir.empty()) {
  84                 splitPath(extraDir, __dllPath->extra_dirs);
  85         } else {
  86                 char* extraPath = pluginGetDllPath();
  87                 if (extraPath) {
  88                         splitPath(extraPath, __dllPath->extra_dirs);
  89                 }
  90         }
  91
  92         _INFO("Path manager initialize success");
  93
  94         initializedPathManager = true;
  95         return 0;
  96 }
  97
  98 void finalizePathManager()
  99 {
 100         if (__dllPath) {
 101                 delete __dllPath;
 102                 __dllPath = NULL;
 103         }
 104
 105         initializedPathManager = false;
 106 }
 107
 108 std::string getRuntimeDir()
 109 {
 110         return __dllPath->runtime_dir;
 111 }
 112
 113 std::string getTizenFXDir()
 114 {
 115         return __dllPath->tizenfx_dir;
 116 }
 117
 118 std::string getTizenFXRefDir()
 119 {
 120         return __dllPath->tizenfx_ref_dir;
 121 }
 122
 123 std::vector <std::string> getExtraDirs()
 124 {
 125         return __dllPath->extra_dirs;
 126 }
 127
 128 static std::string getPlatformTPA()
 129 {
 130         std::string platform_tpa;
 131
 132         if (isFileExist(PLATFORM_TPA_CACHE)) {
 133                 _INFO("platform tpa cache found.");
 134                 std::ifstream cacheFile;
 135                 cacheFile.open(PLATFORM_TPA_CACHE);
 136                 std::getline(cacheFile, platform_tpa);
 137                 cacheFile.close();
 138         } else {
 139                 std::vector<std::string> tpaDir;
 140                 tpaDir.push_back(getRuntimeDir());
 141                 tpaDir.push_back(getTizenFXDir());
 142                 tpaDir.push_back(getTizenFXRefDir());
 143                 assembliesInDirectory(tpaDir, platform_tpa);
 144         }
 145
 146         return platform_tpa;
 147 }
 148
 149 static std::string getPluginTPA()
 150 {
 151         std::string plugin_tpa;
 152
 153         char* plugin_tpa_list = pluginGetTPA();
 154         if (plugin_tpa_list) {
 155                 _INFO("plugin TPA list found. use TPA list for plugin");
 156                 plugin_tpa = plugin_tpa_list;
 157         } else if (!__dllPath->extra_dirs.empty()){
 158                 _INFO("plugin extra directory found. use plugin extra directroy for TPA");
 159                 assembliesInDirectory(__dllPath->extra_dirs, plugin_tpa);
 160         }
 161
 162         return plugin_tpa;
 163 }
 164
 165 std::string getTPA()
 166 {
 167         if (!__tpa.empty()) {
 168                 return __tpa;
 169         }
 170
 171         if (__dllPath == NULL) {
 172                 return std::string("");
 173         }
 174
 175         return getPlatformTPA() + ":" + getPluginTPA();
 176 }
 177