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 FelixAdapter.cpp
25 #include "FelixAdapter.h"
30 FelixAdapter *FelixAdapter::s_pinstance;
32 FelixAdapter::FelixAdapter(JavaVM *args)
36 config = Config::Getinstance(args);
37 std::string pluginpath = config->getPluginPath();
40 printf("Current path is %s\n", pluginpath.c_str());
44 fprintf(stderr, "Pluin path does not exist\n");
47 registerAllPlugin(pluginpath);
50 FelixAdapter::~FelixAdapter(void)
53 s_pinstance->deleteinstance();
57 int FelixAdapter::installPlugin(const std::string path)
62 int FelixAdapter::findPluginRecursive(const std::string path)
67 int FelixAdapter::loadPluginInfoToManager(const std::string path)
72 int FelixAdapter::registerPlugin(const std::string path)
76 printf("FelixAdapter path == null\n");
81 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
83 jstring jpath = env->NewStringUTF(path.c_str());
84 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
85 jmethodID mid = env->GetStaticMethodID(cls, "registerPlugin", "(Ljava/lang/String;)I");
87 // call registerPlugin() function
88 return (int)env->CallStaticIntMethod(cls, mid, jpath);
91 int FelixAdapter::registerAllPlugin(const std::string path)
95 printf("FelixAdapter path == null\n");
100 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
102 jstring jpath = env->NewStringUTF(path.c_str());
103 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
104 jmethodID mid = env->GetStaticMethodID(cls, "registerAllPlugin", "(Ljava/lang/String;)I");
106 // call registerAllPlugin() function
107 return (int)env->CallStaticIntMethod(cls, mid, jpath);
110 int FelixAdapter::unregisterPlugin(Plugin *const plugin)
113 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
115 const char *cpath = plugin->getID().c_str();
116 jstring jpath = env->NewStringUTF(cpath);
117 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
118 jmethodID mid = env->GetStaticMethodID(cls, "unregisterPlugin", "(Ljava/lang/String;)I");
120 // call unregisterPlugin() function
121 return (int)env->CallStaticIntMethod(cls, mid, jpath);
124 int FelixAdapter::unregisterAllPlugin(void)
127 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
129 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
130 jmethodID mid = env->GetStaticMethodID(cls, "unregisterAllPlugin", "()I");
132 // call registerAllPlugin() function
133 return (int)env->CallStaticIntMethod(cls, mid);
136 std::vector<Plugin> &FelixAdapter::getAllPlugins(void)
139 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
142 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
143 jmethodID mid = env->GetStaticMethodID(cls, "getAllPlugins", "()[Lorg/osgi/framework/Bundle;");
145 // call getAllPlugins() function
146 jobjectArray jresultArray = (jobjectArray)env->CallStaticObjectMethod(cls, mid);
147 jint size = env->GetArrayLength(jresultArray);
150 for (int i = 0; i < (int)size; i++)
152 Plugin *plugin = new Plugin;
154 jobject result = env->GetObjectArrayElement(jresultArray, i);
155 cls = env->GetObjectClass(result);
156 // set Language value
157 plugin->setValue("Language", "JAVA");
159 mid = env->GetMethodID(cls, "getSymbolicName", "()Ljava/lang/String;");
160 jstring jid = (jstring)env->CallObjectMethod(result, mid);
161 std::string id = env->GetStringUTFChars(jid, 0);
162 plugin->setValue("Id", id);
164 mid = env->GetMethodID(cls, "getVersion", "()Lorg/osgi/framework/Version;");
165 jobject jversion_object = env->CallObjectMethod(result, mid);
166 jclass vcls = env->GetObjectClass(jversion_object);
167 mid = env->GetMethodID(vcls, "toString", "()Ljava/lang/String;");
168 jstring jversion = (jstring)env->CallObjectMethod(jversion_object, mid);
169 std::string version = env->GetStringUTFChars(jversion, 0);
170 plugin->setValue("Version", version);
172 cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
173 mid = env->GetStaticMethodID(cls, "getValue",
174 "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");
175 std::string key = "Name";
176 jstring jname = (jstring)env->CallStaticObjectMethod(cls, mid, jid,
177 env->NewStringUTF(key.c_str()));
178 std::string name = env->GetStringUTFChars(jname, 0);
179 plugin->setValue("Name", name);
180 // set ResourceType value
181 key = "ResourceType";
182 jstring jresourcetype = (jstring)env->CallStaticObjectMethod(cls, mid, jid,
183 env->NewStringUTF(key.c_str()));
184 std::string resourcetype = env->GetStringUTFChars(jresourcetype, 0);
185 plugin->setValue("ResourceType", resourcetype);
187 // set ResourceURL value
189 jstring juritype = (jstring)env->CallStaticObjectMethod(cls, mid, jid,
190 env->NewStringUTF(key.c_str()));
191 std::string url = env->GetStringUTFChars(juritype, 0);
192 plugin->setValue("Url", url);
194 // push the plugin into the vector
195 m_plugins.push_back(*plugin);
201 std::vector<Plugin> *FelixAdapter::findPlugins(const std::string key, const std::string value)
204 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
206 jstring jkey = env->NewStringUTF(key.c_str());
207 jstring jvalue = env->NewStringUTF(value.c_str());
209 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
210 jmethodID mid = env->GetStaticMethodID(cls, "findPlugins",
211 "(Ljava/lang/String;Ljava/lang/String;)[Lorg/osgi/framework/Bundle;");
213 // call findPlugins() function
214 jobjectArray jresultArray = (jobjectArray)env->CallStaticObjectMethod(cls, mid, (jstring)jkey,
217 jint size = env->GetArrayLength(jresultArray);
219 std::vector<Plugin> *re_plugins;
220 re_plugins = new std::vector<Plugin>;
222 for (int i = 0; i < (int)size; i++)
224 Plugin *plugin = new Plugin;
226 jobject result = env->GetObjectArrayElement(jresultArray, i);
227 cls = env->GetObjectClass(result);
228 // set Language value
229 plugin->setValue("Language", "JAVA");
231 mid = env->GetMethodID(cls, "getSymbolicName", "()Ljava/lang/String;");
232 jstring jid = (jstring)env->CallObjectMethod(result, mid);
233 std::string id = env->GetStringUTFChars(jid, 0);
234 plugin->setValue("Id", id);
236 mid = env->GetMethodID(cls, "getVersion", "()Lorg/osgi/framework/Version;");
237 jobject jversion_object = env->CallObjectMethod(result, mid);
238 jclass vcls = env->GetObjectClass(jversion_object);
239 mid = env->GetMethodID(vcls, "toString", "()Ljava/lang/String;");
240 jstring jversion = (jstring)env->CallObjectMethod(jversion_object, mid);
241 std::string version = env->GetStringUTFChars(jversion, 0);
242 plugin->setValue("Version", version);
244 cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
245 mid = env->GetStaticMethodID(cls, "getValue",
246 "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");
247 std::string key = "Name";
248 jstring jname = (jstring)env->CallStaticObjectMethod(cls, mid, jid,
249 env->NewStringUTF(key.c_str()));
250 std::string name = env->GetStringUTFChars(jname, 0);
251 plugin->setValue("Name", name);
252 // set ResourceType value
253 key = "ResourceType";
254 jstring jresourcetype = (jstring)env->CallStaticObjectMethod(cls, mid, jid,
255 env->NewStringUTF(key.c_str()));
256 std::string resourcetype = env->GetStringUTFChars(jresourcetype, 0);
257 plugin->setValue("ResourceType", resourcetype);
258 // push the plugin into the vector
259 m_plugins.push_back(*plugin);
265 Plugin *FelixAdapter::getPlugin(const std::string plugID)
270 bool FelixAdapter::getFileList(File_list &list, const std::string strDir)
276 void FelixAdapter::printPluginList(cp_plugin_info_t **plugins)
281 int FelixAdapter::start(Plugin *const plugin, void *const arg)
284 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
286 const char *cid = plugin->getID().c_str();
287 jstring jid = env->NewStringUTF(cid);
288 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
289 jmethodID mid = env->GetStaticMethodID(cls, "start", "(Ljava/lang/String;)I");
291 // call start() function
292 return (int)env->CallStaticIntMethod(cls, mid, jid);
295 int FelixAdapter::stop(Plugin *const plugin)
298 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
300 const char *cid = plugin->getID().c_str();
301 jstring jid = env->NewStringUTF(cid);
302 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
303 jmethodID mid = env->GetStaticMethodID(cls, "stop", "(Ljava/lang/String;)I");
305 // call stop() function
306 return (int)env->CallStaticIntMethod(cls, mid, jid);
309 bool FelixAdapter::isStarted(Plugin *plugin)
312 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
314 const char *cid = plugin->getID().c_str();
315 jstring jid = env->NewStringUTF(cid);
316 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
317 jmethodID mid = env->GetStaticMethodID(cls, "isStarted", "(Ljava/lang/String;)Z");
319 // call isStarted() function
320 return (bool)env->CallStaticBooleanMethod(cls, mid, jid);
324 void FelixAdapter::observePluginPath(void *str)
330 const std::string FelixAdapter::getState(const std::string plugID)
333 jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
335 jstring jplugID = env->NewStringUTF(plugID.c_str());
336 jclass cls = env->FindClass("org/iotivity/service/ppm/FelixManager");
337 jmethodID mid = env->GetStaticMethodID(cls, "getState",
338 "(Ljava/lang/String;)Ljava/lang/String;");
340 // call getState() function
341 jstring jresult = (jstring)env->CallStaticObjectMethod(cls, mid, jplugID);
342 return env->GetStringUTFChars(jresult, 0);