service/simulator/java/jni/simulator_manager_jni.cpp

   1 /******************************************************************
   2  *
   3  * Copyright 2015 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 #include "simulator_manager_jni.h"
  22 #include "simulator_resource_server_jni.h"
  23 #include "simulator_common_jni.h"
  24 #include "simulator_manager.h"
  25 #include "simulator_remote_resource_jni.h"
  26 #include "simulator_resource_model_jni.h"
  27 #include "simulator_device_info_jni.h"
  28 #include "simulator_platform_info_jni.h"
  29 #include "simulator_resource_jni_util.h"
  30 #include "simulator_jni_utils.h"
  31
  32 SimulatorClassRefs gSimulatorClassRefs;
  33 std::mutex gEnvMutex;
  34 JavaVM *gvm;
  35
  36 JNIEnv *getEnv()
  37 {
  38     std::unique_lock<std::mutex> lock(gEnvMutex);
  39     if (nullptr == gvm)
  40         return NULL;
  41
  42     JNIEnv *env = NULL;
  43     jint ret = gvm->GetEnv((void **)&env, JNI_VERSION_1_6);
  44     switch (ret)
  45     {
  46         case JNI_OK:
  47             return env;
  48         case JNI_EDETACHED:
  49             if (0 == gvm->AttachCurrentThread((void **)&env, NULL))
  50                 return env;
  51     }
  52
  53     return NULL;
  54 }
  55
  56 void releaseEnv()
  57 {
  58     std::unique_lock<std::mutex> lock(gEnvMutex);
  59     if (nullptr == gvm)
  60         return;
  61     gvm->DetachCurrentThread();
  62 }
  63
  64 class JNILogger : public ILogger
  65 {
  66     public:
  67         void setJavaLogger(JNIEnv *env, jobject logger)
  68         {
  69             m_logger = env->NewWeakGlobalRef(logger);
  70         }
  71
  72         void write(std::string time, ILogger::Level level, std::string message)
  73         {
  74             JNIEnv *env = getEnv();
  75             if (nullptr == env)
  76                 return;
  77
  78             jobject logger = env->NewLocalRef(m_logger);
  79             if (!logger)
  80             {
  81                 releaseEnv();
  82                 return;
  83             }
  84
  85             jclass loggerCls = env->GetObjectClass(logger);
  86             if (!loggerCls)
  87             {
  88                 releaseEnv();
  89                 return;
  90             }
  91
  92             jmethodID writeMId = env->GetMethodID(loggerCls, "write",
  93                                                   "(Ljava/lang/String;ILjava/lang/String;)V");
  94             if (!writeMId)
  95             {
  96                 releaseEnv();
  97                 return;
  98             }
  99
 100             jstring msg = env->NewStringUTF(message.c_str());
 101             jstring timeStr = env->NewStringUTF(time.c_str());
 102             env->CallVoidMethod(logger, writeMId, timeStr, static_cast<jint>(level), msg);
 103             env->DeleteLocalRef(msg);
 104             env->DeleteLocalRef(timeStr);
 105             releaseEnv();
 106         }
 107
 108     private:
 109         jweak m_logger;
 110 };
 111
 112
 113 jobject SimulatorRemoteResourceToJava(JNIEnv *env, jlong resource)
 114 {
 115     jmethodID constructor = env->GetMethodID(gSimulatorClassRefs.classSimulatorRemoteResource, "<init>",
 116                             "(J)V");
 117     if (NULL == constructor)
 118     {
 119         return NULL;
 120     }
 121
 122     jobject resourceObj = (jobject) env->NewObject(gSimulatorClassRefs.classSimulatorRemoteResource,
 123                           constructor, resource);
 124     if (NULL == resourceObj)
 125     {
 126         return NULL;
 127     }
 128
 129     return resourceObj;
 130 }
 131
 132 class JNIFoundResourceListener
 133 {
 134     public:
 135         void setJavaFoundResourceListener(JNIEnv *env, jobject listener)
 136         {
 137             m_listener = env->NewWeakGlobalRef(listener);
 138         }
 139
 140         void onFoundResource(std::shared_ptr<SimulatorRemoteResource> resource)
 141         {
 142             JNIEnv *env = getEnv();
 143             if (nullptr == env)
 144                 return;
 145
 146             jobject foundResourceListener = env->NewLocalRef(m_listener);
 147             if (!foundResourceListener)
 148             {
 149                 releaseEnv();
 150                 return;
 151             }
 152
 153             jclass foundResourceCls = env->GetObjectClass(foundResourceListener);
 154             if (!foundResourceCls)
 155             {
 156                 releaseEnv();
 157                 return;
 158             }
 159
 160             jmethodID foundResourceMId = env->GetMethodID(foundResourceCls, "onResourceCallback",
 161                                          "(Lorg/oic/simulator/clientcontroller/SimulatorRemoteResource;)V");
 162             if (!foundResourceMId)
 163             {
 164                 releaseEnv();
 165                 return;
 166             }
 167
 168             JniSimulatorRemoteResource *jniSimulatorResource = new JniSimulatorRemoteResource(resource);
 169             if (!jniSimulatorResource)
 170             {
 171                 releaseEnv();
 172                 return;
 173             }
 174
 175             jobject simulatorResource = SimulatorRemoteResourceToJava(env,
 176                                         reinterpret_cast<jlong>(jniSimulatorResource));
 177
 178             jfieldID fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mUri",
 179                                                "Ljava/lang/String;");
 180             jstring jUri = env->NewStringUTF(resource->getURI().c_str());
 181             env->SetObjectField(simulatorResource, fieldID, jUri);
 182
 183             fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mConnType", "I");
 184             jint jConnType = resource->getConnectivityType();
 185             env->SetIntField(simulatorResource, fieldID, jConnType);
 186
 187             fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mHost",
 188                                       "Ljava/lang/String;");
 189             jstring jHost = env->NewStringUTF(resource->getHost().c_str());
 190             env->SetObjectField(simulatorResource, fieldID, jHost);
 191
 192             fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mId",
 193                                       "Ljava/lang/String;");
 194             jstring jUid = env->NewStringUTF(resource->getID().c_str());
 195             env->SetObjectField(simulatorResource, fieldID, jUid);
 196
 197             fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResTypes",
 198                                       "Ljava/util/LinkedList;");
 199             std::vector<std::string> resourceTypes = resource->getResourceTypes();
 200             jobject jResTypes = convertStringVectorToJavaList(env, resourceTypes);
 201             env->SetObjectField(simulatorResource, fieldID, jResTypes);
 202
 203             fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResInterfaces",
 204                                       "Ljava/util/LinkedList;");
 205             std::vector<std::string> interfaceTypes = resource->getResourceInterfaces();
 206             jobject jResInterfaces = convertStringVectorToJavaList(env, interfaceTypes);
 207             env->SetObjectField(simulatorResource, fieldID, jResInterfaces);
 208
 209             fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mIsObservable", "Z");
 210             env->SetBooleanField(simulatorResource, fieldID, resource->isObservable());
 211
 212             env->CallVoidMethod(foundResourceListener, foundResourceMId, simulatorResource);
 213             if ((env)->ExceptionCheck())
 214             {
 215                 delete jniSimulatorResource;
 216                 releaseEnv();
 217                 return;
 218             }
 219
 220             releaseEnv();
 221         }
 222
 223     private:
 224         jweak m_listener;
 225
 226 };
 227
 228 void onResourceModelChange(jweak jlistenerRef, const std::string &uri,
 229                            const SimulatorResourceModel &resModel)
 230 {
 231     JNIEnv *env = getEnv();
 232     if (nullptr == env)
 233         return;
 234
 235     jobject modelChangeListener = env->NewLocalRef(jlistenerRef);
 236     if (!modelChangeListener)
 237     {
 238         releaseEnv();
 239         return;
 240     }
 241
 242     jclass modelChangeCls = env->GetObjectClass(modelChangeListener);
 243     if (!modelChangeCls)
 244     {
 245         releaseEnv();
 246         return;
 247     }
 248
 249     jmethodID foundModelChangeMId = env->GetMethodID(modelChangeCls, "onResourceModelChanged",
 250                                     "(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;)V");
 251     if (!foundModelChangeMId)
 252     {
 253         releaseEnv();
 254         return;
 255     }
 256
 257     JSimulatorResourceModel *jniModel = new JSimulatorResourceModel(resModel);
 258     if (!jniModel)
 259     {
 260         releaseEnv();
 261         return;
 262     }
 263
 264     jobject jModel = JSimulatorResourceModel::toJava(env, reinterpret_cast<jlong>(jniModel));
 265     jstring jUri = env->NewStringUTF(uri.c_str());
 266     env->CallVoidMethod(modelChangeListener, foundModelChangeMId, jUri, jModel);
 267     if ((env)->ExceptionCheck())
 268     {
 269         delete jniModel;
 270         releaseEnv();
 271         return;
 272     }
 273
 274     env->DeleteLocalRef(jUri);
 275
 276     releaseEnv();
 277 }
 278
 279
 280 JNIEXPORT jobject JNICALL
 281 Java_org_oic_simulator_SimulatorManagerNativeInterface_createResource
 282 (JNIEnv *env, jclass object, jstring configPath, jobject listener)
 283 {
 284     if (!configPath)
 285     {
 286         throwInvalidArgsException(env, SIMULATOR_INVALID_PARAM,
 287                                   "Configuration file path is empty!");
 288         return nullptr;
 289     }
 290
 291     if (!listener)
 292     {
 293         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK,
 294                                   "Resource model change callback not set!");
 295         return nullptr;
 296     }
 297
 298     jweak jlistenerRef = env->NewWeakGlobalRef(listener);
 299     SimulatorResourceServer::ResourceModelChangedCB callback =  [jlistenerRef](const std::string & uri,
 300             const SimulatorResourceModel & resModel)
 301     {
 302         onResourceModelChange(jlistenerRef, uri, resModel);
 303     };
 304
 305     const char *configPathCStr = env->GetStringUTFChars(configPath, NULL);
 306     SimulatorResourceServerSP resource = NULL;
 307     try
 308     {
 309         resource = SimulatorManager::getInstance()->createResource(
 310                        configPathCStr, callback);
 311         if (nullptr == resource)
 312         {
 313             if (configPathCStr)
 314                 env->ReleaseStringUTFChars(configPath, configPathCStr);
 315             return NULL;
 316         }
 317     }
 318     catch (InvalidArgsException &e)
 319     {
 320         throwInvalidArgsException(env, e.code(), e.what());
 321         return nullptr;
 322     }
 323     catch (SimulatorException &e)
 324     {
 325         throwSimulatorException(env, e.code(), e.what());
 326         return nullptr;
 327     }
 328     catch (...)
 329     {
 330         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 331         return nullptr;
 332     }
 333
 334     JniSimulatorResource *jniSimResource = new JniSimulatorResource(resource);
 335     jobject jSimulatorResource = JniSimulatorResource::toJava(env,
 336                                  reinterpret_cast<jlong>(jniSimResource));
 337
 338     jniSimResource->setResourceInfo(env, jSimulatorResource);
 339
 340     if (configPathCStr)
 341         env->ReleaseStringUTFChars(configPath, configPathCStr);
 342     return jSimulatorResource;
 343 }
 344
 345 JNIEXPORT jobjectArray JNICALL
 346 Java_org_oic_simulator_SimulatorManagerNativeInterface_createResources
 347 (JNIEnv *env, jclass object, jstring configPath, jint count, jobject listener)
 348 {
 349     if (!configPath)
 350     {
 351         throwInvalidArgsException(env, SIMULATOR_INVALID_PARAM,
 352                                   "Configuration file path is empty!");
 353         return nullptr;
 354     }
 355
 356     if (!listener)
 357     {
 358         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK,
 359                                   "Resource model change callback not set!");
 360         return nullptr;
 361     }
 362
 363     jweak jlistenerRef = env->NewWeakGlobalRef(listener);
 364     SimulatorResourceServer::ResourceModelChangedCB callback =  [jlistenerRef](const std::string & uri,
 365             const SimulatorResourceModel & resModel)
 366     {
 367         onResourceModelChange(jlistenerRef, uri, resModel);
 368     };
 369
 370     const char *configPathCStr = env->GetStringUTFChars(configPath, NULL);
 371     std::vector<SimulatorResourceServerSP> resources;
 372     try
 373     {
 374         resources = SimulatorManager::getInstance()->createResource(configPathCStr, count, callback);
 375     }
 376     catch (InvalidArgsException &e)
 377     {
 378         throwInvalidArgsException(env, e.code(), e.what());
 379         return nullptr;
 380     }
 381     catch (SimulatorException &e)
 382     {
 383         throwSimulatorException(env, e.code(), e.what());
 384         return nullptr;
 385     }
 386     catch (...)
 387     {
 388         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 389         return nullptr;
 390     }
 391
 392     // Construct the object array and send it java layer
 393     jobjectArray resourceArray = env->NewObjectArray(resources.size(),
 394                                  gSimulatorClassRefs.classSimulatorResource, NULL);
 395     if (resourceArray)
 396     {
 397         for (size_t i = 0; i < resources.size(); i++)
 398         {
 399             JniSimulatorResource *jniSimResource = new JniSimulatorResource(resources[i]);
 400             jobject jSimulatorResource = JniSimulatorResource::toJava(env,
 401                                          reinterpret_cast<jlong>(jniSimResource));
 402             jniSimResource->setResourceInfo(env, jSimulatorResource);
 403             env->SetObjectArrayElement(resourceArray, i, jSimulatorResource);
 404         }
 405     }
 406
 407     if (configPathCStr)
 408         env->ReleaseStringUTFChars(configPath, configPathCStr);
 409     return resourceArray;
 410 }
 411
 412 JNIEXPORT void JNICALL
 413 Java_org_oic_simulator_SimulatorManagerNativeInterface_deleteResource
 414 (JNIEnv *env, jclass object, jobject jResource)
 415 {
 416     if (!jResource)
 417     {
 418         throwInvalidArgsException(env, SIMULATOR_INVALID_PARAM,
 419                                   "No resource has been passed!");
 420         return;
 421     }
 422
 423     SimulatorResourceServerSP resource =
 424         JniSimulatorResource::getJniSimulatorResourceSP(env, jResource);
 425     if (!resource)
 426     {
 427         throwSimulatorException(env, SIMULATOR_BAD_OBJECT,
 428                                 "Simulator resource not found!");
 429         return;
 430     }
 431
 432     try
 433     {
 434         SimulatorManager::getInstance()->deleteResource(resource);
 435     }
 436     catch (InvalidArgsException &e)
 437     {
 438         throwInvalidArgsException(env, e.code(), e.what());
 439     }
 440     catch (...)
 441     {
 442         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 443     }
 444 }
 445
 446 JNIEXPORT void JNICALL
 447 Java_org_oic_simulator_SimulatorManagerNativeInterface_deleteResources
 448 (JNIEnv *env, jclass object, jstring resourceType)
 449 {
 450     std::string type;
 451     const char *typeCStr = NULL;
 452     if (resourceType)
 453     {
 454         typeCStr = env->GetStringUTFChars(resourceType, NULL);
 455         type = typeCStr;
 456     }
 457
 458     try
 459     {
 460         SimulatorManager::getInstance()->deleteResource(type);
 461     }
 462     catch (...)
 463     {
 464         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 465         return;
 466     }
 467
 468     if (typeCStr)
 469         env->ReleaseStringUTFChars(resourceType, typeCStr);
 470 }
 471
 472 JNIEXPORT void JNICALL
 473 Java_org_oic_simulator_SimulatorManagerNativeInterface_findResource
 474 (JNIEnv *env, jobject object, jstring jResourceType, jobject jListener)
 475 {
 476     if (!jListener)
 477     {
 478         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 479         return;
 480     }
 481
 482     const char *typeCStr = NULL;
 483     std::string resourceType;
 484     if (jResourceType)
 485     {
 486         typeCStr = env->GetStringUTFChars(jResourceType, NULL);
 487         resourceType = typeCStr;
 488     }
 489
 490     JNIFoundResourceListener *resourceListener = new JNIFoundResourceListener();
 491     resourceListener->setJavaFoundResourceListener(env, jListener);
 492
 493     try
 494     {
 495         if (!jResourceType)
 496         {
 497             SimulatorManager::getInstance()->findResource(
 498                 std::bind(&JNIFoundResourceListener::onFoundResource,
 499                           resourceListener, std::placeholders::_1));
 500         }
 501         else
 502         {
 503             SimulatorManager::getInstance()->findResource(resourceType,
 504                     std::bind(&JNIFoundResourceListener::onFoundResource,
 505                               resourceListener, std::placeholders::_1));
 506         }
 507
 508     }
 509     catch (InvalidArgsException &e)
 510     {
 511         throwInvalidArgsException(env, e.code(), e.what());
 512         return;
 513     }
 514     catch (SimulatorException &e)
 515     {
 516         throwSimulatorException(env, e.code(), e.what());
 517         return;
 518     }
 519     catch (...)
 520     {
 521         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 522         return;
 523     }
 524
 525     if (typeCStr)
 526         env->ReleaseStringUTFChars(jResourceType, typeCStr);
 527 }
 528
 529
 530 JNIEXPORT void JNICALL
 531 Java_org_oic_simulator_SimulatorManagerNativeInterface_setLogger
 532 (JNIEnv *env, jclass object, jobject logger)
 533 {
 534     static std::shared_ptr<JNILogger> target(new JNILogger());
 535     target->setJavaLogger(env, logger);
 536     SimulatorManager::getInstance()->setLogger(target);
 537 }
 538
 539 JNIEXPORT void JNICALL
 540 Java_org_oic_simulator_SimulatorManagerNativeInterface_setDeviceInfo
 541 (JNIEnv *env, jobject interfaceObject, jstring deviceInfo)
 542 {
 543     if (!deviceInfo)
 544     {
 545         throwInvalidArgsException(env, SIMULATOR_INVALID_PARAM, "Invalid device info!");
 546         return;
 547     }
 548
 549     const char *deviceName = env->GetStringUTFChars(deviceInfo, NULL);
 550
 551     try
 552     {
 553         SimulatorManager::getInstance()->setDeviceInfo(deviceName);
 554     }
 555     catch (InvalidArgsException &e)
 556     {
 557         throwInvalidArgsException(env, e.code(), e.what());
 558     }
 559     catch (SimulatorException &e)
 560     {
 561         throwSimulatorException(env, e.code(), e.what());
 562     }
 563     catch (...)
 564     {
 565         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 566         return;
 567     }
 568
 569     env->ReleaseStringUTFChars(deviceInfo, deviceName);
 570 }
 571
 572 JNIEXPORT void JNICALL
 573 Java_org_oic_simulator_SimulatorManagerNativeInterface_getDeviceInfo
 574 (JNIEnv *env, jobject interfaceObject, jobject jListener)
 575 {
 576     if (!jListener)
 577     {
 578         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 579         return;
 580     }
 581
 582     JniDeviceInfoListener *deviceInfoListener = new JniDeviceInfoListener(env, jListener);
 583     DeviceInfoCallback callback = std::bind([deviceInfoListener](DeviceInfo & deviceInfo)
 584     {
 585         deviceInfoListener->onDeviceInfoReceived(deviceInfo);
 586         delete deviceInfoListener;
 587     }, std::placeholders::_1);
 588
 589     try
 590     {
 591         SimulatorManager::getInstance()->getDeviceInfo(callback);
 592     }
 593     catch (InvalidArgsException &e)
 594     {
 595         throwInvalidArgsException(env, e.code(), e.what());
 596     }
 597     catch (SimulatorException &e)
 598     {
 599         throwSimulatorException(env, e.code(), e.what());
 600     }
 601     catch (...)
 602     {
 603         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 604         return;
 605     }
 606 }
 607
 608 JNIEXPORT void JNICALL
 609 Java_org_oic_simulator_SimulatorManagerNativeInterface_setPlatformInfo
 610 (JNIEnv *env, jobject interfaceObject, jobject jPlatformInfo)
 611 {
 612     if (!jPlatformInfo)
 613     {
 614         throwInvalidArgsException(env, SIMULATOR_INVALID_PARAM, "Invalid platform info!");
 615         return;
 616     }
 617
 618     JPlatformInfo jniPlatformInfo(env);
 619     try
 620     {
 621         PlatformInfo platformInfo = jniPlatformInfo.toCPP(jPlatformInfo);
 622         SimulatorManager::getInstance()->setPlatformInfo(platformInfo);
 623     }
 624     catch (SimulatorException &e)
 625     {
 626         throwSimulatorException(env, e.code(), e.what());
 627     }
 628     catch (...)
 629     {
 630         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 631         return;
 632     }
 633 }
 634
 635 JNIEXPORT void JNICALL
 636 Java_org_oic_simulator_SimulatorManagerNativeInterface_getPlatformInfo
 637 (JNIEnv *env, jobject interfaceObject, jobject jListener)
 638 {
 639     if (!jListener)
 640     {
 641         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 642         return;
 643     }
 644
 645     JniPlatformInfoListener *platformInfoListener = new JniPlatformInfoListener(env, jListener);
 646     PlatformInfoCallback callback = std::bind([platformInfoListener](PlatformInfo & platformInfo)
 647     {
 648         platformInfoListener->onPlatformInfoReceived(platformInfo);
 649         delete platformInfoListener;
 650     }, std::placeholders::_1);
 651
 652     try
 653     {
 654         SimulatorManager::getInstance()->getPlatformInfo(callback);
 655     }
 656     catch (InvalidArgsException &e)
 657     {
 658         throwInvalidArgsException(env, e.code(), e.what());
 659     }
 660     catch (SimulatorException &e)
 661     {
 662         throwSimulatorException(env, e.code(), e.what());
 663     }
 664     catch (...)
 665     {
 666         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 667         return;
 668     }
 669 }
 670
 671 static bool getClassRef(JNIEnv *env, const char *className, jclass &classRef)
 672 {
 673     jclass localClassRef = nullptr;
 674     localClassRef = env->FindClass(className);
 675     if (!localClassRef)
 676         return false;
 677
 678     classRef = (jclass)env->NewGlobalRef(localClassRef);
 679     env->DeleteLocalRef(localClassRef);
 680     return true;
 681 }
 682
 683 #ifdef __cplusplus
 684 extern "C" {
 685 #endif
 686 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
 687 {
 688     if (!vm)
 689     {
 690         return JNI_ERR;
 691     }
 692
 693     JNIEnv *env = NULL;
 694     if (JNI_OK != vm->GetEnv((void **) &env, JNI_VERSION_1_6))
 695     {
 696         return JNI_ERR;
 697     }
 698
 699     // Get the class references
 700     if (false == getClassRef(env, "java/lang/Object", gSimulatorClassRefs.classObject))
 701     {
 702         return JNI_ERR;
 703     }
 704
 705     if (false == getClassRef(env, "java/lang/Integer", gSimulatorClassRefs.classInteger))
 706     {
 707         return JNI_ERR;
 708     }
 709
 710     if (false == getClassRef(env, "java/lang/Double", gSimulatorClassRefs.classDouble))
 711     {
 712         return JNI_ERR;
 713     }
 714
 715     if (false == getClassRef(env, "java/lang/String", gSimulatorClassRefs.classString))
 716     {
 717         return JNI_ERR;
 718     }
 719
 720     if (false == getClassRef(env, "java/util/HashMap", gSimulatorClassRefs.classHashMap))
 721     {
 722         return JNI_ERR;
 723     }
 724
 725     if (false == getClassRef(env, "java/util/Vector", gSimulatorClassRefs.classVector))
 726     {
 727         return JNI_ERR;
 728     }
 729
 730     if (false == getClassRef(env, "java/util/Map", gSimulatorClassRefs.classMap))
 731     {
 732         return JNI_ERR;
 733     }
 734
 735     if (false == getClassRef(env, "java/util/Map$Entry", gSimulatorClassRefs.classMapEntry))
 736     {
 737         return JNI_ERR;
 738     }
 739
 740     if (false == getClassRef(env, "java/util/Set", gSimulatorClassRefs.classSet))
 741     {
 742         return JNI_ERR;
 743     }
 744
 745     if (false == getClassRef(env, "java/util/Iterator", gSimulatorClassRefs.classIterator))
 746     {
 747         return JNI_ERR;
 748     }
 749
 750     if (false == getClassRef(env, "java/util/LinkedList", gSimulatorClassRefs.classLinkedList))
 751     {
 752         return JNI_ERR;
 753     }
 754
 755     if (false == getClassRef(env, "org/oic/simulator/serviceprovider/SimulatorResourceServer",
 756                              gSimulatorClassRefs.classSimulatorResource))
 757     {
 758         return JNI_ERR;
 759     }
 760
 761     if (false == getClassRef(env, "org/oic/simulator/SimulatorResourceModel",
 762                              gSimulatorClassRefs.classSimulatorResourceModel))
 763     {
 764         return JNI_ERR;
 765     }
 766
 767     if (false == getClassRef(env, "org/oic/simulator/ResourceAttribute",
 768                              gSimulatorClassRefs.classResourceAttribute))
 769     {
 770         return JNI_ERR;
 771     }
 772
 773     if (false == getClassRef(env, "org/oic/simulator/clientcontroller/SimulatorRemoteResource",
 774                              gSimulatorClassRefs.classSimulatorRemoteResource))
 775     {
 776         return JNI_ERR;
 777     }
 778
 779     if (false == getClassRef(env, "org/oic/simulator/serviceprovider/ObserverInfo",
 780                              gSimulatorClassRefs.classObserverInfo))
 781     {
 782         return JNI_ERR;
 783     }
 784
 785     if (false == getClassRef(env, "org/oic/simulator/DeviceInfo",
 786                              gSimulatorClassRefs.classDeviceInfo))
 787     {
 788         return JNI_ERR;
 789     }
 790
 791     if (false == getClassRef(env, "org/oic/simulator/PlatformInfo",
 792                              gSimulatorClassRefs.classPlatformInfo))
 793     {
 794         return JNI_ERR;
 795     }
 796
 797     if (false == getClassRef(env, "org/oic/simulator/SimulatorException",
 798                              gSimulatorClassRefs.classSimulatorException))
 799     {
 800         return JNI_ERR;
 801     }
 802
 803     if (false == getClassRef(env, "org/oic/simulator/InvalidArgsException",
 804                              gSimulatorClassRefs.classInvalidArgsException))
 805     {
 806         return JNI_ERR;
 807     }
 808
 809     if (false == getClassRef(env, "org/oic/simulator/NoSupportException",
 810                              gSimulatorClassRefs.classNoSupportException))
 811     {
 812         return JNI_ERR;
 813     }
 814
 815     if (false == getClassRef(env, "org/oic/simulator/OperationInProgressException",
 816                              gSimulatorClassRefs.classOperationInProgressException))
 817     {
 818         return JNI_ERR;
 819     }
 820
 821     // Get the reference to methods
 822     gSimulatorClassRefs.classIntegerCtor = env->GetMethodID(gSimulatorClassRefs.classInteger, "<init>",
 823                                            "(I)V");
 824     if (!gSimulatorClassRefs.classIntegerCtor)
 825         return JNI_ERR;
 826
 827     gSimulatorClassRefs.classDoubleCtor = env->GetMethodID(gSimulatorClassRefs.classDouble, "<init>",
 828                                           "(D)V");
 829     if (!gSimulatorClassRefs.classDoubleCtor)
 830         return JNI_ERR;
 831
 832     gSimulatorClassRefs.classHashMapCtor = env->GetMethodID(gSimulatorClassRefs.classHashMap, "<init>",
 833                                            "()V");
 834     if (!gSimulatorClassRefs.classHashMapCtor)
 835         return JNI_ERR;
 836
 837     gSimulatorClassRefs.classHashMapPut = env->GetMethodID(gSimulatorClassRefs.classHashMap, "put",
 838                                           "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
 839     if (!gSimulatorClassRefs.classHashMapPut)
 840         return JNI_ERR;
 841
 842     gSimulatorClassRefs.classVectorCtor = env->GetMethodID(gSimulatorClassRefs.classVector, "<init>",
 843                                           "()V");
 844     if (!gSimulatorClassRefs.classVectorCtor)
 845         return JNI_ERR;
 846
 847     gSimulatorClassRefs.classVectorAddElement = env->GetMethodID(gSimulatorClassRefs.classVector,
 848             "addElement",
 849             "(Ljava/lang/Object;)V");
 850     if (!gSimulatorClassRefs.classVectorAddElement)
 851         return JNI_ERR;
 852
 853     gSimulatorClassRefs.classMapEntrySet = env->GetMethodID(
 854             gSimulatorClassRefs.classMap, "entrySet", "()Ljava/util/Set;");
 855     if (!gSimulatorClassRefs.classMapEntrySet)
 856         return JNI_ERR;
 857
 858     gSimulatorClassRefs.classMapGetKey = env->GetMethodID(
 859             gSimulatorClassRefs.classMapEntry, "getKey", "()Ljava/lang/Object;");
 860     if (!gSimulatorClassRefs.classMapGetKey)
 861         return JNI_ERR;
 862
 863     gSimulatorClassRefs.classMapGetValue = env->GetMethodID(
 864             gSimulatorClassRefs.classMapEntry, "getValue", "()Ljava/lang/Object;");
 865     if (!gSimulatorClassRefs.classMapGetValue)
 866         return JNI_ERR;
 867
 868     gSimulatorClassRefs.classIteratorId = env->GetMethodID(
 869             gSimulatorClassRefs.classSet, "iterator", "()Ljava/util/Iterator;");
 870     if (!gSimulatorClassRefs.classIteratorId)
 871         return JNI_ERR;
 872
 873     gSimulatorClassRefs.classHasNextId = env->GetMethodID(
 874             gSimulatorClassRefs.classIterator, "hasNext", "()Z");
 875     if (!gSimulatorClassRefs.classHasNextId)
 876         return JNI_ERR;
 877
 878     gSimulatorClassRefs.classNextId = env->GetMethodID(
 879                                           gSimulatorClassRefs.classIterator, "next", "()Ljava/lang/Object;");
 880     if (!gSimulatorClassRefs.classNextId)
 881         return JNI_ERR;
 882
 883     gSimulatorClassRefs.classLinkedListCtor = env->GetMethodID(gSimulatorClassRefs.classLinkedList,
 884             "<init>", "()V");
 885     if (!gSimulatorClassRefs.classLinkedListCtor)
 886         return JNI_ERR;
 887
 888     gSimulatorClassRefs.classLinkedListAddObject = env->GetMethodID(gSimulatorClassRefs.classLinkedList,
 889             "add", "(Ljava/lang/Object;)Z");
 890     if (!gSimulatorClassRefs.classLinkedListAddObject)
 891         return JNI_ERR;
 892
 893     gSimulatorClassRefs.classSimulatorResourceCtor = env->GetMethodID(
 894                 gSimulatorClassRefs.classSimulatorResource, "<init>", "(J)V");
 895     if (!gSimulatorClassRefs.classSimulatorResourceCtor)
 896         return JNI_ERR;
 897
 898     gSimulatorClassRefs.classSimulatorResourceModelCtor = env->GetMethodID(
 899                 gSimulatorClassRefs.classSimulatorResourceModel, "<init>", "(J)V");
 900     if (!gSimulatorClassRefs.classSimulatorResourceModelCtor)
 901         return JNI_ERR;
 902
 903     gSimulatorClassRefs.classResourceAttributeCtor = env->GetMethodID(
 904                 gSimulatorClassRefs.classResourceAttribute, "<init>", "()V");
 905     if (!gSimulatorClassRefs.classResourceAttributeCtor)
 906         return JNI_ERR;
 907
 908     gSimulatorClassRefs.classResourceAttributeSetRange = env->GetMethodID(
 909                 gSimulatorClassRefs.classResourceAttribute, "setRange", "(II)V");
 910     if (!gSimulatorClassRefs.classResourceAttributeSetRange)
 911         return JNI_ERR;
 912
 913     gSimulatorClassRefs.classSimulatorResourceModelId = env->GetMethodID(
 914                 gSimulatorClassRefs.classSimulatorResourceModel, "<init>", "(J)V");
 915     if (!gSimulatorClassRefs.classSimulatorResourceModelId)
 916         return JNI_ERR;
 917
 918     gSimulatorClassRefs.classObserverInfoCtor = env->GetMethodID(
 919                 gSimulatorClassRefs.classObserverInfo, "<init>",
 920                 "(ILjava/lang/String;I)V");
 921     if (!gSimulatorClassRefs.classObserverInfoCtor)
 922         return JNI_ERR;
 923
 924     gSimulatorClassRefs.classSimulatorExceptionCtor = env->GetMethodID(
 925                 gSimulatorClassRefs.classSimulatorException, "<init>",
 926                 "(ILjava/lang/String;)V");
 927     if (!gSimulatorClassRefs.classSimulatorExceptionCtor)
 928         return JNI_ERR;
 929
 930     gSimulatorClassRefs.classInvalidArgsExceptionCtor = env->GetMethodID(
 931                 gSimulatorClassRefs.classInvalidArgsException, "<init>",
 932                 "(ILjava/lang/String;)V");
 933     if (!gSimulatorClassRefs.classInvalidArgsExceptionCtor)
 934         return JNI_ERR;
 935
 936     gSimulatorClassRefs.classNoSupportExceptionCtor = env->GetMethodID(
 937                 gSimulatorClassRefs.classNoSupportException, "<init>",
 938                 "(ILjava/lang/String;)V");
 939     if (!gSimulatorClassRefs.classNoSupportExceptionCtor)
 940         return JNI_ERR;
 941
 942     gSimulatorClassRefs.classOperationInProgressExceptionCtor = env->GetMethodID(
 943                 gSimulatorClassRefs.classOperationInProgressException, "<init>",
 944                 "(ILjava/lang/String;)V");
 945     if (!gSimulatorClassRefs.classOperationInProgressExceptionCtor)
 946         return JNI_ERR;
 947
 948     gvm = vm;
 949     return JNI_VERSION_1_6;
 950 }
 951
 952 JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved)
 953 {
 954 }
 955
 956 #ifdef __cplusplus
 957 }
 958 #endif