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     Plugin *plugin = new Plugin;
  78     plugin->setValue("Id", id);
  79
  80     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
  81     {
  82         if (!m_plugins[i].getID().compare(id))
  83         {
  84             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
  85             {
  86                 if ((flag = cppm->unregisterPlugin(&m_plugins[i])))
  87                 {
  88                     m_plugins.erase(m_plugins.begin() + i);
  89                 }
  90             }
  91             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
  92             {
  93                 if ((flag = javappm->unregisterPlugin(&m_plugins[i])))
  94                 {
  95                     m_plugins.erase(m_plugins.begin() + i);
  96                 }
  97             }
  98         }
  99     }
 100
 101     return flag;
 102 }
 103
 104 int PluginManagerImpl::unregisterAllPlugin()
 105 {
 106     int flag = 0;
 107     flag = cppm->unregisterAllPlugin();
 108     flag = javappm->unregisterAllPlugin();
 109     m_plugins.clear();
 110     return flag;
 111 }
 112
 113
 114 std::vector<Plugin> &PluginManagerImpl::getAllPlugins(void)
 115 {
 116     return m_plugins;
 117 }
 118
 119 std::vector<Plugin> *PluginManagerImpl::findPlugins(const std::string key,
 120         const std::string value)
 121 {
 122     std::vector<Plugin> *re_plugins;
 123     re_plugins = new std::vector<Plugin>;
 124     for (unsigned int i = 0; i < m_plugins.size(); i++)
 125     {
 126         if (!m_plugins[i].getValueByAttribute(key).compare(value))
 127         {
 128             re_plugins->push_back(m_plugins[i]);
 129         }
 130     }
 131
 132     return re_plugins;
 133 }
 134
 135 Plugin *PluginManagerImpl::getPlugin(const std::string pluginID)
 136 {
 137     for (unsigned int i = 0; i < m_plugins.size(); i++)
 138     {
 139         if (!(m_plugins[i].getID().compare(pluginID)))
 140         {
 141             return &(m_plugins[i]);
 142         }
 143     }
 144
 145     return nullptr;
 146 }
 147 int PluginManagerImpl::startPlugins(const std::string key, const std::string value)
 148 {
 149     int flag = FALSE;
 150     std::string resourcetype = "";
 151     int size = value.size();
 152
 153     //Parsing Resource_Type
 154     for (int i = size - 1; i > -1 ; i--)
 155     {
 156         if (value.at(i) == '.' && value.at(i) == '/')
 157         {
 158             break;
 159         }
 160         resourcetype += value.at(i);
 161     }
 162
 163     //Reverse string(Resource value)
 164     reverse(resourcetype.begin(), resourcetype.end());
 165
 166     //Search Plugin
 167     std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
 168
 169     //start Plugin
 170     std::vector<Plugin>::iterator it;
 171     for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
 172     {
 173         if (!isStarted(&(*it))) // started : 1, stop : 0
 174         {
 175             flag = startPlugins(&(*it));//TODO PASS the OCPlatform
 176         }
 177     }
 178     delete(resource_plugin);
 179     resource_plugin = nullptr;
 180     return flag;
 181 }
 182
 183 int PluginManagerImpl::startPlugins(Plugin *const plugin)
 184 {
 185     int flag = FALSE;
 186     void *arg  = nullptr;
 187
 188     flag = startbyPlatform(plugin, arg);
 189
 190     return flag;
 191 }
 192
 193 int PluginManagerImpl::stopPlugins(const std::string key, const std::string value)
 194 {
 195     int flag = FALSE;
 196     std::string resourcetype = "";
 197     int size = value.size();
 198
 199     //Parsing Resource_Type
 200     for (int i = size - 1; i > -1 ; i--)
 201     {
 202         if (value.at(i) == '.' && value.at(i) == '/')
 203         {
 204             break;
 205         }
 206         resourcetype += value.at(i);
 207     }
 208
 209     //Reverse string(Resource value)
 210
 211     reverse(resourcetype.begin(), resourcetype.end());
 212
 213     // printf("resource value = %s\n", resourcetype.c_str());
 214
 215     //Search Plugin
 216     std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
 217
 218     //stop Plugin
 219     std::vector<Plugin>::iterator it;
 220     for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
 221     {
 222         if (isStarted(&(*it))) // started : 1, stop : 0
 223         {
 224             flag = stopPlugins(&(*it));//TODO PASS the OCPlatform
 225         }
 226     }
 227     delete(resource_plugin);
 228     resource_plugin = nullptr;
 229     return flag;
 230 }
 231
 232 int PluginManagerImpl::stopPlugins(Plugin *const plugin)
 233 {
 234     int flag = FALSE;
 235
 236     flag = stopbyPlatform(plugin);
 237
 238     return flag;
 239 }
 240
 241 int PluginManagerImpl::startbyPlatform(Plugin *const plugin, void *const arg)
 242 {
 243     int flag = 0;
 244
 245     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 246     {
 247         if (!m_plugins[i].getID().compare(plugin->getID()))
 248         {
 249             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 250             {
 251                 flag = cppm->start(plugin, arg);
 252             }
 253             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 254             {
 255                 flag = javappm->start(plugin, arg);
 256             }
 257         }
 258     }
 259
 260     if (flag)
 261     {
 262         refreshPluginInfo();
 263     }
 264     return flag;
 265 }
 266
 267 int PluginManagerImpl::stopbyPlatform(Plugin *const plugin)
 268 {
 269     int flag = 0;
 270
 271     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 272     {
 273         if (!m_plugins[i].getID().compare(plugin->getID()))
 274         {
 275             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 276             {
 277                 flag = cppm->stop(plugin);
 278             }
 279             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 280             {
 281                 flag = javappm->stop(plugin);
 282             }
 283         }
 284     }
 285
 286     if (flag)
 287     {
 288         refreshPluginInfo();
 289     }
 290     return flag;
 291 }
 292
 293 bool PluginManagerImpl::isStarted(Plugin *plugin)
 294 {
 295     bool flag = 0;
 296     if (cppm->isStarted(plugin))
 297     {
 298         flag = TRUE;
 299         return flag;
 300     }
 301
 302     if (javappm->isStarted(plugin))
 303     {
 304         flag = TRUE;
 305         return flag;
 306     }
 307     return flag;
 308 }
 309
 310 std::string PluginManagerImpl::getState(std::string plugID)
 311 {
 312     std::string str = "";
 313
 314     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 315     {
 316         if (!m_plugins[i].getID().compare(plugID))
 317         {
 318             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 319             {
 320                 str = cppm->getState(plugID);
 321             }
 322             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 323             {
 324                 str = javappm->getState(plugID);
 325             }
 326         }
 327     }
 328
 329     return str;
 330 }
 331
 332 std::vector<Plugin> PluginManagerImpl::refreshPluginInfo()
 333 {
 334     m_plugins.clear();
 335     m_plugins = cppm->getAllPlugins();
 336
 337     std::vector<Plugin> java_plugins = javappm->getAllPlugins();
 338     int size = java_plugins.size();
 339
 340     for (int i = 0 ; i < size ; i++)
 341     {
 342         m_plugins.push_back(java_plugins[i]);
 343     }
 344
 345     return m_plugins;
 346 }