service/protocol-plugin/plugin-manager/src/PluginManagerImpl.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 /// @file PluginManagerImpl.cpp
  22
  23 /// @brief
  24
  25 #include "PluginManagerImpl.h"
  26
  27 using namespace OIC;
  28
  29 PluginManagerImpl *PluginManagerImpl::s_pinstance = nullptr;
  30
  31 extern "C" PluginManagerImpl *create_object()
  32 {
  33     PluginManagerImpl *newobj;
  34     newobj =  new PluginManagerImpl;
  35     return newobj;
  36 }
  37
  38 extern "C" void destroy_object( PluginManagerImpl *object )
  39 {
  40     delete object;
  41 }
  42
  43 PluginManagerImpl::PluginManagerImpl()
  44 {
  45     cppm = CpluffAdapter::Getinstance();
  46     javappm = FelixAdapter::Getinstance();
  47     refreshPluginInfo();
  48 }
  49
  50 PluginManagerImpl::~PluginManagerImpl()
  51 {
  52
  53 }
  54
  55 int PluginManagerImpl::registerPlugin(std::string path)
  56 {
  57     int flag = 0;
  58     flag = cppm->registerPlugin(path);
  59     flag = javappm->registerPlugin(path);
  60     refreshPluginInfo();
  61     return flag;
  62 }
  63
  64 int PluginManagerImpl::registerAllPlugin(std::string path)
  65 {
  66     int flag = 0;
  67     flag = cppm->registerAllPlugin(path);
  68     flag = javappm->registerAllPlugin(path);
  69     refreshPluginInfo();
  70     return flag;
  71 }
  72
  73 int PluginManagerImpl::unregisterPlugin(std::string id)
  74 {
  75     int flag = 0;
  76
  77     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
  78     {
  79         if (!m_plugins[i].getID().compare(id))
  80         {
  81             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
  82             {
  83                 if ((flag = cppm->unregisterPlugin(&m_plugins[i])))
  84                 {
  85                     m_plugins.erase(m_plugins.begin() + i);
  86                 }
  87             }
  88             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
  89             {
  90                 if ((flag = javappm->unregisterPlugin(&m_plugins[i])))
  91                 {
  92                     m_plugins.erase(m_plugins.begin() + i);
  93                 }
  94             }
  95         }
  96     }
  97
  98     return flag;
  99 }
 100
 101 int PluginManagerImpl::unregisterAllPlugin()
 102 {
 103     int flag = 0;
 104     flag = cppm->unregisterAllPlugin();
 105     flag = javappm->unregisterAllPlugin();
 106     m_plugins.clear();
 107     return flag;
 108 }
 109
 110 int PluginManagerImpl::rescanPlugin()
 111 {
 112     Config *config = Config::Getinstance();
 113     std::string pluginpath = config->getPluginPath();
 114     if (pluginpath != "")
 115     {
 116         printf("Current path is %s\n", pluginpath.c_str());
 117     }
 118     else
 119     {
 120         fprintf(stderr, "Pluing path does not exist\n");
 121         pluginpath = "";
 122     }
 123     int result = registerAllPlugin(pluginpath);
 124     return result;
 125 }
 126
 127
 128 std::vector<Plugin> &PluginManagerImpl::getAllPlugins(void)
 129 {
 130     return m_plugins;
 131 }
 132
 133 std::vector<Plugin> *PluginManagerImpl::findPlugins(const std::string key,
 134         const std::string value)
 135 {
 136     std::vector<Plugin> *re_plugins;
 137     re_plugins = new std::vector<Plugin>;
 138     for (unsigned int i = 0; i < m_plugins.size(); i++)
 139     {
 140         if (!m_plugins[i].getValueByAttribute(key).compare(value))
 141         {
 142             re_plugins->push_back(m_plugins[i]);
 143         }
 144     }
 145
 146     return re_plugins;
 147 }
 148
 149 Plugin *PluginManagerImpl::getPlugin(const std::string pluginID)
 150 {
 151     for (unsigned int i = 0; i < m_plugins.size(); i++)
 152     {
 153         if (!(m_plugins[i].getID().compare(pluginID)))
 154         {
 155             return &(m_plugins[i]);
 156         }
 157     }
 158
 159     return nullptr;
 160 }
 161 int PluginManagerImpl::startPlugins(const std::string key, const std::string value)
 162 {
 163     int flag = FALSE;
 164     std::string resourcetype = "";
 165     int size = value.size();
 166
 167     //Parsing Resource_Type
 168     for (int i = size - 1; i > -1 ; i--)
 169     {
 170         if (value.at(i) == '.' && value.at(i) == '/')
 171         {
 172             break;
 173         }
 174         resourcetype += value.at(i);
 175     }
 176
 177     //Reverse string(Resource value)
 178     reverse(resourcetype.begin(), resourcetype.end());
 179
 180     //Search Plugin
 181     std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
 182
 183     //start Plugin
 184     std::vector<Plugin>::iterator it;
 185     for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
 186     {
 187         if (!isStarted(&(*it))) // started : 1, stop : 0
 188         {
 189             flag = startPlugins(&(*it));//TODO PASS the OCPlatform
 190         }
 191     }
 192     delete(resource_plugin);
 193     resource_plugin = nullptr;
 194     return flag;
 195 }
 196
 197 int PluginManagerImpl::startPlugins(Plugin *const plugin)
 198 {
 199     int flag = FALSE;
 200     void *arg  = nullptr;
 201
 202     flag = startbyPlatform(plugin, arg);
 203
 204     return flag;
 205 }
 206
 207 int PluginManagerImpl::stopPlugins(const std::string key, const std::string value)
 208 {
 209     int flag = FALSE;
 210     std::string resourcetype = "";
 211     int size = value.size();
 212
 213     //Parsing Resource_Type
 214     for (int i = size - 1; i > -1 ; i--)
 215     {
 216         if (value.at(i) == '.' && value.at(i) == '/')
 217         {
 218             break;
 219         }
 220         resourcetype += value.at(i);
 221     }
 222
 223     //Reverse string(Resource value)
 224
 225     reverse(resourcetype.begin(), resourcetype.end());
 226
 227     // printf("resource value = %s\n", resourcetype.c_str());
 228
 229     //Search Plugin
 230     std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
 231
 232     //stop Plugin
 233     std::vector<Plugin>::iterator it;
 234     for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
 235     {
 236         if (isStarted(&(*it))) // started : 1, stop : 0
 237         {
 238             flag = stopPlugins(&(*it));//TODO PASS the OCPlatform
 239         }
 240     }
 241     delete(resource_plugin);
 242     resource_plugin = nullptr;
 243     return flag;
 244 }
 245
 246 int PluginManagerImpl::stopPlugins(Plugin *const plugin)
 247 {
 248     int flag = FALSE;
 249
 250     flag = stopbyPlatform(plugin);
 251
 252     return flag;
 253 }
 254
 255 int PluginManagerImpl::startbyPlatform(Plugin *const plugin, void *const arg)
 256 {
 257     int flag = 0;
 258
 259     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 260     {
 261         if (!m_plugins[i].getID().compare(plugin->getID()))
 262         {
 263             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 264             {
 265                 flag = cppm->start(plugin, arg);
 266             }
 267             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 268             {
 269                 flag = javappm->start(plugin, arg);
 270             }
 271         }
 272     }
 273
 274     if (flag)
 275     {
 276         refreshPluginInfo();
 277     }
 278     return flag;
 279 }
 280
 281 int PluginManagerImpl::stopbyPlatform(Plugin *const plugin)
 282 {
 283     int flag = 0;
 284
 285     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 286     {
 287         if (!m_plugins[i].getID().compare(plugin->getID()))
 288         {
 289             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 290             {
 291                 flag = cppm->stop(plugin);
 292             }
 293             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 294             {
 295                 flag = javappm->stop(plugin);
 296             }
 297         }
 298     }
 299
 300     if (flag)
 301     {
 302         refreshPluginInfo();
 303     }
 304     return flag;
 305 }
 306
 307 bool PluginManagerImpl::isStarted(Plugin *plugin)
 308 {
 309     bool flag = 0;
 310     if (cppm->isStarted(plugin))
 311     {
 312         flag = TRUE;
 313         return flag;
 314     }
 315
 316     if (javappm->isStarted(plugin))
 317     {
 318         flag = TRUE;
 319         return flag;
 320     }
 321     return flag;
 322 }
 323
 324 std::string PluginManagerImpl::getState(std::string plugID)
 325 {
 326     std::string str = "";
 327
 328     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 329     {
 330         if (!m_plugins[i].getID().compare(plugID))
 331         {
 332             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 333             {
 334                 str = cppm->getState(plugID);
 335             }
 336             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 337             {
 338                 str = javappm->getState(plugID);
 339             }
 340         }
 341     }
 342
 343     return str;
 344 }
 345
 346 std::vector<Plugin> PluginManagerImpl::refreshPluginInfo()
 347 {
 348     m_plugins.clear();
 349     m_plugins = cppm->getAllPlugins();
 350
 351     std::vector<Plugin> java_plugins = javappm->getAllPlugins();
 352     int size = java_plugins.size();
 353
 354     for (int i = 0 ; i < size ; i++)
 355     {
 356         m_plugins.push_back(java_plugins[i]);
 357     }
 358
 359     return m_plugins;
 360 }