service/simulator/java/jni/simulator_remote_resource_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_remote_resource_jni.h"
  22 #include "simulator_common_jni.h"
  23 #include "simulator_error_codes.h"
  24 #include "simulator_resource_jni_util.h"
  25 #include "simulator_resource_model_jni.h"
  26 #include "simulator_client_types.h"
  27 #include "simulator_exceptions.h"
  28 #include "simulator_jni_utils.h"
  29
  30 extern SimulatorClassRefs gSimulatorClassRefs;
  31
  32 SimulatorRemoteResourceSP JniSimulatorRemoteResource::getResourceHandle
  33 (JNIEnv *env, jobject object)
  34 {
  35     JniSimulatorRemoteResource *jniResource = GetHandle<JniSimulatorRemoteResource>(env, object);
  36     if (env->ExceptionCheck() || !jniResource)
  37     {
  38         return nullptr;
  39     }
  40
  41     return jniResource->m_resource;
  42 }
  43
  44 class JNIOnObserveListener
  45 {
  46     public:
  47         void setJavaOnObserveListener(JNIEnv *env, jobject listener)
  48         {
  49             m_listener = env->NewWeakGlobalRef(listener);
  50         }
  51
  52         void onObserveCallback(const std::string &uId, const int errorCode,
  53                                SimulatorResourceModelSP representation,
  54                                const int seqNumber)
  55         {
  56             JNIEnv *env = getEnv();
  57             if (nullptr == env)
  58                 return;
  59
  60             jobject onObserveListener = env->NewLocalRef(m_listener);
  61             if (!onObserveListener)
  62             {
  63                 releaseEnv();
  64                 return;
  65             }
  66
  67             jclass onObserveCls = env->GetObjectClass(onObserveListener);
  68             if (!onObserveCls)
  69             {
  70                 releaseEnv();
  71                 return;
  72             }
  73
  74             if (OC_STACK_OK != errorCode && OC_STACK_RESOURCE_CREATED != errorCode
  75                 && OC_STACK_RESOURCE_DELETED != errorCode)
  76             {
  77                 jmethodID midL = env->GetMethodID(onObserveCls, "onObserveFailed", "(Ljava/lang/Throwable;)V");
  78                 if (!midL)
  79                 {
  80                     releaseEnv();
  81                     return;
  82                 }
  83                 env->CallVoidMethod(onObserveListener, midL);
  84             }
  85             else
  86             {
  87                 JSimulatorResourceModel *jniModel = new JSimulatorResourceModel(representation);
  88                 if (!jniModel)
  89                 {
  90                     releaseEnv();
  91                     return;
  92                 }
  93
  94                 jobject jRepresentation = JSimulatorResourceModel::toJava(env,
  95                         reinterpret_cast<jlong>(jniModel));
  96                 if (!jRepresentation)
  97                 {
  98                     delete jniModel;
  99                     releaseEnv();
 100                     return;
 101                 }
 102
 103                 jmethodID midL = env->GetMethodID(onObserveCls, "onObserveCompleted",
 104                         "(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;I)V");
 105                 if (!midL)
 106                 {
 107                     delete jniModel;
 108                     releaseEnv();
 109                     return;
 110                 }
 111
 112                 jstring jUid = env->NewStringUTF(uId.c_str());
 113
 114                 env->CallVoidMethod(onObserveListener, midL, jUid, jRepresentation,
 115                                     static_cast<jint>(seqNumber));
 116                 if (env->ExceptionCheck())
 117                 {
 118                     delete jniModel;
 119                     releaseEnv();
 120                 }
 121             }
 122         }
 123
 124     private:
 125         jweak m_listener;
 126 };
 127
 128 class JNIOnGetListener
 129 {
 130     public:
 131         void setJavaOnGetListener(JNIEnv *env, jobject listener)
 132         {
 133             m_listener = env->NewWeakGlobalRef(listener);
 134         }
 135
 136         void onGetCallback(const std::string &uId, int errorCode,
 137                            SimulatorResourceModelSP representation)
 138         {
 139             JNIEnv *env = getEnv();
 140             if (nullptr == env)
 141                 return;
 142
 143             jobject onGetListener = env->NewLocalRef(m_listener);
 144             if (!onGetListener)
 145             {
 146                 releaseEnv();
 147                 return;
 148             }
 149
 150             jclass onGetCls = env->GetObjectClass(onGetListener);
 151             if (!onGetCls)
 152             {
 153                 releaseEnv();
 154                 return;
 155             }
 156
 157             // TODO: Revisit is it required?
 158             if (OC_STACK_OK != errorCode && OC_STACK_RESOURCE_CREATED != errorCode
 159                 && OC_STACK_RESOURCE_DELETED != errorCode)
 160             {
 161                 jmethodID midL = env->GetMethodID(onGetCls, "onGetFailed", "(Ljava/lang/Throwable;)V");
 162                 if (!midL)
 163                 {
 164                     releaseEnv();
 165                     return;
 166                 }
 167                 env->CallVoidMethod(onGetListener, midL);
 168             }
 169             else
 170             {
 171                 JSimulatorResourceModel *jniModel = new JSimulatorResourceModel(representation);
 172                 if (!jniModel)
 173                 {
 174                     releaseEnv();
 175                     return;
 176                 }
 177
 178                 jobject jRepresentation = JSimulatorResourceModel::toJava(env, reinterpret_cast<jlong>(jniModel));
 179                 if (!jRepresentation)
 180                 {
 181                     delete jniModel;
 182                     releaseEnv();
 183                     return;
 184                 }
 185
 186                 jmethodID midL = env->GetMethodID(onGetCls, "onGetCompleted",
 187                                                   "(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;)V");
 188                 if (!midL)
 189                 {
 190                     delete jniModel;
 191                     releaseEnv();
 192                     return;
 193                 }
 194
 195                 jstring jUid = env->NewStringUTF(uId.c_str());
 196                 env->CallVoidMethod(onGetListener, midL, jUid, jRepresentation);
 197                 if (env->ExceptionCheck())
 198                 {
 199                     delete jniModel;
 200                     releaseEnv();
 201                 }
 202             }
 203         }
 204
 205     private:
 206         jweak m_listener;
 207 };
 208
 209 class JNIOnPutListener
 210 {
 211     public:
 212         void setJavaOnPutListener(JNIEnv *env, jobject listener)
 213         {
 214             m_listener = env->NewWeakGlobalRef(listener);
 215         }
 216
 217         void onPutCallback(const std::string &uId, int errorCode,
 218                            SimulatorResourceModelSP representation)
 219         {
 220             JNIEnv *env = getEnv();
 221             if (nullptr == env)
 222                 return;
 223
 224             jobject onPutListener = env->NewLocalRef(m_listener);
 225             if (!onPutListener)
 226             {
 227                 releaseEnv();
 228                 return;
 229             }
 230
 231             jclass onGetCls = env->GetObjectClass(onPutListener);
 232             if (!onGetCls)
 233             {
 234                 releaseEnv();
 235                 return;
 236             }
 237
 238             // TODO: Revisit is it required?
 239             if (OC_STACK_OK != errorCode && OC_STACK_RESOURCE_CREATED != errorCode
 240                 && OC_STACK_RESOURCE_DELETED != errorCode)
 241             {
 242                 jmethodID midL = env->GetMethodID(onGetCls, "onPutFailed", "(Ljava/lang/Throwable;)V");
 243                 if (!midL)
 244                 {
 245                     releaseEnv();
 246                     return;
 247                 }
 248                 env->CallVoidMethod(onPutListener, midL);
 249             }
 250             else
 251             {
 252                 JSimulatorResourceModel *jniModel = new JSimulatorResourceModel(representation);
 253                 if (!jniModel)
 254                 {
 255                     releaseEnv();
 256                     return;
 257                 }
 258
 259                 jobject jRepresentation = JSimulatorResourceModel::toJava(env,
 260                         reinterpret_cast<jlong>(jniModel));
 261                 if (!jRepresentation)
 262                 {
 263                     delete jniModel;
 264                     releaseEnv();
 265                     return;
 266                 }
 267
 268                 jmethodID midL = env->GetMethodID(onGetCls, "onPutCompleted",
 269                             "(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;)V");
 270                 if (!midL)
 271                 {
 272                     delete jniModel;
 273                     releaseEnv();
 274                     return;
 275                 }
 276
 277                 jstring jUid = env->NewStringUTF(uId.c_str());
 278                 env->CallVoidMethod(onPutListener, midL, jUid, jRepresentation);
 279                 if (env->ExceptionCheck())
 280                 {
 281                     delete jniModel;
 282                     releaseEnv();
 283                 }
 284             }
 285         }
 286
 287     private:
 288         jweak m_listener;
 289 };
 290
 291 class JNIOnPostListener
 292 {
 293     public:
 294         void setJavaOnPostListener(JNIEnv *env, jobject listener)
 295         {
 296             m_listener = env->NewWeakGlobalRef(listener);
 297         }
 298
 299         void onPostCallback(const std::string &uId, int errorCode,
 300                             SimulatorResourceModelSP representation)
 301         {
 302             JNIEnv *env = getEnv();
 303             if (nullptr == env)
 304                 return;
 305
 306             jobject onPostListener = env->NewLocalRef(m_listener);
 307             if (!onPostListener)
 308             {
 309                 releaseEnv();
 310                 return;
 311             }
 312
 313             jclass onGetCls = env->GetObjectClass(onPostListener);
 314             if (!onGetCls)
 315             {
 316                 releaseEnv();
 317                 return;
 318             }
 319
 320             // TODO: Revisit is it required?
 321             if (OC_STACK_OK != errorCode && OC_STACK_RESOURCE_CREATED != errorCode
 322                 && OC_STACK_RESOURCE_DELETED != errorCode)
 323             {
 324                 jmethodID midL = env->GetMethodID(onGetCls, "onPostFailed", "(Ljava/lang/Throwable;)V");
 325                 if (!midL)
 326                 {
 327                     releaseEnv();
 328                     return;
 329                 }
 330                 env->CallVoidMethod(onPostListener, midL);
 331             }
 332             else
 333             {
 334                 JSimulatorResourceModel *jniModel = new JSimulatorResourceModel(representation);
 335                 if (!jniModel)
 336                 {
 337                     releaseEnv();
 338                     return;
 339                 }
 340
 341                 jobject jRepresentation = JSimulatorResourceModel::toJava(env,
 342                         reinterpret_cast<jlong>(jniModel));
 343                 if (!jRepresentation)
 344                 {
 345                     delete jniModel;
 346                     releaseEnv();
 347                     return;
 348                 }
 349
 350                 jmethodID midL = env->GetMethodID(onGetCls, "onPostCompleted",
 351                         "(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;)V");
 352                 if (!midL)
 353                 {
 354                     delete jniModel;
 355                     releaseEnv();
 356                     return;
 357                 }
 358
 359                 jstring jUid = env->NewStringUTF(uId.c_str());
 360
 361                 env->CallVoidMethod(onPostListener, midL, jUid, jRepresentation);
 362                 if (env->ExceptionCheck())
 363                 {
 364                     delete jniModel;
 365                     releaseEnv();
 366                 }
 367             }
 368         }
 369
 370     private:
 371         jweak m_listener;
 372
 373 };
 374
 375 class JNIOnVerificationListener
 376 {
 377     public:
 378         void setJavaOnVerificationListener(JNIEnv *env, jobject listener)
 379         {
 380             m_listener = env->NewWeakGlobalRef(listener);
 381         }
 382
 383         void onVerificationCallback(const std::string &uId, int id, OperationState opState)
 384         {
 385             JNIEnv *env = getEnv();
 386             if (nullptr == env)
 387                 return;
 388
 389             jobject onVerificationListener = env->NewLocalRef(m_listener);
 390             if (!onVerificationListener)
 391             {
 392                 releaseEnv();
 393                 return;
 394             }
 395
 396             jclass onVerificationCls = env->GetObjectClass(onVerificationListener);
 397             if (!onVerificationCls)
 398             {
 399                 releaseEnv();
 400                 return;
 401             }
 402
 403             jmethodID midL;
 404
 405             if (OP_START == opState)
 406             {
 407                 midL = env->GetMethodID(onVerificationCls, "onVerificationStarted", "(Ljava/lang/String;I)V");
 408             }
 409             else if (OP_COMPLETE == opState)
 410             {
 411                 midL = env->GetMethodID(onVerificationCls, "onVerificationCompleted", "(Ljava/lang/String;I)V");
 412             }
 413             else
 414             {
 415                 midL = env->GetMethodID(onVerificationCls, "onVerificationAborted", "(Ljava/lang/String;I)V");
 416             }
 417
 418             if (!midL)
 419             {
 420                 releaseEnv();
 421                 return;
 422             }
 423
 424             jstring jUid = env->NewStringUTF(uId.c_str());
 425
 426             env->CallVoidMethod(onVerificationListener, midL, jUid, (jint)id);
 427
 428             if (env->ExceptionCheck())
 429             {
 430                 releaseEnv();
 431             }
 432         }
 433
 434     private:
 435         jweak m_listener;
 436
 437 };
 438
 439
 440 JNIEXPORT void JNICALL
 441 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_startObserve
 442 (JNIEnv *env, jobject thiz, jint observeType, jobject jQueryParamsMap, jobject jListener)
 443 {
 444     if (!jListener)
 445     {
 446         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 447         return;
 448     }
 449
 450     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 451                                          thiz);
 452     if (!resource)
 453     {
 454         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 455         return;
 456     }
 457
 458     std::map<std::string, std::string> queryParams;
 459     if (jQueryParamsMap)
 460         convertJavaMapToQueryParamsMap(env, jQueryParamsMap, queryParams);
 461
 462     ObserveType type = ObserveType::OBSERVE;
 463     if (1 == observeType)
 464         type = ObserveType::OBSERVE_ALL;
 465
 466     JNIOnObserveListener *onObserveListener = new JNIOnObserveListener();
 467     onObserveListener->setJavaOnObserveListener(env, jListener);
 468
 469     try
 470     {
 471         resource->observe(type,
 472                           std::bind(&JNIOnObserveListener::onObserveCallback,
 473                                     onObserveListener, std::placeholders::_1,
 474                                     std::placeholders::_2, std::placeholders::_3,
 475                                     std::placeholders::_4));
 476     }
 477     catch (InvalidArgsException &e)
 478     {
 479         throwInvalidArgsException(env, e.code(), e.what());
 480     }
 481     catch (SimulatorException &e)
 482     {
 483         throwSimulatorException(env, e.code(), e.what());
 484     }
 485     catch (...)
 486     {
 487         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 488     }
 489 }
 490
 491 JNIEXPORT void JNICALL
 492 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_stopObserve
 493 (JNIEnv *env, jobject thiz)
 494 {
 495     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 496                                          thiz);
 497     if (!resource)
 498     {
 499         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 500         return;
 501     }
 502
 503     try
 504     {
 505         resource->cancelObserve();
 506     }
 507     catch (SimulatorException &e)
 508     {
 509         throwSimulatorException(env, e.code(), e.what());
 510     }
 511     catch (...)
 512     {
 513         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 514     }
 515 }
 516
 517 JNIEXPORT void JNICALL
 518 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_nativeGet
 519 (JNIEnv *env, jobject thiz, jstring jResourceInterface,
 520  jobject jQueryParamsMap, jobject jListener)
 521 {
 522     if (!jListener)
 523     {
 524         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 525         return;
 526     }
 527
 528     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 529                                          thiz);
 530     if (!resource)
 531     {
 532         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 533         return;
 534     }
 535
 536     // Interface type
 537     const char *interfaceCStr = NULL;
 538     std::string interfaceType;
 539     if (jResourceInterface)
 540     {
 541         interfaceCStr = env->GetStringUTFChars(jResourceInterface, NULL);
 542         interfaceType = interfaceCStr;
 543     }
 544
 545     // Query parameters
 546     std::map<std::string, std::string> queryParams;
 547     if (jQueryParamsMap)
 548         convertJavaMapToQueryParamsMap(env, jQueryParamsMap, queryParams);
 549
 550     // Create listener
 551     JNIOnGetListener *onGetListener = new JNIOnGetListener();
 552     onGetListener->setJavaOnGetListener(env, jListener);
 553
 554     try
 555     {
 556         resource->get(interfaceType,
 557                       queryParams,
 558                       std::bind(&JNIOnGetListener::onGetCallback,
 559                                 onGetListener, std::placeholders::_1,
 560                                 std::placeholders::_2, std::placeholders::_3));
 561     }
 562     catch (InvalidArgsException &e)
 563     {
 564         throwInvalidArgsException(env, e.code(), e.what());
 565         return;
 566     }
 567     catch (NoSupportException &e)
 568     {
 569         throwNoSupportException(env, e.code(), e.what());
 570         return;
 571     }
 572     catch (SimulatorException &e)
 573     {
 574         throwSimulatorException(env, e.code(), e.what());
 575         return;
 576     }
 577     catch (...)
 578     {
 579         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 580         return;
 581     }
 582
 583     if (interfaceCStr)
 584         env->ReleaseStringUTFChars(jResourceInterface, interfaceCStr);
 585 }
 586
 587 JNIEXPORT void JNICALL
 588 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_nativePut
 589 (JNIEnv *env, jobject thiz, jstring jResourceInterface,
 590  jobject jRepresentation, jobject jQueryParamsMap, jobject jListener)
 591 {
 592     if (!jListener)
 593     {
 594         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 595         return;
 596     }
 597
 598     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 599                                          thiz);
 600     if (!resource)
 601     {
 602         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 603         return;
 604     }
 605
 606     // Interface type
 607     const char *interfaceCStr = NULL;
 608     std::string interfaceType;
 609     if (jResourceInterface)
 610     {
 611         interfaceCStr = env->GetStringUTFChars(jResourceInterface, NULL);
 612         interfaceType = interfaceCStr;
 613     }
 614
 615     // Query parameters
 616     std::map<std::string, std::string> queryParams;
 617     if (jQueryParamsMap)
 618         convertJavaMapToQueryParamsMap(env, jQueryParamsMap, queryParams);
 619
 620     SimulatorResourceModelSP resourceModel =
 621         JSimulatorResourceModel::getResourceModelPtr(env, jRepresentation);
 622
 623     // Create listener
 624     JNIOnPutListener *onPutListener = new JNIOnPutListener();
 625     onPutListener->setJavaOnPutListener(env, jListener);
 626
 627     try
 628     {
 629         resource->put(interfaceType,
 630                       queryParams,
 631                       resourceModel,
 632                       std::bind(&JNIOnPutListener::onPutCallback,
 633                                 onPutListener, std::placeholders::_1,
 634                                 std::placeholders::_2, std::placeholders::_3));
 635     }
 636     catch (InvalidArgsException &e)
 637     {
 638         throwInvalidArgsException(env, e.code(), e.what());
 639         return;
 640     }
 641     catch (NoSupportException &e)
 642     {
 643         throwNoSupportException(env, e.code(), e.what());
 644         return;
 645     }
 646     catch (SimulatorException &e)
 647     {
 648         throwSimulatorException(env, e.code(), e.what());
 649         return;
 650     }
 651     catch (...)
 652     {
 653         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 654         return;
 655     }
 656
 657     if (interfaceCStr)
 658         env->ReleaseStringUTFChars(jResourceInterface, interfaceCStr);
 659 }
 660
 661 JNIEXPORT void JNICALL
 662 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_nativePost
 663 (JNIEnv *env, jobject thiz, jstring jResourceInterface,
 664  jobject jRepresentation, jobject jQueryParamsMap, jobject jListener)
 665 {
 666     if (!jListener)
 667     {
 668         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 669         return;
 670     }
 671
 672     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 673                                          thiz);
 674     if (!resource)
 675     {
 676         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 677         return;
 678     }
 679
 680     // Interface type
 681     const char *interfaceCStr = NULL;
 682     std::string interfaceType;
 683     if (jResourceInterface)
 684     {
 685         interfaceCStr = env->GetStringUTFChars(jResourceInterface, NULL);
 686         interfaceType = interfaceCStr;
 687     }
 688
 689     // Query parameters
 690     std::map<std::string, std::string> queryParams;
 691     if (jQueryParamsMap)
 692         convertJavaMapToQueryParamsMap(env, jQueryParamsMap, queryParams);
 693
 694     SimulatorResourceModelSP resourceModel =
 695         JSimulatorResourceModel::getResourceModelPtr(env, jRepresentation);
 696
 697     // Create listener
 698     JNIOnPostListener *onPostListener = new JNIOnPostListener();
 699     onPostListener->setJavaOnPostListener(env, jListener);
 700
 701     try
 702     {
 703         resource->post(interfaceType,
 704                        queryParams,
 705                        resourceModel,
 706                        std::bind(&JNIOnPostListener::onPostCallback,
 707                                  onPostListener, std::placeholders::_1,
 708                                  std::placeholders::_2, std::placeholders::_3));
 709     }
 710     catch (InvalidArgsException &e)
 711     {
 712         throwInvalidArgsException(env, e.code(), e.what());
 713         return;
 714     }
 715     catch (NoSupportException &e)
 716     {
 717         throwNoSupportException(env, e.code(), e.what());
 718         return;
 719     }
 720     catch (SimulatorException &e)
 721     {
 722         throwSimulatorException(env, e.code(), e.what());
 723         return;
 724     }
 725     catch (...)
 726     {
 727         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 728         return;
 729     }
 730
 731     if (interfaceCStr)
 732         env->ReleaseStringUTFChars(jResourceInterface, interfaceCStr);
 733 }
 734
 735 JNIEXPORT void JNICALL
 736 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_setConfigInfo
 737 (JNIEnv *env, jobject thiz, jstring jConfigPath)
 738 {
 739     if (!jConfigPath)
 740     {
 741         throwInvalidArgsException(env, SIMULATOR_INVALID_PARAM,
 742                                   "Configuration file path is null!");
 743         return;
 744     }
 745
 746     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 747                                          thiz);
 748     if (!resource)
 749     {
 750         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 751         return;
 752     }
 753
 754     // Interface type
 755     const char *configCStr = NULL;
 756     std::string configPath;
 757     if (jConfigPath)
 758     {
 759         configCStr = env->GetStringUTFChars(jConfigPath, NULL);
 760         configPath = configCStr;
 761     }
 762
 763     try
 764     {
 765         resource->configure(configPath);
 766     }
 767     catch (InvalidArgsException &e)
 768     {
 769         throwInvalidArgsException(env, e.code(), e.what());
 770         return;
 771     }
 772     catch (...)
 773     {
 774         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 775         return;
 776     }
 777
 778     if (configCStr)
 779         env->ReleaseStringUTFChars(jConfigPath, configCStr);
 780 }
 781
 782 JNIEXPORT jint JNICALL
 783 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_startVerification
 784 (JNIEnv *env, jobject thiz, jint jReqType, jobject jListener)
 785 {
 786     if (!jListener)
 787     {
 788         throwInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!");
 789         return SIMULATOR_INVALID_CALLBACK;
 790     }
 791
 792     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 793                                          thiz);
 794     if (!resource)
 795     {
 796         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 797         return SIMULATOR_BAD_OBJECT;
 798     }
 799
 800     // Convert RequestType
 801     RequestType reqType;
 802
 803     switch (jReqType)
 804     {
 805         case 0:
 806             reqType = RequestType::RQ_TYPE_GET;
 807             break;
 808
 809         case 1:
 810             reqType = RequestType::RQ_TYPE_PUT;
 811             break;
 812
 813         case 2:
 814             reqType = RequestType::RQ_TYPE_POST;
 815             break;
 816
 817         case 3:
 818             reqType = RequestType::RQ_TYPE_DELETE;
 819             break;
 820
 821         default:
 822             return -1;
 823     }
 824
 825     // Create listener
 826     JNIOnVerificationListener *onVerificationListener = new JNIOnVerificationListener();
 827     onVerificationListener->setJavaOnVerificationListener(env, jListener);
 828
 829     int automationId = -1;
 830
 831     try
 832     {
 833         automationId = resource->startVerification(reqType,
 834                        std::bind(&JNIOnVerificationListener::onVerificationCallback,
 835                                  onVerificationListener, std::placeholders::_1,
 836                                  std::placeholders::_2, std::placeholders::_3));
 837     }
 838     catch (InvalidArgsException &e)
 839     {
 840         throwInvalidArgsException(env, e.code(), e.what());
 841     }
 842     catch (NoSupportException &e)
 843     {
 844         throwNoSupportException(env, e.code(), e.what());
 845     }
 846     catch (OperationInProgressException &e)
 847     {
 848         throwOperationInProgressException(env, e.code(), e.what());
 849     }
 850     catch (SimulatorException &e)
 851     {
 852         throwSimulatorException(env, e.code(), e.what());
 853     }
 854     catch (...)
 855     {
 856         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 857     }
 858
 859     return automationId;
 860 }
 861
 862 JNIEXPORT void JNICALL
 863 Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_stopVerification
 864 (JNIEnv *env, jobject thiz, jint jId)
 865 {
 866     SimulatorRemoteResourceSP resource = JniSimulatorRemoteResource::getResourceHandle(env,
 867                                          thiz);
 868     if (!resource)
 869     {
 870         throwSimulatorException(env, SIMULATOR_BAD_OBJECT, "No resource!");
 871         return;
 872     }
 873
 874     try
 875     {
 876         resource->stopVerification((int)jId);
 877     }
 878     catch (InvalidArgsException &e)
 879     {
 880         throwInvalidArgsException(env, e.code(), e.what());
 881     }
 882     catch (NoSupportException &e)
 883     {
 884         throwNoSupportException(env, e.code(), e.what());
 885     }
 886     catch (...)
 887     {
 888         throwSimulatorException(env, SIMULATOR_ERROR, "Unknown Exception");
 889     }
 890 }
 891
 892 JNIEXPORT void JNICALL Java_org_oic_simulator_clientcontroller_SimulatorRemoteResource_dispose
 893 (JNIEnv *env, jobject thiz)
 894 {
 895     JniSimulatorRemoteResource *resource = GetHandle<JniSimulatorRemoteResource>(env, thiz);
 896     delete resource;
 897 }