1 //******************************************************************
3 // Copyright 2014 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 /// @file PluginManagerImpl.cpp
23 /// @brief PluginManagerImple provides abstraction of the plugin manager interface
25 #include "PluginManagerImpl.h"
29 PluginManagerImpl *PluginManagerImpl::s_pinstance = NULL;
31 extern "C" PluginManagerImpl *create_object(void *args)
33 PluginManagerImpl *newobj;
34 newobj = new PluginManagerImpl(args);
38 extern "C" void destroy_object( PluginManagerImpl *object )
43 PluginManagerImpl::PluginManagerImpl(void *args)
47 cppm = CpluffAdapter::Getinstance();
51 cppm = CpluffAdapter::Getinstance(args);
53 javappm = FelixAdapter::Getinstance(args);
61 PluginManagerImpl::~PluginManagerImpl()
66 int PluginManagerImpl::registerPlugin(std::string path)
70 flag = cppm->registerPlugin(path);
73 flag = javappm->registerPlugin(path);
79 int PluginManagerImpl::registerAllPlugin(std::string path)
82 flag = cppm->registerAllPlugin(path);
86 flag = javappm->registerAllPlugin(path);
93 int PluginManagerImpl::unregisterPlugin(std::string id)
97 for (unsigned int i = 0 ; i < m_plugins.size(); i++)
99 if (!m_plugins[i].getID().compare(id))
101 if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
103 if ((flag = cppm->unregisterPlugin(&m_plugins[i])))
105 m_plugins.erase(m_plugins.begin() + i);
108 else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
111 if ((flag = javappm->unregisterPlugin(&m_plugins[i])))
113 m_plugins.erase(m_plugins.begin() + i);
123 int PluginManagerImpl::unregisterAllPlugin()
126 flag = cppm->unregisterAllPlugin();
129 flag = javappm->unregisterAllPlugin();
135 int PluginManagerImpl::rescanPlugin()
137 Config *config = Config::Getinstance(m_args);
138 std::string pluginpath = config->getPluginPath();
139 if (pluginpath != "")
141 printf("Current path is %s\n", pluginpath.c_str());
145 fprintf(stderr, "Pluing path does not exist\n");
148 int result = registerAllPlugin(pluginpath);
152 std::vector<Plugin> &PluginManagerImpl::getAllPlugins(void)
157 std::vector<Plugin> *PluginManagerImpl::findPlugins(const std::string key,
158 const std::string value)
160 std::vector<Plugin> *re_plugins;
161 re_plugins = new std::vector<Plugin>;
162 for (unsigned int i = 0; i < m_plugins.size(); i++)
164 std::string attributeValue = m_plugins[i].getValueByAttribute(key);
165 if (!attributeValue.empty() && !attributeValue.compare(value))
167 re_plugins->push_back(m_plugins[i]);
174 Plugin *PluginManagerImpl::getPlugin(const std::string pluginID)
176 for (unsigned int i = 0; i < m_plugins.size(); i++)
178 if (!(m_plugins[i].getID().compare(pluginID)))
180 return &(m_plugins[i]);
186 int PluginManagerImpl::startPlugins(const std::string key, const std::string value)
189 std::string resourcetype = "";
190 int size = value.size();
192 //Parsing Resource_Type
193 for (int i = size - 1; i > -1 ; i--)
195 if (value.at(i) == '.' && value.at(i) == '/')
199 resourcetype += value.at(i);
202 //Reverse string(Resource value)
203 reverse(resourcetype.begin(), resourcetype.end());
206 std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
209 std::vector<Plugin>::iterator it;
210 for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
212 if (!isStarted(&(*it))) // started : 1, stop : 0
214 flag = startPlugins(&(*it));//TODO PASS the OCPlatform
217 delete(resource_plugin);
218 resource_plugin = NULL;
222 int PluginManagerImpl::startPlugins(Plugin *const plugin)
227 flag = startbyPlatform(plugin, arg);
232 int PluginManagerImpl::stopPlugins(const std::string key, const std::string value)
235 std::string resourcetype = "";
236 int size = value.size();
238 //Parsing Resource_Type
239 for (int i = size - 1; i > -1 ; i--)
241 if (value.at(i) == '.' && value.at(i) == '/')
245 resourcetype += value.at(i);
248 //Reverse string(Resource value)
250 reverse(resourcetype.begin(), resourcetype.end());
252 // printf("resource value = %s\n", resourcetype.c_str());
255 std::vector<Plugin> *resource_plugin = findPlugins(key, resourcetype);
258 std::vector<Plugin>::iterator it;
259 for (it = resource_plugin->begin(); it != resource_plugin->end(); it++)
261 if (isStarted(&(*it))) // started : 1, stop : 0
263 flag = stopPlugins(&(*it));//TODO PASS the OCPlatform
266 delete(resource_plugin);
267 resource_plugin = NULL;
271 int PluginManagerImpl::stopPlugins(Plugin *const plugin)
275 flag = stopbyPlatform(plugin);
280 int PluginManagerImpl::startbyPlatform(Plugin *const plugin, void *const arg)
284 for (unsigned int i = 0 ; i < m_plugins.size(); i++)
286 if (!m_plugins[i].getID().compare(plugin->getID()))
288 if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
290 flag = cppm->start(plugin, arg);
292 else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
296 flag = javappm->start(plugin, arg);
309 int PluginManagerImpl::stopbyPlatform(Plugin *const plugin)
313 for (unsigned int i = 0 ; i < m_plugins.size(); i++)
315 if (!m_plugins[i].getID().compare(plugin->getID()))
317 if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
319 flag = cppm->stop(plugin);
321 else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
325 flag = javappm->stop(plugin);
338 bool PluginManagerImpl::isStarted(Plugin *plugin)
341 if (cppm->isStarted(plugin))
349 if (javappm->isStarted(plugin))
359 std::string PluginManagerImpl::getState(std::string plugID)
361 std::string str = "";
363 for (unsigned int i = 0 ; i < m_plugins.size(); i++)
365 if (!m_plugins[i].getID().compare(plugID))
367 if (!m_plugins[i].getValueByAttribute("Language").compare("CPP"))
369 str = cppm->getState(plugID);
371 else if (!m_plugins[i].getValueByAttribute("Language").compare("JAVA"))
375 str = javappm->getState(plugID);
384 std::vector<Plugin> PluginManagerImpl::refreshPluginInfo()
387 m_plugins = cppm->getAllPlugins();
392 std::vector<Plugin> java_plugins = javappm->getAllPlugins();
393 int size = java_plugins.size();
395 for (int i = 0 ; i < size ; i++)
397 m_plugins.push_back(java_plugins[i]);