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 PluginManagerImple provides abstraction of the plugin manager interface
  24
  25 #include "PluginManagerImpl.h"
  26
  27 using namespace OIC;
  28
  29 PluginManagerImpl *PluginManagerImpl::s_pinstance = NULL;
  30
  31 extern "C" PluginManagerImpl *create_object(void *args)
  32 {
  33     PluginManagerImpl *newobj;
  34     newobj =  new PluginManagerImpl(args);
  35     return newobj;
  36 }
  37
  38 extern "C" void destroy_object( PluginManagerImpl *object )
  39 {
  40     delete object;
  41 }
  42
  43 PluginManagerImpl::PluginManagerImpl(void *args)
  44 {
  45 #ifndef ANDROID
  46     m_args = args;
  47     cppm = CpluffAdapter::Getinstance();
  48 #endif
  49 #ifdef ANDROID
  50     m_args = args;
  51     cppm = CpluffAdapter::Getinstance(args);
  52     if (args)
  53         javappm = FelixAdapter::Getinstance(args);
  54     else
  55         javappm = NULL;
  56 #endif
  57
  58     refreshPluginInfo();
  59 }
  60
  61 PluginManagerImpl::~PluginManagerImpl()
  62 {
  63
  64 }
  65
  66 int PluginManagerImpl::registerPlugin(std::string path)
  67 {
  68     int flag = 0;
  69
  70     flag = cppm->registerPlugin(path);
  71 #ifdef ANDROID
  72     if (javappm)
  73         flag = javappm->registerPlugin(path);
  74 #endif
  75     refreshPluginInfo();
  76     return flag;
  77 }
  78
  79 int PluginManagerImpl::registerAllPlugin(std::string path)
  80 {
  81     int flag = 0;
  82     flag = cppm->registerAllPlugin(path);
  83
  84 #ifdef ANDROID
  85     if (javappm)
  86         flag = javappm->registerAllPlugin(path);
  87 #endif
  88
  89     refreshPluginInfo();
  90     return flag;
  91 }
  92
  93 int PluginManagerImpl::unregisterPlugin(std::string id)
  94 {
  95     int flag = 0;
  96
  97     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
  98     {
  99         if (!m_plugins[i].getID().compare(id))
 100         {
 101             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 102             {
 103                 if ((flag = cppm->unregisterPlugin(&m_plugins[i])))
 104                 {
 105                     m_plugins.erase(m_plugins.begin() + i);
 106                 }
 107             }
 108             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 109             {
 110 #ifdef ANDROID
 111                 if ((flag = javappm->unregisterPlugin(&m_plugins[i])))
 112                 {
 113                     m_plugins.erase(m_plugins.begin() + i);
 114                 }
 115 #endif
 116             }
 117         }
 118     }
 119
 120     return flag;
 121 }
 122
 123 int PluginManagerImpl::unregisterAllPlugin()
 124 {
 125     int flag = 0;
 126     flag = cppm->unregisterAllPlugin();
 127 #ifdef ANDROID
 128     if (javappm)
 129         flag = javappm->unregisterAllPlugin();
 130 #endif
 131     m_plugins.clear();
 132     return flag;
 133 }
 134
 135 int PluginManagerImpl::rescanPlugin()
 136 {
 137     Config *config = Config::Getinstance(m_args);
 138     std::string pluginpath = config->getPluginPath();
 139     if (pluginpath != "")
 140     {
 141         printf("Current path is %s\n", pluginpath.c_str());
 142     }
 143     else
 144     {
 145         fprintf(stderr, "Pluing path does not exist\n");
 146         pluginpath = "";
 147     }
 148     int result = registerAllPlugin(pluginpath);
 149     return result;
 150 }
 151
 152 std::vector<Plugin> &PluginManagerImpl::getAllPlugins(void)
 153 {
 154     return m_plugins;
 155 }
 156
 157 std::vector<Plugin> *PluginManagerImpl::findPlugins(const std::string key,
 158         const std::string value)
 159 {
 160     std::vector<Plugin> *re_plugins;
 161     re_plugins = new std::vector<Plugin>;
 162     for (unsigned int i = 0; i < m_plugins.size(); i++)
 163     {
 164         std::string attributeValue = m_plugins[i].getValueByAttribute(key);
 165         if (!attributeValue.empty() && !attributeValue.compare(value))
 166         {
 167             re_plugins->push_back(m_plugins[i]);
 168         }
 169     }
 170
 171     return re_plugins;
 172 }
 173
 174 Plugin *PluginManagerImpl::getPlugin(const std::string pluginID)
 175 {
 176     for (unsigned int i = 0; i < m_plugins.size(); i++)
 177     {
 178         if (!(m_plugins[i].getID().compare(pluginID)))
 179         {
 180             return &(m_plugins[i]);
 181         }
 182     }
 183
 184     return NULL;
 185 }
 186 int PluginManagerImpl::startPlugins(const std::string key, const std::string value)
 187 {
 188     int flag = FALSE;
 189     std::string resourcetype = "";
 190     int size = value.size();
 191
 192     //Parsing Resource_Type
 193     for (int i = size - 1; i > -1 ; i--)
 194     {
 195         if (value.at(i) == '.' && value.at(i) == '/')
 196         {
 197             break;
 198         }
 199         resourcetype += value.at(i);
 200     }
 201
 202     //Reverse string(Resource value)
 203     reverse(resourcetype.begin(), resourcetype.end());
 204
 205     //Search Plugin
 206     std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
 207
 208     //start Plugin
 209     std::vector<Plugin>::iterator it;
 210     for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
 211     {
 212         if (!isStarted(&(*it))) // started : 1, stop : 0
 213         {
 214             flag = startPlugins(&(*it));//TODO PASS the OCPlatform
 215         }
 216     }
 217     delete(resource_plugin);
 218     resource_plugin = NULL;
 219     return flag;
 220 }
 221
 222 int PluginManagerImpl::startPlugins(Plugin *const plugin)
 223 {
 224     int flag = FALSE;
 225     void *arg  = NULL;
 226
 227     flag = startbyPlatform(plugin, arg);
 228
 229     return flag;
 230 }
 231
 232 int PluginManagerImpl::stopPlugins(const std::string key, const std::string value)
 233 {
 234     int flag = FALSE;
 235     std::string resourcetype = "";
 236     int size = value.size();
 237
 238     //Parsing Resource_Type
 239     for (int i = size - 1; i > -1 ; i--)
 240     {
 241         if (value.at(i) == '.' && value.at(i) == '/')
 242         {
 243             break;
 244         }
 245         resourcetype += value.at(i);
 246     }
 247
 248     //Reverse string(Resource value)
 249
 250     reverse(resourcetype.begin(), resourcetype.end());
 251
 252     // printf("resource value = %s\n", resourcetype.c_str());
 253
 254     //Search Plugin
 255     std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
 256
 257     //stop Plugin
 258     std::vector<Plugin>::iterator it;
 259     for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
 260     {
 261         if (isStarted(&(*it))) // started : 1, stop : 0
 262         {
 263             flag = stopPlugins(&(*it));//TODO PASS the OCPlatform
 264         }
 265     }
 266     delete(resource_plugin);
 267     resource_plugin = NULL;
 268     return flag;
 269 }
 270
 271 int PluginManagerImpl::stopPlugins(Plugin *const plugin)
 272 {
 273     int flag = FALSE;
 274
 275     flag = stopbyPlatform(plugin);
 276
 277     return flag;
 278 }
 279
 280 int PluginManagerImpl::startbyPlatform(Plugin *const plugin, void *const arg)
 281 {
 282     int flag = 0;
 283
 284     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 285     {
 286         if (!m_plugins[i].getID().compare(plugin->getID()))
 287         {
 288             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 289             {
 290                 flag = cppm->start(plugin, arg);
 291             }
 292             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 293             {
 294 #ifdef ANDROID
 295                 if (javappm)
 296                     flag = javappm->start(plugin, arg);
 297 #endif
 298             }
 299         }
 300     }
 301
 302     if (flag)
 303     {
 304         refreshPluginInfo();
 305     }
 306     return flag;
 307 }
 308
 309 int PluginManagerImpl::stopbyPlatform(Plugin *const plugin)
 310 {
 311     int flag = 0;
 312
 313     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 314     {
 315         if (!m_plugins[i].getID().compare(plugin->getID()))
 316         {
 317             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 318             {
 319                 flag = cppm->stop(plugin);
 320             }
 321             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 322             {
 323 #ifdef ANDROID
 324                 if (javappm)
 325                     flag = javappm->stop(plugin);
 326 #endif
 327             }
 328         }
 329     }
 330
 331     if (flag)
 332     {
 333         refreshPluginInfo();
 334     }
 335     return flag;
 336 }
 337
 338 bool PluginManagerImpl::isStarted(Plugin *plugin)
 339 {
 340     bool flag = 0;
 341     if (cppm->isStarted(plugin))
 342     {
 343         flag = TRUE;
 344         return flag;
 345     }
 346 #ifdef ANDROID
 347     if (javappm)
 348     {
 349         if (javappm->isStarted(plugin))
 350         {
 351             flag = TRUE;
 352             return flag;
 353         }
 354     }
 355 #endif
 356     return flag;
 357 }
 358
 359 std::string PluginManagerImpl::getState(std::string plugID)
 360 {
 361     std::string str = "";
 362
 363     for (unsigned int i = 0 ; i < m_plugins.size(); i++)
 364     {
 365         if (!m_plugins[i].getID().compare(plugID))
 366         {
 367             if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
 368             {
 369                 str = cppm->getState(plugID);
 370             }
 371             else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
 372             {
 373 #ifdef ANDROID
 374                 if (javappm)
 375                     str = javappm->getState(plugID);
 376 #endif
 377             }
 378         }
 379     }
 380
 381     return str;
 382 }
 383
 384 std::vector<Plugin> PluginManagerImpl::refreshPluginInfo()
 385 {
 386     m_plugins.clear();
 387     m_plugins = cppm->getAllPlugins();
 388
 389 #ifdef ANDROID
 390     if (javappm)
 391     {
 392         std::vector<Plugin> java_plugins = javappm->getAllPlugins();
 393         int size = java_plugins.size();
 394
 395         for (int i = 0 ; i < size ; i++)
 396         {
 397             m_plugins.push_back(java_plugins[i]);
 398         }
 399     }
 400 #endif
 401
 402     return m_plugins;
 403 }