android/android_api/base/jni/JniOcPlatform.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Intel Corporation.
   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 "JniOcPlatform.h"
  22 #include "OCPlatform.h"
  23 #include "JniOcResource.h"
  24 #include "JniOcResourceHandle.h"
  25 #include "JniOcPresenceHandle.h"
  26 #include "JniOcResourceResponse.h"
  27 #include "JniOcSecurity.h"
  28 #include "JniOcDirectPairDevice.h"
  29 #include "JniUtils.h"
  30 #include "ocpayload.h"
  31
  32 #ifdef WITH_CLOUD
  33 #include "JniOcAccountManager.h"
  34 #endif
  35
  36 using namespace OC;
  37
  38 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
  39 {
  40     JniOnResourceFoundListener *onResourceFoundListener = nullptr;
  41
  42     resourceFoundMapLock.lock();
  43
  44     for (auto it = onResourceFoundListenerMap.begin();
  45          it != onResourceFoundListenerMap.end();
  46          ++it)
  47     {
  48         if (env->IsSameObject(jListener, it->first))
  49         {
  50             auto refPair = it->second;
  51             onResourceFoundListener = refPair.first;
  52             refPair.second++;
  53             it->second = refPair;
  54             onResourceFoundListenerMap.insert(*it);
  55             LOGD("OnResourceFoundListener: ref. count incremented");
  56             break;
  57         }
  58     }
  59
  60     if (!onResourceFoundListener)
  61     {
  62         onResourceFoundListener =
  63             new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);
  64         jobject jgListener = env->NewGlobalRef(jListener);
  65
  66         onResourceFoundListenerMap.insert(
  67             std::pair<jobject,
  68                       std::pair<JniOnResourceFoundListener*, int >>(
  69                           jgListener,
  70                           std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener,
  71                                                                       1)));
  72         LOGD("OnResourceFoundListener: new listener");
  73     }
  74     resourceFoundMapLock.unlock();
  75     return onResourceFoundListener;
  76 }
  77
  78 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)
  79 {
  80     resourceFoundMapLock.lock();
  81
  82     for (auto it = onResourceFoundListenerMap.begin();
  83          it != onResourceFoundListenerMap.end();
  84          ++it)
  85     {
  86         if (env->IsSameObject(jListener, it->first))
  87         {
  88             auto refPair = it->second;
  89             if (refPair.second > 1)
  90             {
  91                 refPair.second--;
  92                 it->second = refPair;
  93                 onResourceFoundListenerMap.insert(*it);
  94                 LOGI("OnResourceFoundListener: ref. count decremented");
  95             }
  96             else
  97             {
  98                 env->DeleteGlobalRef(it->first);
  99                 JniOnResourceFoundListener* listener = refPair.first;
 100                 delete listener;
 101                 onResourceFoundListenerMap.erase(it);
 102                 LOGI("OnResourceFoundListener removed");
 103             }
 104             break;
 105         }
 106     }
 107     resourceFoundMapLock.unlock();
 108 }
 109
 110 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)
 111 {
 112     JniOnDeviceInfoListener *onDeviceInfoListener = nullptr;
 113
 114     deviceInfoMapLock.lock();
 115
 116     for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
 117     {
 118         if (env->IsSameObject(jListener, it->first))
 119         {
 120             auto refPair = it->second;
 121             onDeviceInfoListener = refPair.first;
 122             refPair.second++;
 123             it->second = refPair;
 124             onDeviceInfoListenerMap.insert(*it);
 125             LOGD("OnDeviceInfoListener: ref. count incremented");
 126             break;
 127         }
 128     }
 129
 130     if (!onDeviceInfoListener)
 131     {
 132         onDeviceInfoListener =
 133             new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);
 134         jobject jgListener = env->NewGlobalRef(jListener);
 135
 136         onDeviceInfoListenerMap.insert(
 137             std::pair<jobject,
 138                       std::pair<JniOnDeviceInfoListener*, int>>(
 139                           jgListener,
 140                           std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));
 141         LOGI("OnDeviceInfoListener: new listener");
 142     }
 143
 144     deviceInfoMapLock.unlock();
 145     return onDeviceInfoListener;
 146 }
 147
 148 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)
 149 {
 150     deviceInfoMapLock.lock();
 151     bool isFound = false;
 152     for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
 153     {
 154         if (env->IsSameObject(jListener, it->first))
 155         {
 156             auto refPair = it->second;
 157             if (refPair.second > 1)
 158             {
 159                 refPair.second--;
 160                 it->second = refPair;
 161                 onDeviceInfoListenerMap.insert(*it);
 162                 LOGI("OnDeviceInfoListener: ref. count decremented");
 163             }
 164             else
 165             {
 166                 env->DeleteGlobalRef(it->first);
 167                 JniOnDeviceInfoListener* listener = refPair.first;
 168                 delete listener;
 169                 onDeviceInfoListenerMap.erase(it);
 170
 171                 LOGI("OnDeviceInfoListener removed");
 172             }
 173
 174             isFound = true;
 175             break;
 176         }
 177     }
 178
 179     if (!isFound)
 180     {
 181         ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");
 182     }
 183     deviceInfoMapLock.unlock();
 184 }
 185
 186 JniOnPlatformInfoListener* AddOnPlatformInfoListener(JNIEnv* env, jobject jListener)
 187 {
 188     JniOnPlatformInfoListener *onPlatformInfoListener = nullptr;
 189
 190     platformInfoMapLock.lock();
 191
 192     for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
 193     {
 194         if (env->IsSameObject(jListener, it->first))
 195         {
 196             auto refPair = it->second;
 197             onPlatformInfoListener = refPair.first;
 198             refPair.second++;
 199             it->second = refPair;
 200             onPlatformInfoListenerMap.insert(*it);
 201             LOGD("OnPlatformInfoListener: ref. count incremented");
 202             break;
 203         }
 204     }
 205
 206     if (!onPlatformInfoListener)
 207     {
 208         onPlatformInfoListener =
 209             new JniOnPlatformInfoListener(env, jListener, RemoveOnPlatformInfoListener);
 210         jobject jgListener = env->NewGlobalRef(jListener);
 211
 212         onPlatformInfoListenerMap.insert(
 213             std::pair<jobject, std::pair<JniOnPlatformInfoListener*, int>>(
 214                 jgListener,
 215                 std::pair<JniOnPlatformInfoListener*, int>(onPlatformInfoListener, 1)));
 216         LOGI("OnPlatformInfoListener: new listener");
 217     }
 218
 219     platformInfoMapLock.unlock();
 220     return onPlatformInfoListener;
 221 }
 222
 223 void RemoveOnPlatformInfoListener(JNIEnv* env, jobject jListener)
 224 {
 225     platformInfoMapLock.lock();
 226     bool isFound = false;
 227     for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
 228     {
 229         if (env->IsSameObject(jListener, it->first))
 230         {
 231             auto refPair = it->second;
 232             if (refPair.second > 1)
 233             {
 234                 refPair.second--;
 235                 it->second = refPair;
 236                 onPlatformInfoListenerMap.insert(*it);
 237                 LOGI("OnPlatformInfoListener: ref. count decremented");
 238             }
 239             else
 240             {
 241                 env->DeleteGlobalRef(it->first);
 242                 JniOnPlatformInfoListener* listener = refPair.first;
 243                 delete listener;
 244                 onPlatformInfoListenerMap.erase(it);
 245
 246                 LOGI("OnPlatformInfoListener removed");
 247             }
 248
 249             isFound = true;
 250             break;
 251         }
 252     }
 253
 254     if (!isFound)
 255     {
 256         ThrowOcException(JNI_EXCEPTION, "OnPlatformInfoListenet not found");
 257     }
 258     platformInfoMapLock.unlock();
 259 }
 260
 261 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)
 262 {
 263     JniOnPresenceListener *onPresenceListener = nullptr;
 264
 265     presenceMapLock.lock();
 266
 267     for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
 268     {
 269         if (env->IsSameObject(jListener, it->first))
 270         {
 271             auto refPair = it->second;
 272             onPresenceListener = refPair.first;
 273             refPair.second++;
 274             it->second = refPair;
 275             onPresenceListenerMap.insert(*it);
 276             LOGD("OnPresenceListener: ref. count incremented");
 277             break;
 278         }
 279     }
 280     if (!onPresenceListener)
 281     {
 282         onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);
 283         jobject jgListener = env->NewGlobalRef(jListener);
 284         onPresenceListenerMap.insert(
 285             std::pair<jobject, std::pair<JniOnPresenceListener*, int>>(
 286                 jgListener,
 287                 std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));
 288         LOGI("OnPresenceListener: new listener");
 289     }
 290     presenceMapLock.unlock();
 291     return onPresenceListener;
 292 }
 293
 294 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)
 295 {
 296     presenceMapLock.lock();
 297     bool isFound = false;
 298     for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
 299     {
 300         if (env->IsSameObject(jListener, it->first))
 301         {
 302             auto refPair = it->second;
 303             if (refPair.second > 1)
 304             {
 305                 refPair.second--;
 306                 it->second = refPair;
 307                 onPresenceListenerMap.insert(*it);
 308                 LOGI("OnPresenceListener: ref. count decremented");
 309             }
 310             else
 311             {
 312                 env->DeleteGlobalRef(it->first);
 313                 JniOnPresenceListener* listener = refPair.first;
 314                 delete listener;
 315                 onPresenceListenerMap.erase(it);
 316                 LOGI("OnPresenceListener is removed");
 317             }
 318             isFound = true;
 319             break;
 320         }
 321     }
 322     if (!isFound)
 323     {
 324         ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");
 325     }
 326     presenceMapLock.unlock();
 327 }
 328
 329 JniOnObserveListener* AddOnObserveListener(JNIEnv* env, jobject jListener)
 330 {
 331     JniOnObserveListener *onObserveListener = nullptr;
 332
 333     observeMapLock.lock();
 334
 335     for (auto it = onObserveListenerMap.begin(); it != onObserveListenerMap.end(); ++it)
 336     {
 337         if (env->IsSameObject(jListener, it->first))
 338         {
 339             auto refPair = it->second;
 340             onObserveListener = refPair.first;
 341             refPair.second++;
 342             it->second = refPair;
 343             onObserveListenerMap.insert(*it);
 344             LOGD("OnObserveListener: ref. count incremented");
 345             break;
 346         }
 347     }
 348     if (!onObserveListener)
 349     {
 350         onObserveListener = new JniOnObserveListener(env, jListener, (JniOcResource*)nullptr);
 351         jobject jgListener = env->NewGlobalRef(jListener);
 352         onObserveListenerMap.insert(
 353             std::pair<jobject, std::pair<JniOnObserveListener*, int>>(
 354                 jgListener,
 355                 std::pair<JniOnObserveListener*, int>(onObserveListener, 1)));
 356         LOGI("OnObserveListener: new listener");
 357     }
 358     observeMapLock.unlock();
 359     return onObserveListener;
 360 }
 361
 362 void RemoveOnObserveListener(JNIEnv* env, jobject jListener)
 363 {
 364     observeMapLock.lock();
 365     bool isFound = false;
 366     for (auto it = onObserveListenerMap.begin(); it != onObserveListenerMap.end(); ++it)
 367     {
 368         if (env->IsSameObject(jListener, it->first))
 369         {
 370             auto refPair = it->second;
 371             if (refPair.second > 1)
 372             {
 373                 refPair.second--;
 374                 it->second = refPair;
 375                 onObserveListenerMap.insert(*it);
 376                 LOGI("OnObserveListener: ref. count decremented");
 377             }
 378             else
 379             {
 380                 env->DeleteGlobalRef(it->first);
 381                 JniOnObserveListener* listener = refPair.first;
 382                 delete listener;
 383                 onObserveListenerMap.erase(it);
 384                 LOGI("OnObserveListener is removed");
 385             }
 386             isFound = true;
 387             break;
 388         }
 389     }
 390     if (!isFound)
 391     {
 392         ThrowOcException(JNI_EXCEPTION, "OnObserveListener not found");
 393     }
 394     observeMapLock.unlock();
 395 }
 396
 397 JniOnDPDevicesFoundListener* AddOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
 398 {
 399     JniOnDPDevicesFoundListener *onDPDeviceListener = nullptr;
 400
 401     dpDevicesFoundListenerMapLock.lock();
 402
 403     for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
 404             onDPDevicesFoundListenerMap.end(); ++it)
 405     {
 406         if (env->IsSameObject(jListener, it->first))
 407         {
 408             auto refPair = it->second;
 409             onDPDeviceListener = refPair.first;
 410             refPair.second++;
 411             it->second = refPair;
 412             onDPDevicesFoundListenerMap.insert(*it);
 413             LOGD("onDPDeviceListener: ref. count incremented");
 414             break;
 415         }
 416     }
 417     if (!onDPDeviceListener)
 418     {
 419         onDPDeviceListener = new JniOnDPDevicesFoundListener(env, jListener,
 420                 RemoveOnDPDevicesFoundListener);
 421         jobject jgListener = env->NewGlobalRef(jListener);
 422         onDPDevicesFoundListenerMap.insert(
 423                 std::pair<jobject, std::pair<JniOnDPDevicesFoundListener*, int>>(
 424                     jgListener,
 425                     std::pair<JniOnDPDevicesFoundListener*, int>(onDPDeviceListener, 1)));
 426         LOGI("onDPDeviceListener: new listener");
 427     }
 428     dpDevicesFoundListenerMapLock.unlock();
 429     return onDPDeviceListener;
 430 }
 431
 432 void RemoveOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
 433 {
 434     dpDevicesFoundListenerMapLock.lock();
 435     bool isFound = false;
 436     for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
 437             onDPDevicesFoundListenerMap.end(); ++it)
 438     {
 439         if (env->IsSameObject(jListener, it->first))
 440         {
 441             auto refPair = it->second;
 442             if (refPair.second > 1)
 443             {
 444                 refPair.second--;
 445                 it->second = refPair;
 446                 onDPDevicesFoundListenerMap.insert(*it);
 447                 LOGI("onDPDeviceListener: ref. count decremented");
 448             }
 449             else
 450             {
 451                 env->DeleteGlobalRef(it->first);
 452                 JniOnDPDevicesFoundListener* listener = refPair.first;
 453                 delete listener;
 454                 onDPDevicesFoundListenerMap.erase(it);
 455                 LOGI("onDPDeviceListener is removed");
 456             }
 457             isFound = true;
 458             break;
 459         }
 460     }
 461     if (!isFound)
 462     {
 463         ThrowOcException(JNI_EXCEPTION, "onDPDeviceListener not found");
 464     }
 465     dpDevicesFoundListenerMapLock.unlock();
 466 }
 467
 468 JniOnDirectPairingListener* AddOnDirectPairingListener(JNIEnv* env, jobject jListener)
 469 {
 470     JniOnDirectPairingListener *onDirectPairingListener = nullptr;
 471
 472     directPairingListenerMapLock.lock();
 473
 474     for (auto it = directPairingListenerMap.begin(); it !=
 475             directPairingListenerMap.end(); ++it)
 476     {
 477         if (env->IsSameObject(jListener, it->first))
 478         {
 479             auto refPair = it->second;
 480             onDirectPairingListener = refPair.first;
 481             refPair.second++;
 482             it->second = refPair;
 483             directPairingListenerMap.insert(*it);
 484             LOGD("onDirectPairingListener: ref. count incremented");
 485             break;
 486         }
 487     }
 488     if (!onDirectPairingListener)
 489     {
 490         onDirectPairingListener = new JniOnDirectPairingListener(env, jListener,
 491                 RemoveOnDirectPairingListener);
 492         jobject jgListener = env->NewGlobalRef(jListener);
 493         directPairingListenerMap.insert(
 494                 std::pair<jobject, std::pair<JniOnDirectPairingListener*, int>>(
 495                     jgListener,
 496                     std::pair<JniOnDirectPairingListener*, int>(onDirectPairingListener, 1)));
 497         LOGI("onDirectPairingListener: new listener");
 498     }
 499     directPairingListenerMapLock.unlock();
 500     return onDirectPairingListener;
 501 }
 502
 503 void RemoveOnDirectPairingListener(JNIEnv* env, jobject jListener)
 504 {
 505     directPairingListenerMapLock.lock();
 506     bool isFound = false;
 507     for (auto it = directPairingListenerMap.begin(); it !=
 508             directPairingListenerMap.end(); ++it)
 509     {
 510         if (env->IsSameObject(jListener, it->first))
 511         {
 512             auto refPair = it->second;
 513             if (refPair.second > 1)
 514             {
 515                 refPair.second--;
 516                 it->second = refPair;
 517                 directPairingListenerMap.insert(*it);
 518                 LOGI("onDirectPairingListener: ref. count decremented");
 519             }
 520             else
 521             {
 522                 env->DeleteGlobalRef(it->first);
 523                 JniOnDirectPairingListener* listener = refPair.first;
 524                 delete listener;
 525                 directPairingListenerMap.erase(it);
 526                 LOGI("onDirectPairingListener is removed");
 527             }
 528             isFound = true;
 529             break;
 530         }
 531     }
 532     if (!isFound)
 533     {
 534         ThrowOcException(JNI_EXCEPTION, "onDirectPairingListener not found");
 535     }
 536     directPairingListenerMapLock.unlock();
 537 }
 538
 539 JniOnPublishResourceListener* AddOnPublishResourceListener(JNIEnv* env, jobject jListener)
 540 {
 541     if (!env)
 542     {
 543         LOGD("env is null");
 544         return nullptr;
 545     }
 546
 547     JniOnPublishResourceListener *onPublishResourceListener = nullptr;
 548
 549     publishResourceListenerMapLock.lock();
 550
 551     for (auto it = onPublishResourceListenerMap.begin(); it !=
 552             onPublishResourceListenerMap.end(); ++it)
 553     {
 554         if (env->IsSameObject(jListener, it->first))
 555         {
 556             auto refPair = it->second;
 557             onPublishResourceListener = refPair.first;
 558             refPair.second++;
 559             it->second = refPair;
 560             onPublishResourceListenerMap.insert(*it);
 561             LOGD("onPublishResourceListener: ref. count incremented");
 562             break;
 563         }
 564     }
 565     if (!onPublishResourceListener)
 566     {
 567         onPublishResourceListener = new JniOnPublishResourceListener(env, jListener,
 568                 RemoveOnPublishResourceListener);
 569         jobject jgListener = env->NewGlobalRef(jListener);
 570         onPublishResourceListenerMap.insert(
 571                 std::pair<jobject, std::pair<JniOnPublishResourceListener*, int>>(
 572                     jgListener,
 573                     std::pair<JniOnPublishResourceListener*, int>(onPublishResourceListener, 1)));
 574         LOGI("onPublishResourceListener: new listener");
 575     }
 576     publishResourceListenerMapLock.unlock();
 577     return onPublishResourceListener;
 578 }
 579
 580 void RemoveOnPublishResourceListener(JNIEnv* env, jobject jListener)
 581 {
 582     if (!env)
 583     {
 584         ThrowOcException(JNI_EXCEPTION, "env is null");
 585         return;
 586     }
 587
 588     publishResourceListenerMapLock.lock();
 589     bool isFound = false;
 590     for (auto it = onPublishResourceListenerMap.begin(); it !=
 591             onPublishResourceListenerMap.end(); ++it)
 592     {
 593         if (env->IsSameObject(jListener, it->first))
 594         {
 595             auto refPair = it->second;
 596             if (refPair.second > 1)
 597             {
 598                 refPair.second--;
 599                 it->second = refPair;
 600                 onPublishResourceListenerMap.insert(*it);
 601                 LOGI("onPublishResourceListener: ref. count decremented");
 602             }
 603             else
 604             {
 605                 env->DeleteGlobalRef(it->first);
 606                 JniOnPublishResourceListener* listener = refPair.first;
 607                 delete listener;
 608                 onPublishResourceListenerMap.erase(it);
 609                 LOGI("onPublishResourceListener is removed");
 610             }
 611             isFound = true;
 612             break;
 613         }
 614     }
 615     if (!isFound)
 616     {
 617         ThrowOcException(JNI_EXCEPTION, "onPublishResourceListener not found");
 618     }
 619     publishResourceListenerMapLock.unlock();
 620 }
 621
 622 JniOnDeleteResourceListener* AddOnDeleteResourceListener(JNIEnv* env, jobject jListener)
 623 {
 624     if (!env)
 625     {
 626         LOGD("env is null");
 627         return nullptr;
 628     }
 629
 630     JniOnDeleteResourceListener *onDeleteResourceListener = nullptr;
 631
 632     deleteResourceListenerMapLock.lock();
 633
 634     for (auto it = onDeleteResourceListenerMap.begin(); it !=
 635             onDeleteResourceListenerMap.end(); ++it)
 636     {
 637         if (env->IsSameObject(jListener, it->first))
 638         {
 639             auto refPair = it->second;
 640             onDeleteResourceListener = refPair.first;
 641             refPair.second++;
 642             it->second = refPair;
 643             onDeleteResourceListenerMap.insert(*it);
 644             LOGD("onDeleteResourceListener: ref. count incremented");
 645             break;
 646         }
 647     }
 648     if (!onDeleteResourceListener)
 649     {
 650         onDeleteResourceListener = new JniOnDeleteResourceListener(env, jListener,
 651                 RemoveOnDeleteResourceListener);
 652         jobject jgListener = env->NewGlobalRef(jListener);
 653         onDeleteResourceListenerMap.insert(
 654                 std::pair<jobject, std::pair<JniOnDeleteResourceListener*, int>>(
 655                     jgListener,
 656                     std::pair<JniOnDeleteResourceListener*, int>(onDeleteResourceListener, 1)));
 657         LOGI("onDeleteResourceListener: new listener");
 658     }
 659     deleteResourceListenerMapLock.unlock();
 660     return onDeleteResourceListener;
 661 }
 662
 663 void RemoveOnDeleteResourceListener(JNIEnv* env, jobject jListener)
 664 {
 665     if (!env)
 666     {
 667         ThrowOcException(JNI_EXCEPTION, "env is null");
 668         return;
 669     }
 670
 671     deleteResourceListenerMapLock.lock();
 672     bool isFound = false;
 673     for (auto it = onDeleteResourceListenerMap.begin(); it !=
 674             onDeleteResourceListenerMap.end(); ++it)
 675     {
 676         if (env->IsSameObject(jListener, it->first))
 677         {
 678             auto refPair = it->second;
 679             if (refPair.second > 1)
 680             {
 681                 refPair.second--;
 682                 it->second = refPair;
 683                 onDeleteResourceListenerMap.insert(*it);
 684                 LOGI("onDeleteResourceListener: ref. count decremented");
 685             }
 686             else
 687             {
 688                 env->DeleteGlobalRef(it->first);
 689                 JniOnDeleteResourceListener* listener = refPair.first;
 690                 delete listener;
 691                 onDeleteResourceListenerMap.erase(it);
 692                 LOGI("onDeleteResourceListener is removed");
 693             }
 694             isFound = true;
 695             break;
 696         }
 697     }
 698     if (!isFound)
 699     {
 700         ThrowOcException(JNI_EXCEPTION, "onDeleteResourceListener not found");
 701     }
 702     deleteResourceListenerMapLock.unlock();
 703 }
 704
 705 /*
 706 * Class:     org_iotivity_base_OcPlatform
 707 * Method:    configure
 708 * Signature: (IILjava/lang/String;II)V
 709 */
 710 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
 711 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort,
 712                                                                  jint jQOS, jstring jDbPath)
 713 {
 714     LOGI("OcPlatform_configure");
 715
 716     std::string ipAddress;
 717     std::string dbfile;
 718     if (jIpAddress)
 719     {
 720         ipAddress = env->GetStringUTFChars(jIpAddress, nullptr);
 721     }
 722     if (jDbPath)
 723     {
 724         dbfile = env->GetStringUTFChars(jDbPath, nullptr);
 725         JniOcSecurity::StoreDbPath(dbfile);
 726     }
 727     uint16_t port = 0;
 728     if (jPort > 0)
 729     {
 730         port = static_cast<uint16_t>(jPort);
 731     }
 732
 733     PlatformConfig cfg{
 734         JniUtils::getServiceType(env, jServiceType),
 735         JniUtils::getModeType(env, jModeType),
 736         ipAddress,
 737         port,
 738         JniUtils::getQOS(env, static_cast<int>(jQOS)),
 739         JniOcSecurity::getOCPersistentStorage()
 740     };
 741     OCPlatform::Configure(cfg);
 742 }
 743
 744 /*
 745 * Class:     org_iotivity_base_OcPlatform
 746 * Method:    notifyAllObservers0
 747 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
 748 */
 749 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0
 750 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
 751 {
 752     LOGI("OcPlatform_notifyAllObservers");
 753     if (!jResourceHandle)
 754     {
 755         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 756         return;
 757     }
 758
 759     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
 760         env, jResourceHandle);
 761     if (!jniOcResourceHandle)
 762     {
 763         return;
 764     }
 765
 766     try
 767     {
 768         OCStackResult result =
 769             OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());
 770
 771         if (OC_STACK_OK != result)
 772         {
 773             ThrowOcException(result, "Failed to notify all observers");
 774             return;
 775         }
 776     }
 777     catch (OCException& e)
 778     {
 779         LOGE("%s", e.reason().c_str());
 780         ThrowOcException(e.code(), e.reason().c_str());
 781     }
 782 }
 783
 784 /*
 785 * Class:     org_iotivity_base_OcPlatform
 786 * Method:    notifyAllObservers1
 787 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V
 788 */
 789 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1
 790 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)
 791 {
 792     LOGI("OcPlatform_notifyAllObservers1");
 793
 794     if (!jResourceHandle)
 795     {
 796         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 797         return;
 798     }
 799
 800     JniOcResourceHandle* jniOcResourceHandle =
 801         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 802     if (!jniOcResourceHandle)
 803     {
 804         return;
 805     }
 806
 807     try {
 808         OCStackResult result = OCPlatform::notifyAllObservers(
 809             jniOcResourceHandle->getOCResourceHandle(),
 810             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 811
 812         if (OC_STACK_OK != result)
 813         {
 814             ThrowOcException(result, "Failed to notify all observers");
 815             return;
 816         }
 817     }
 818     catch (OCException& e)
 819     {
 820         LOGE("%s", e.reason().c_str());
 821         ThrowOcException(e.code(), e.reason().c_str());
 822     }
 823 }
 824
 825 /*
 826 * Class:     org_iotivity_base_OcPlatform
 827 * Method:    notifyListOfObservers2
 828 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V
 829 */
 830 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2(
 831     JNIEnv *env,
 832     jclass clazz,
 833     jobject jResourceHandle,
 834     jbyteArray jObservationIdArr,
 835     jobject jResourceResponse)
 836 {
 837     LOGD("OcPlatform_notifyListOfObservers2");
 838     if (!jResourceHandle)
 839     {
 840         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 841         return;
 842     }
 843     if (!jObservationIdArr)
 844     {
 845         ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
 846         return;
 847     }
 848     if (!jResourceResponse)
 849     {
 850         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
 851         return;
 852     }
 853
 854     JniOcResourceHandle* jniOcResourceHandle =
 855         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 856     if (!jniOcResourceHandle)
 857     {
 858         return;
 859     }
 860
 861     JniOcResourceResponse* jniOcResourceResponse =
 862         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
 863     if (!jniOcResourceResponse)
 864     {
 865         return;
 866     }
 867
 868     int len = env->GetArrayLength(jObservationIdArr);
 869     uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
 870
 871     ObservationIds observationIds;
 872     for (int i = 0; i < len; ++i)
 873     {
 874         observationIds.push_back(bArr[i]);
 875     }
 876
 877     env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
 878
 879     try
 880     {
 881         OCStackResult result = OCPlatform::notifyListOfObservers(
 882             jniOcResourceHandle->getOCResourceHandle(),
 883             observationIds,
 884             jniOcResourceResponse->getOCResourceResponse());
 885
 886         if (OC_STACK_OK != result)
 887         {
 888             ThrowOcException(result, "Failed to notify all observers");
 889         }
 890     }
 891     catch (OCException& e)
 892     {
 893         LOGE("%s", e.reason().c_str());
 894         ThrowOcException(e.code(), e.reason().c_str());
 895     }
 896 }
 897
 898 /*
 899 * Class:     org_iotivity_base_OcPlatform
 900 * Method:    notifyListOfObservers3
 901 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V
 902 */
 903 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3(
 904     JNIEnv *env,
 905     jclass clazz,
 906     jobject jResourceHandle,
 907     jbyteArray jObservationIdArr,
 908     jobject jResourceResponse,
 909     jint jQoS)
 910 {
 911     LOGD("OcPlatform_notifyListOfObservers3");
 912     if (!jResourceHandle)
 913     {
 914         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 915         return;
 916     }
 917     if (!jObservationIdArr)
 918     {
 919         ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
 920         return;
 921     }
 922     if (!jResourceResponse)
 923     {
 924         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
 925         return;
 926     }
 927
 928     JniOcResourceHandle* jniOcResourceHandle =
 929         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 930     if (!jniOcResourceHandle)
 931     {
 932         return;
 933     }
 934
 935     JniOcResourceResponse* jniOcResourceResponse =
 936         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
 937     if (!jniOcResourceResponse)
 938     {
 939         return;
 940     }
 941
 942     int len = env->GetArrayLength(jObservationIdArr);
 943     uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
 944
 945     ObservationIds observationIds;
 946     for (int i = 0; i < len; ++i)
 947     {
 948         observationIds.push_back(bArr[i]);
 949     }
 950
 951     env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
 952
 953     try
 954     {
 955         OCStackResult result = OCPlatform::notifyListOfObservers(
 956             jniOcResourceHandle->getOCResourceHandle(),
 957             observationIds,
 958             jniOcResourceResponse->getOCResourceResponse(),
 959             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 960
 961         if (OC_STACK_OK != result)
 962         {
 963             ThrowOcException(result, "Failed to notify all observers");
 964         }
 965     }
 966     catch (OCException& e)
 967     {
 968         LOGE("%s", e.reason().c_str());
 969         ThrowOcException(e.code(), e.reason().c_str());
 970     }
 971 }
 972
 973 /*
 974 * Class:     org_iotivity_base_OcPlatform
 975 * Method:    findResource0
 976 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V
 977 */
 978 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0(
 979     JNIEnv *env,
 980     jclass clazz,
 981     jstring jHost,
 982     jstring jResourceUri,
 983     jint jConnectivityType,
 984     jobject jListener)
 985 {
 986     LOGD("OcPlatform_findResource");
 987     std::string host;
 988     if (jHost)
 989     {
 990         host = env->GetStringUTFChars(jHost, nullptr);
 991     }
 992     std::string resourceUri;
 993     if (jResourceUri)
 994     {
 995         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
 996     }
 997     if (!jListener)
 998     {
 999         ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
1000         return;
1001     }
1002
1003     JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
1004
1005     FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
1006     {
1007         onResFoundListener->foundResourceCallback(resource);
1008     };
1009
1010     FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
1011     {
1012         onResFoundListener->findResourceErrorCallback(uri, eCode);
1013     };
1014
1015     try
1016     {
1017         OCStackResult result = OCPlatform::findResource(
1018             host,
1019             resourceUri,
1020             static_cast<OCConnectivityType>(jConnectivityType),
1021             findCallback,
1022             findErrorCallback);
1023
1024         if (OC_STACK_OK != result)
1025         {
1026             ThrowOcException(result, "Find resource has failed");
1027             return;
1028         }
1029     }
1030     catch (OCException& e)
1031     {
1032         LOGE("%s", e.reason().c_str());
1033         ThrowOcException(e.code(), e.reason().c_str());
1034     }
1035 }
1036
1037 /*
1038 * Class:     org_iotivity_base_OcPlatform
1039 * Method:    findResource1
1040 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
1041 */
1042 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1(
1043     JNIEnv *env,
1044     jclass clazz,
1045     jstring jHost,
1046     jstring jResourceUri,
1047     jint jConnectivityType,
1048     jobject jListener,
1049     jint jQoS)
1050 {
1051     LOGD("OcPlatform_findResource");
1052     std::string host;
1053     if (jHost)
1054     {
1055         host = env->GetStringUTFChars(jHost, nullptr);
1056     }
1057     std::string resourceUri;
1058     if (jResourceUri)
1059     {
1060         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1061     }
1062     if (!jListener)
1063     {
1064         ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
1065         return;
1066     }
1067     JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
1068
1069     FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
1070     {
1071         onResFoundListener->foundResourceCallback(resource);
1072     };
1073
1074     FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
1075     {
1076         onResFoundListener->findResourceErrorCallback(uri, eCode);
1077     };
1078
1079     try
1080     {
1081         OCStackResult result = OCPlatform::findResource(
1082             host,
1083             resourceUri,
1084             static_cast<OCConnectivityType>(jConnectivityType),
1085             findCallback,
1086             findErrorCallback,
1087             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1088
1089         if (OC_STACK_OK != result)
1090         {
1091             ThrowOcException(result, "Find resource has failed");
1092             return;
1093         }
1094     }
1095     catch (OCException& e)
1096     {
1097         LOGE("%s", e.reason().c_str());
1098         ThrowOcException(e.code(), e.reason().c_str());
1099     }
1100 }
1101
1102 /*
1103  * Class:     org_iotivity_base_OcPlatform
1104  * Method:    findDirectPairingDevices
1105  * Signature: (ILorg/iotivity/base/OcPlatform/FindDirectPairingListener;)V
1106  */
1107 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findDirectPairingDevices
1108   (JNIEnv * env, jclass clazz, jint jTimeout, jobject jListener)
1109 {
1110     LOGD("OcPlatform_findDirectPairingDevices");
1111
1112     if (!jListener)
1113     {
1114         ThrowOcException(OC_STACK_INVALID_PARAM, "onDPDevicesFoundListener cannot be null");
1115         return;
1116     }
1117     JniOnDPDevicesFoundListener *onDPDevsFoundListener = AddOnDPDevicesFoundListener(env,
1118             jListener);
1119
1120     GetDirectPairedCallback getDirectPairedCallback =
1121         [onDPDevsFoundListener](PairedDevices pairingDevList)
1122         {
1123             onDPDevsFoundListener->directPairingDevicesCallback(pairingDevList,
1124                     DPFunc::FIND_DIRECT_PAIRED_DEV_LIST);
1125         };
1126
1127     try
1128     {
1129         OCStackResult result = OCPlatform::findDirectPairingDevices(jTimeout,
1130                 getDirectPairedCallback);
1131         if (OC_STACK_OK != result)
1132         {
1133             ThrowOcException(result, "OCPlatform::findDirectPairingDevices has failed");
1134             return;
1135         }
1136     }
1137     catch (OCException& e)
1138     {
1139         LOGE("%s", e.reason().c_str());
1140         ThrowOcException(e.code(), e.reason().c_str());
1141     }
1142 }
1143
1144 /*
1145  * Class:     org_iotivity_base_OcPlatform
1146  * Method:    getDirectPairedDevices
1147  * Signature: (Lorg/iotivity/base/OcDirectPairDevice/GetDirectPairedListener;)V
1148  */
1149 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDirectPairedDevices
1150 (JNIEnv *env, jclass jclazz, jobject jListener)
1151 {
1152     LOGD("OcPlatform_getDirectPairedDevices");
1153
1154     if (!jListener)
1155     {
1156         ThrowOcException(OC_STACK_INVALID_PARAM, "getPairedDevList Callback cannot be null");
1157         return;
1158     }
1159     JniOnDPDevicesFoundListener *onGetPairedDevicesListener = AddOnDPDevicesFoundListener(env,
1160             jListener);
1161
1162     GetDirectPairedCallback getDirectPairedCallback =
1163         [onGetPairedDevicesListener](PairedDevices pairedDevList)
1164         {
1165             onGetPairedDevicesListener->directPairingDevicesCallback(pairedDevList,
1166                     DPFunc::GET_PAIRED_DEV_LIST);
1167         };
1168
1169     try
1170     {
1171         OCStackResult result = OCPlatform::getDirectPairedDevices(getDirectPairedCallback);
1172         if (OC_STACK_OK != result)
1173         {
1174             ThrowOcException(result, "OcDirectPairDevice_getDirectPairedDevices");
1175             return;
1176         }
1177     }
1178     catch (OCException& e)
1179     {
1180         LOGE("%s", e.reason().c_str());
1181         ThrowOcException(e.code(), e.reason().c_str());
1182     }
1183 }
1184
1185 /*
1186  * Class:     org_iotivity_base_OcPlatform
1187  * Method:    doDirectPairing
1188  * Signature: (Lorg/iotivity/base/OcDirectPairDevice;Lorg/iotivity/base/OcPrmType;
1189  *           Ljava/lang/String;Lorg/iotivity/base/OcDirectPairDevice/DirectPairingListener;)V
1190  */
1191 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_doDirectPairing0
1192 (JNIEnv *env, jclass clazz, jobject jpeer, jint jprmType, jstring jpin, jobject jListener)
1193 {
1194     LOGD("OcPlatform_doDirectPairing");
1195
1196     if (!jListener)
1197     {
1198         ThrowOcException(OC_STACK_INVALID_PARAM, "doDirectPairing Callback cannot be null");
1199         return;
1200     }
1201     if (!jpeer)
1202     {
1203         ThrowOcException(OC_STACK_INVALID_PARAM, "Peer cannot be null");
1204         return;
1205     }
1206
1207     JniOnDirectPairingListener *onDirectPairingListener = AddOnDirectPairingListener(env,
1208             jListener);
1209
1210     DirectPairingCallback DirectPairingCB =
1211         [onDirectPairingListener](std::shared_ptr<OCDirectPairing> dpDev, OCStackResult result)
1212         {
1213             onDirectPairingListener->doDirectPairingCB(dpDev, result);
1214         };
1215
1216     JniOcDirectPairDevice *dev = JniOcDirectPairDevice::getJniOcDirectPairDevicePtr(env, jpeer);
1217
1218     if (!dev)
1219     {
1220         return ;
1221     }
1222     std::string pin = env->GetStringUTFChars(jpin, 0);
1223
1224     try
1225     {
1226         OCStackResult result = OCPlatform::doDirectPairing(dev->getPtr(), (OCPrm_t)jprmType,
1227                 pin, DirectPairingCB);
1228         if (OC_STACK_OK != result)
1229         {
1230             ThrowOcException(result, "OcPlatform_oDirectPairing");
1231             return;
1232         }
1233     }
1234     catch (OCException& e)
1235     {
1236         LOGE("%s", e.reason().c_str());
1237         ThrowOcException(e.code(), e.reason().c_str());
1238     }
1239 }
1240
1241 /*
1242 * Class:     org_iotivity_base_OcPlatform
1243 * Method:    getDeviceInfo0
1244 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
1245 */
1246 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0(
1247     JNIEnv *env,
1248     jclass clazz,
1249     jstring jHost,
1250     jstring jResourceUri,
1251     jint jConnectivityType,
1252     jobject jListener)
1253 {
1254     LOGD("OcPlatform_getDeviceInfo0");
1255     std::string host;
1256     if (jHost)
1257     {
1258         host = env->GetStringUTFChars(jHost, nullptr);
1259     }
1260     std::string resourceUri;
1261     if (jResourceUri)
1262     {
1263         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1264     }
1265     if (!jListener)
1266     {
1267         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1268         return;
1269     }
1270     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1271
1272     FindDeviceCallback findDeviceCallback =
1273         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1274         {
1275             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1276         };
1277
1278     try
1279     {
1280         OCStackResult result = OCPlatform::getDeviceInfo(
1281             host,
1282             resourceUri,
1283             static_cast<OCConnectivityType>(jConnectivityType),
1284             findDeviceCallback);
1285
1286         if (OC_STACK_OK != result)
1287         {
1288             ThrowOcException(result, "Find device has failed");
1289         }
1290     }
1291     catch (OCException& e)
1292     {
1293         LOGE("%s", e.reason().c_str());
1294         ThrowOcException(e.code(), e.reason().c_str());
1295     }
1296 }
1297
1298 /*
1299 * Class:     org_iotivity_base_OcPlatform
1300 * Method:    getDeviceInfo1
1301 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
1302 */
1303 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1(
1304     JNIEnv *env,
1305     jclass clazz,
1306     jstring jHost,
1307     jstring jResourceUri,
1308     jint jConnectivityType,
1309     jobject jListener,
1310     jint jQoS)
1311 {
1312     LOGD("OcPlatform_getDeviceInfo1");
1313     std::string host;
1314     if (jHost)
1315     {
1316         host = env->GetStringUTFChars(jHost, nullptr);
1317     }
1318     std::string resourceUri;
1319     if (jResourceUri)
1320     {
1321         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1322     }
1323     if (!jListener)
1324     {
1325         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1326         return;
1327     }
1328     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1329
1330     FindDeviceCallback findDeviceCallback =
1331         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1332         {
1333             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1334         };
1335
1336     try
1337     {
1338         OCStackResult result = OCPlatform::getDeviceInfo(
1339             host,
1340             resourceUri,
1341             static_cast<OCConnectivityType>(jConnectivityType),
1342             findDeviceCallback,
1343             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1344
1345         if (OC_STACK_OK != result)
1346         {
1347             ThrowOcException(result, "Find device has failed");
1348         }
1349     }
1350     catch (OCException& e)
1351     {
1352         LOGE("%s", e.reason().c_str());
1353         ThrowOcException(e.code(), e.reason().c_str());
1354     }
1355 }
1356
1357 /*
1358 * Class:     org_iotivity_base_OcPlatform
1359 * Method:    getPlatformInfo0
1360 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
1361 */
1362 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0(
1363     JNIEnv *env,
1364     jclass clazz,
1365     jstring jHost,
1366     jstring jResourceUri,
1367     jint jConnectivityType,
1368     jobject jListener)
1369 {
1370     LOGD("OcPlatform_getPlatformInfo0");
1371     std::string host;
1372     if (jHost)
1373     {
1374         host = env->GetStringUTFChars(jHost, nullptr);
1375     }
1376     std::string resourceUri;
1377     if (jResourceUri)
1378     {
1379         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1380     }
1381     if (!jListener)
1382     {
1383         ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1384         return;
1385     }
1386     JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
1387
1388     FindPlatformCallback findPlatformCallback =
1389         [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
1390         {
1391             onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
1392         };
1393
1394     try
1395     {
1396         OCStackResult result = OCPlatform::getPlatformInfo(
1397             host,
1398             resourceUri,
1399             static_cast<OCConnectivityType>(jConnectivityType),
1400             findPlatformCallback);
1401
1402         if (OC_STACK_OK != result)
1403         {
1404             ThrowOcException(result, "Find platform has failed");
1405         }
1406     }
1407     catch (OCException& e)
1408     {
1409         LOGE("%s", e.reason().c_str());
1410         ThrowOcException(e.code(), e.reason().c_str());
1411     }
1412 }
1413
1414 /*
1415 * Class:     org_iotivity_base_OcPlatform
1416 * Method:    getPlatformInfo1
1417 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
1418 */
1419 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1(
1420     JNIEnv *env,
1421     jclass clazz,
1422     jstring jHost,
1423     jstring jResourceUri,
1424     jint jConnectivityType,
1425     jobject jListener,
1426     jint jQoS)
1427 {
1428     LOGD("OcPlatform_getPlatformInfo1");
1429     std::string host;
1430     if (jHost)
1431     {
1432         host = env->GetStringUTFChars(jHost, nullptr);
1433     }
1434     std::string resourceUri;
1435     if (jResourceUri)
1436     {
1437         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1438     }
1439     if (!jListener)
1440     {
1441         ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1442         return;
1443     }
1444     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1445
1446     FindDeviceCallback findDeviceCallback =
1447         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1448         {
1449             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1450         };
1451
1452     try
1453     {
1454         OCStackResult result = OCPlatform::getPlatformInfo(
1455             host,
1456             resourceUri,
1457             static_cast<OCConnectivityType>(jConnectivityType),
1458             findDeviceCallback,
1459             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1460
1461         if (OC_STACK_OK != result)
1462         {
1463             ThrowOcException(result, "Find platform has failed");
1464         }
1465     }
1466     catch (OCException& e)
1467     {
1468         LOGE("%s", e.reason().c_str());
1469         ThrowOcException(e.code(), e.reason().c_str());
1470     }
1471 }
1472
1473 /*
1474 * Class:     org_iotivity_base_OcPlatform
1475 * Method:    registerResource0
1476 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
1477 */
1478 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0(
1479     JNIEnv *env, jclass clazz, jobject jResource)
1480 {
1481     LOGD("OcPlatform_registerResource");
1482     if (!jResource)
1483     {
1484         ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
1485         return nullptr;
1486     }
1487     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
1488     if (!resource)
1489     {
1490         return nullptr;
1491     }
1492
1493     OCResourceHandle resourceHandle;
1494     try
1495     {
1496         OCStackResult result = OCPlatform::registerResource(
1497             resourceHandle,
1498             resource->getOCResource());
1499
1500         if (OC_STACK_OK != result)
1501         {
1502             ThrowOcException(result, "register resource");
1503         }
1504     }
1505     catch (OCException& e)
1506     {
1507         LOGE("%s", e.reason().c_str());
1508         ThrowOcException(e.code(), e.reason().c_str());
1509         return nullptr;
1510     }
1511     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1512     jlong handle = reinterpret_cast<jlong>(jniHandle);
1513     jobject jResourceHandle =
1514         env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1515
1516     if (!jResourceHandle)
1517     {
1518         LOGE("Failed to create OcResourceHandle");
1519         delete jniHandle;
1520     }
1521     return jResourceHandle;
1522 }
1523
1524 /*
1525 * Class:     org_iotivity_base_OcPlatform
1526 * Method:    registerResource1
1527 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
1528 */
1529 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1(
1530     JNIEnv *env,
1531     jclass clazz,
1532     jstring jResourceUri,
1533     jstring jResourceTypeName,
1534     jstring jResourceInterface,
1535 jobject jListener, jint jResourceProperty)
1536 {
1537     LOGI("OcPlatform_registerResource1");
1538     std::string resourceUri;
1539     if (jResourceUri)
1540     {
1541         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1542     }
1543     std::string resourceTypeName;
1544     if (jResourceTypeName)
1545     {
1546         resourceTypeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1547     }
1548     std::string resourceInterface;
1549     if (jResourceInterface)
1550     {
1551         resourceInterface = env->GetStringUTFChars(jResourceInterface, nullptr);
1552     }
1553     JniEntityHandler* entityHandler = NULL;
1554     EntityHandler handleEntityCallback = NULL;
1555     if (jListener)
1556     {
1557         entityHandler = new JniEntityHandler(env, jListener);
1558         handleEntityCallback =
1559             [entityHandler](const std::shared_ptr<OCResourceRequest> request) -> OCEntityHandlerResult
1560             {
1561                 return entityHandler->handleEntity(request);
1562             };
1563     }
1564
1565     OCResourceHandle resourceHandle;
1566     try
1567     {
1568         OCStackResult result = OCPlatform::registerResource(
1569             resourceHandle,
1570             resourceUri,
1571             resourceTypeName,
1572             resourceInterface,
1573             handleEntityCallback,
1574             static_cast<int>(jResourceProperty));
1575
1576         if (OC_STACK_OK != result)
1577         {
1578             delete entityHandler;
1579             ThrowOcException(result, "register resource");
1580             return nullptr;
1581         }
1582     }
1583     catch (OCException& e)
1584     {
1585         LOGE("%s", e.reason().c_str());
1586         delete entityHandler;
1587         ThrowOcException(e.code(), e.reason().c_str());
1588         return nullptr;
1589     }
1590
1591     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1592     jlong handle = reinterpret_cast<jlong>(jniHandle);
1593     jobject jResourceHandle =
1594         env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1595     if (!jResourceHandle)
1596     {
1597         LOGE("Failed to create OcResourceHandle");
1598         delete jniHandle;
1599     }
1600
1601     return jResourceHandle;
1602 }
1603
1604 /*
1605 * Class:     org_iotivity_base_OcPlatform
1606 * Method:    registerDeviceInfo0
1607 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
1608 */
1609 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0(
1610     JNIEnv *env,
1611     jclass clazz,
1612     jstring jDeviceName,
1613     jobjectArray jDeviceTypes)
1614 {
1615     LOGI("OcPlatform_registerDeviceInfo");
1616
1617     if (!jDeviceName)
1618     {
1619         ThrowOcException(OC_STACK_INVALID_PARAM, "deviceName cannot be null");
1620         return;
1621     }
1622
1623     if (!jDeviceTypes)
1624     {
1625         ThrowOcException(OC_STACK_INVALID_PARAM, "deviceTypes cannot be null");
1626         return;
1627     }
1628
1629     OCDeviceInfo deviceInfo;
1630     try
1631     {
1632         DuplicateString(&deviceInfo.deviceName, env->GetStringUTFChars(jDeviceName, nullptr));
1633         deviceInfo.types = NULL;
1634
1635         jsize len = env->GetArrayLength(jDeviceTypes);
1636         for (jsize i = 0; i < len; ++i)
1637         {
1638             jstring jStr = (jstring)env->GetObjectArrayElement(jDeviceTypes, i);
1639             if (!jStr)
1640             {
1641                 delete deviceInfo.deviceName;
1642                 ThrowOcException(OC_STACK_INVALID_PARAM, "device type cannot be null");
1643                 return;
1644             }
1645
1646             OCResourcePayloadAddStringLL(&deviceInfo.types, env->GetStringUTFChars(jStr, nullptr));
1647             if (env->ExceptionCheck())
1648             {
1649                 delete deviceInfo.deviceName;
1650                 return;
1651             }
1652
1653             env->DeleteLocalRef(jStr);
1654         }
1655     }
1656     catch (std::exception &e)
1657     {
1658         ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1659         return;
1660     }
1661
1662     try
1663     {
1664         OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1665
1666         delete deviceInfo.deviceName;
1667
1668         if (OC_STACK_OK != result)
1669         {
1670             ThrowOcException(result, "Failed to register device info");
1671             return;
1672         }
1673     }
1674     catch (OCException& e)
1675     {
1676         LOGE("%s", e.reason().c_str());
1677         ThrowOcException(e.code(), e.reason().c_str());
1678     }
1679 }
1680
1681 /*
1682 * Class:     org_iotivity_base_OcPlatform
1683 * Method:    registerPlatformInfo0
1684 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
1685 */
1686 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0(
1687     JNIEnv *env,
1688     jclass clazz,
1689     jstring jPlatformID,
1690     jstring jManufacturerName,
1691     jstring jManufacturerUrl,
1692     jstring jModelNumber,
1693     jstring jDateOfManufacture,
1694     jstring jPlatformVersion,
1695     jstring jOperatingSystemVersion,
1696     jstring jHardwareVersion,
1697     jstring jFirmwareVersion,
1698     jstring jSupportUrl,
1699     jstring jSystemTime)
1700 {
1701     LOGI("OcPlatform_registerPlatformInfo");
1702
1703
1704     std::string platformID;
1705         std::string manufacturerName;
1706         std::string manufacturerUrl;
1707         std::string modelNumber;
1708         std::string dateOfManufacture;
1709         std::string platformVersion;
1710         std::string operatingSystemVersion;
1711         std::string hardwareVersion;
1712         std::string firmwareVersion;
1713         std::string supportUrl;
1714         std::string systemTime;
1715
1716         if (jPlatformID)
1717         {
1718             platformID = env->GetStringUTFChars(jPlatformID, nullptr);
1719         }
1720         if (jManufacturerName)
1721         {
1722             manufacturerName = env->GetStringUTFChars(jManufacturerName, nullptr);
1723         }
1724         if (jManufacturerUrl)
1725         {
1726             manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, nullptr);
1727         }
1728         if (jModelNumber)
1729         {
1730             modelNumber = env->GetStringUTFChars(jModelNumber, nullptr);
1731         }
1732         if (jDateOfManufacture)
1733         {
1734             dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, nullptr);
1735         }
1736         if (jPlatformVersion)
1737         {
1738             platformVersion = env->GetStringUTFChars(jPlatformVersion, nullptr);
1739         }
1740         if (jOperatingSystemVersion)
1741         {
1742             operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, nullptr);
1743         }
1744         if (jHardwareVersion)
1745         {
1746             hardwareVersion = env->GetStringUTFChars(jHardwareVersion, nullptr);
1747         }
1748         if (jFirmwareVersion)
1749         {
1750             firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, nullptr);
1751         }
1752         if (jSupportUrl)
1753         {
1754             supportUrl = env->GetStringUTFChars(jSupportUrl, nullptr);
1755         }
1756         if (jSystemTime)
1757         {
1758             systemTime = env->GetStringUTFChars(jSystemTime, nullptr);
1759         }
1760
1761         OCPlatformInfo platformInfo;
1762         try
1763         {
1764             DuplicateString(&platformInfo.platformID, platformID);
1765             DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1766             DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1767             DuplicateString(&platformInfo.modelNumber, modelNumber);
1768             DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1769             DuplicateString(&platformInfo.platformVersion, platformVersion);
1770             DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1771             DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1772             DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1773             DuplicateString(&platformInfo.supportUrl, supportUrl);
1774             DuplicateString(&platformInfo.systemTime, systemTime);
1775         }
1776         catch (std::exception &e)
1777         {
1778             ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1779             return;
1780         }
1781
1782        // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID  = %s", platformID);
1783         try
1784         {
1785             OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1786
1787             delete platformInfo.platformID;
1788             delete platformInfo.manufacturerName;
1789             delete platformInfo.manufacturerUrl;
1790             delete platformInfo.modelNumber;
1791             delete platformInfo.dateOfManufacture;
1792             delete platformInfo.platformVersion;
1793             delete platformInfo.operatingSystemVersion;
1794             delete platformInfo.hardwareVersion;
1795             delete platformInfo.firmwareVersion;
1796             delete platformInfo.supportUrl;
1797             delete platformInfo.systemTime;
1798
1799             if (OC_STACK_OK != result)
1800             {
1801                 ThrowOcException(result, "Failed to register platform info");
1802                 return;
1803             }
1804         }
1805         catch (OCException& e)
1806         {
1807             LOGE("Error is due to %s", e.reason().c_str());
1808             ThrowOcException(e.code(), e.reason().c_str());
1809         }
1810 }
1811
1812 /*
1813 * Class:     org_iotivity_base_OcPlatform
1814 * Method:    unregisterResource0
1815 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1816 */
1817 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1818     JNIEnv *env, jclass clazz, jobject jResourceHandle)
1819 {
1820     LOGI("OcPlatform_unregisterResource");
1821     if (!jResourceHandle)
1822     {
1823         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1824         return;
1825     }
1826     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1827         env, jResourceHandle);
1828     if (!jniOcResourceHandle)
1829     {
1830         return;
1831     }
1832
1833     try
1834     {
1835         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1836         OCStackResult result = OCPlatform::unregisterResource(resHandle);
1837         if (OC_STACK_OK != result)
1838         {
1839             ThrowOcException(result, "Failed to unregister resource");
1840         }
1841     }
1842     catch (OCException& e)
1843     {
1844         LOGE("%s", e.reason().c_str());
1845         ThrowOcException(e.code(), e.reason().c_str());
1846     }
1847 }
1848
1849 /*
1850 * Class:     org_iotivity_base_OcPlatform
1851 * Method:    bindResource0
1852 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1853 */
1854 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1855 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1856 {
1857     LOGI("OcPlatform_bindResource");
1858     if (!jResourceCollectionHandle)
1859     {
1860         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1861         return;
1862     }
1863     if (!jResourceHandle)
1864     {
1865         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1866         return;
1867     }
1868     JniOcResourceHandle* jniOcResourceCollectionHandle =
1869         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1870     if (!jniOcResourceCollectionHandle)
1871     {
1872         return;
1873     }
1874
1875     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1876         env, jResourceHandle);
1877     if (!jniOcResourceHandle)
1878     {
1879         return;
1880     }
1881
1882     try
1883     {
1884         OCStackResult result = OCPlatform::bindResource(
1885             jniOcResourceCollectionHandle->getOCResourceHandle(),
1886             jniOcResourceHandle->getOCResourceHandle()
1887             );
1888
1889         if (OC_STACK_OK != result)
1890         {
1891             ThrowOcException(result, "Failed to bind resource");
1892         }
1893     }
1894     catch (OCException& e)
1895     {
1896         LOGE("%s", e.reason().c_str());
1897         ThrowOcException(e.code(), e.reason().c_str());
1898     }
1899 }
1900
1901 /*
1902 * Class:     org_iotivity_base_OcPlatform
1903 * Method:    bindResources0
1904 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1905 */
1906 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1907     JNIEnv *env,
1908     jclass clazz,
1909     jobject jResourceCollectionHandle,
1910     jobjectArray jResourceHandleArray)
1911 {
1912     LOGI("OcPlatform_bindResources");
1913
1914     if (!jResourceCollectionHandle)
1915     {
1916         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1917         return;
1918     }
1919     if (!jResourceHandleArray)
1920     {
1921         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1922         return;
1923     }
1924
1925     JniOcResourceHandle* jniOcResourceCollectionHandle =
1926         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1927     if (!jniOcResourceCollectionHandle)
1928     {
1929         return;
1930     }
1931
1932     std::vector<OCResourceHandle> resourceHandleList;
1933     int len = env->GetArrayLength(jResourceHandleArray);
1934     for (int i = 0; i < len; ++i)
1935     {
1936         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1937         if (!jResourceHandle)
1938         {
1939             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1940             return;
1941         }
1942
1943         JniOcResourceHandle* jniOcResourceHandle =
1944             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1945         if (!jniOcResourceHandle)
1946         {
1947             return;
1948         }
1949
1950         resourceHandleList.push_back(
1951             jniOcResourceHandle->getOCResourceHandle());
1952     }
1953
1954     try
1955     {
1956         OCStackResult result = OCPlatform::bindResources(
1957             jniOcResourceCollectionHandle->getOCResourceHandle(),
1958             resourceHandleList
1959             );
1960
1961         if (OC_STACK_OK != result)
1962         {
1963             ThrowOcException(result, "Failed to bind resources");
1964         }
1965     }
1966     catch (OCException& e)
1967     {
1968         LOGE("%s", e.reason().c_str());
1969         ThrowOcException(e.code(), e.reason().c_str());
1970     }
1971 }
1972
1973 /*
1974 * Class:     org_iotivity_base_OcPlatform
1975 * Method:    unbindResource0
1976 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1977 */
1978 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1979     JNIEnv *env,
1980     jclass clazz,
1981     jobject jResourceCollectionHandle,
1982     jobject jResourceHandle)
1983 {
1984     LOGI("OcPlatform_unbindResource");
1985     if (!jResourceCollectionHandle)
1986     {
1987         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1988         return;
1989     }
1990     if (!jResourceHandle)
1991     {
1992         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1993         return;
1994     }
1995
1996     JniOcResourceHandle* jniOcResourceCollectionHandle =
1997         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1998     if (!jniOcResourceCollectionHandle)
1999     {
2000         return;
2001     }
2002
2003     JniOcResourceHandle* jniOcResourceHandle =
2004         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2005     if (!jniOcResourceHandle)
2006     {
2007         return;
2008     }
2009
2010     try
2011     {
2012         OCStackResult result = OCPlatform::unbindResource(
2013             jniOcResourceCollectionHandle->getOCResourceHandle(),
2014             jniOcResourceHandle->getOCResourceHandle());
2015
2016         if (OC_STACK_OK != result)
2017         {
2018             ThrowOcException(result, "Failed to unbind resource");
2019         }
2020     }
2021     catch (OCException& e)
2022     {
2023         LOGE("%s", e.reason().c_str());
2024         ThrowOcException(e.code(), e.reason().c_str());
2025     }
2026 }
2027
2028 /*
2029 * Class:     org_iotivity_base_OcPlatform
2030 * Method:    unbindResources0
2031 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
2032 */
2033 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
2034     JNIEnv *env,
2035     jclass clazz,
2036     jobject jResourceCollectionHandle,
2037     jobjectArray jResourceHandleArray)
2038 {
2039     LOGI("OcPlatform_unbindResources");
2040     if (!jResourceCollectionHandle)
2041     {
2042         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
2043         return;
2044     }
2045     if (!jResourceHandleArray)
2046     {
2047         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
2048         return;
2049     }
2050
2051     JniOcResourceHandle* jniOcResourceCollectionHandle =
2052         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
2053     if (!jniOcResourceCollectionHandle)
2054     {
2055         return;
2056     }
2057
2058     std::vector<OCResourceHandle> resourceHandleList;
2059     int len = env->GetArrayLength(jResourceHandleArray);
2060     for (int i = 0; i < len; ++i)
2061     {
2062         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
2063         if (!jResourceHandle)
2064         {
2065             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
2066             return;
2067         }
2068
2069         JniOcResourceHandle* jniOcResourceHandle =
2070             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2071         if (!jniOcResourceHandle)
2072         {
2073             return;
2074         }
2075
2076         resourceHandleList.push_back(
2077             jniOcResourceHandle->getOCResourceHandle());
2078     }
2079
2080     try
2081     {
2082         OCStackResult result = OCPlatform::unbindResources(
2083             jniOcResourceCollectionHandle->getOCResourceHandle(),
2084             resourceHandleList
2085             );
2086
2087         if (OC_STACK_OK != result)
2088         {
2089             ThrowOcException(result, "Failed to unbind resources");
2090         }
2091     }
2092     catch (OCException& e)
2093     {
2094         LOGE("%s", e.reason().c_str());
2095         ThrowOcException(e.code(), e.reason().c_str());
2096     }
2097 }
2098
2099 /*
2100 * Class:     org_iotivity_base_OcPlatform
2101 * Method:    bindTypeToResource0
2102 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
2103 */
2104 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
2105     JNIEnv *env,
2106     jclass clazz,
2107     jobject jResourceHandle,
2108     jstring jResourceTypeName)
2109 {
2110     LOGI("OcPlatform_bindTypeToResource");
2111     if (!jResourceHandle)
2112     {
2113         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
2114         return;
2115     }
2116     std::string typeName;
2117     if (jResourceTypeName)
2118     {
2119         typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
2120     }
2121
2122     JniOcResourceHandle* jniOcResourceHandle =
2123         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2124     if (!jniOcResourceHandle)
2125     {
2126         return;
2127     }
2128
2129     try
2130     {
2131         OCStackResult result = OCPlatform::bindTypeToResource(
2132             jniOcResourceHandle->getOCResourceHandle(),
2133             typeName
2134             );
2135
2136         if (OC_STACK_OK != result)
2137         {
2138             ThrowOcException(result, "Failed to bind type to resource");
2139         }
2140     }
2141     catch (OCException& e)
2142     {
2143         LOGE("%s", e.reason().c_str());
2144         ThrowOcException(e.code(), e.reason().c_str());
2145     }
2146 }
2147
2148 /*
2149 * Class:     org_iotivity_base_OcPlatform
2150 * Method:    bindInterfaceToResource0
2151 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
2152 */
2153 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
2154 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
2155 {
2156     LOGI("OcPlatform_bindInterfaceToResource");
2157     if (!jResourceHandle)
2158     {
2159         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
2160         return;
2161     }
2162     std::string interfaceName;
2163     if (jResourceInterfaceName)
2164     {
2165         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
2166     }
2167
2168     JniOcResourceHandle* jniOcResourceHandle =
2169         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2170     if (!jniOcResourceHandle)
2171     {
2172         return;
2173     }
2174
2175     try
2176     {
2177         OCStackResult result = OCPlatform::bindInterfaceToResource(
2178             jniOcResourceHandle->getOCResourceHandle(),
2179             interfaceName
2180             );
2181
2182         if (OC_STACK_OK != result)
2183         {
2184             ThrowOcException(result, "Failed to bind interface to resource");
2185         }
2186     }
2187     catch (OCException& e)
2188     {
2189         LOGE("%s", e.reason().c_str());
2190         ThrowOcException(e.code(), e.reason().c_str());
2191     }
2192 }
2193
2194 /*
2195 * Class:     org_iotivity_base_OcPlatform
2196 * Method:    startPresence0
2197 * Signature: (I)V
2198 */
2199 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
2200     JNIEnv *env, jclass clazz, jint ttl)
2201 {
2202     LOGI("OcPlatform_startPresence");
2203
2204     try
2205     {
2206         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
2207
2208         if (OC_STACK_OK != result)
2209         {
2210             ThrowOcException(result, "Failed to start presence");
2211         }
2212     }
2213     catch (OCException& e)
2214     {
2215         LOGE("%s", e.reason().c_str());
2216         ThrowOcException(e.code(), e.reason().c_str());
2217     }
2218 }
2219
2220 /*
2221 * Class:     org_iotivity_base_OcPlatform
2222 * Method:    stopPresence0
2223 * Signature: ()V
2224 */
2225 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
2226     JNIEnv *env, jclass clazz)
2227 {
2228     LOGI("OcPlatform_stopPresence");
2229
2230     try
2231     {
2232         OCStackResult result = OCPlatform::stopPresence();
2233
2234         if (OC_STACK_OK != result)
2235         {
2236             ThrowOcException(result, "Failed to stop presence");
2237         }
2238     }
2239     catch (OCException& e)
2240     {
2241         LOGE("%s", e.reason().c_str());
2242         ThrowOcException(e.code(), e.reason().c_str());
2243     }
2244 }
2245
2246 /*
2247 * Class:     org_iotivity_base_OcPlatform
2248 * Method:    subscribePresence0
2249 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2250 */
2251 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
2252     JNIEnv *env,
2253     jclass clazz,
2254     jstring jHost,
2255     jint jConnectivityType,
2256     jobject jListener)
2257 {
2258     LOGD("OcPlatform_subscribePresence");
2259     std::string host;
2260     if (jHost)
2261     {
2262         host = env->GetStringUTFChars(jHost, nullptr);
2263     }
2264     if (!jListener)
2265     {
2266         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2267         return nullptr;
2268     }
2269
2270     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2271
2272     SubscribeCallback subscribeCallback =
2273         [onPresenceListener](OCStackResult result,
2274                              const unsigned int nonce,
2275                              const std::string& hostAddress)
2276         {
2277             onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2278         };
2279
2280     OCPlatform::OCPresenceHandle presenceHandle;
2281     try
2282     {
2283         OCStackResult result = OCPlatform::subscribePresence(
2284             presenceHandle,
2285             host,
2286             static_cast<OCConnectivityType>(jConnectivityType),
2287             subscribeCallback);
2288
2289         if (OC_STACK_OK != result)
2290         {
2291             ThrowOcException(result, "subscribe presence has failed");
2292         }
2293     }
2294     catch (OCException& e)
2295     {
2296         LOGE("%s", e.reason().c_str());
2297         ThrowOcException(e.code(), e.reason().c_str());
2298         return nullptr;
2299     }
2300
2301     JniOcPresenceHandle* jniPresenceHandle =
2302         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2303     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2304     jobject jPresenceHandle =
2305         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2306     if (!jPresenceHandle)
2307     {
2308         LOGE("Failed to create OcPresenceHandle");
2309         delete jniPresenceHandle;
2310     }
2311     return jPresenceHandle;
2312 }
2313
2314 /*
2315 * Class:     org_iotivity_base_OcPlatform
2316 * Method:    subscribePresence1
2317 * Signature: (Ljava/lang/String;Ljava/lang/String;I
2318 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2319 */
2320 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
2321     JNIEnv *env,
2322     jclass clazz,
2323     jstring jHost,
2324     jstring jResourceType,
2325     jint jConnectivityType,
2326     jobject jListener)
2327 {
2328     LOGD("OcPlatform_subscribePresence1");
2329     std::string host;
2330     if (jHost)
2331     {
2332         host = env->GetStringUTFChars(jHost, nullptr);
2333     }
2334     std::string resourceType;
2335     if (jResourceType)
2336     {
2337         resourceType = env->GetStringUTFChars(jResourceType, nullptr);
2338     }
2339     if (!jListener)
2340     {
2341         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2342         return nullptr;
2343     }
2344
2345     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2346
2347     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
2348         const unsigned int nonce, const std::string& hostAddress)
2349     {
2350         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2351     };
2352
2353     OCPlatform::OCPresenceHandle presenceHandle;
2354     try
2355     {
2356         OCStackResult result = OCPlatform::subscribePresence(
2357             presenceHandle,
2358             host,
2359             resourceType,
2360             static_cast<OCConnectivityType>(jConnectivityType),
2361             subscribeCallback);
2362
2363         if (OC_STACK_OK != result)
2364         {
2365             ThrowOcException(result, "subscribe presence has failed");
2366         }
2367     }
2368     catch (OCException& e)
2369     {
2370         LOGE("%s", e.reason().c_str());
2371         ThrowOcException(e.code(), e.reason().c_str());
2372         return nullptr;
2373     }
2374
2375     JniOcPresenceHandle* jniPresenceHandle =
2376         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2377     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2378     jobject jPresenceHandle =
2379         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2380     if (!jPresenceHandle)
2381     {
2382         LOGE("Failed to create OcPresenceHandle");
2383         delete jniPresenceHandle;
2384     }
2385     return jPresenceHandle;
2386 }
2387
2388 /*
2389 * Class:     org_iotivity_base_OcPlatform
2390 * Method:    unsubscribePresence0
2391 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
2392 */
2393 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
2394     JNIEnv *env, jclass clazz, jobject jPresenceHandle)
2395 {
2396     LOGD("OcPlatform_unsubscribePresence");
2397     if (!jPresenceHandle)
2398     {
2399         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
2400         return;
2401     }
2402     JniOcPresenceHandle* jniPresenceHandle =
2403         JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
2404     if (!jniPresenceHandle)
2405     {
2406         return;
2407     }
2408
2409     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
2410
2411     try
2412     {
2413         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
2414
2415         if (OC_STACK_OK != result)
2416         {
2417             ThrowOcException(result, "unsubscribe presence has failed");
2418             return;
2419         }
2420         jweak jwOnPresenceListener =
2421             jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
2422         if (jwOnPresenceListener)
2423         {
2424             RemoveOnPresenceListener(env, jwOnPresenceListener);
2425         }
2426         jweak jwOnObserveListener =
2427             jniPresenceHandle->getJniOnObserveListener()->getJWListener();
2428         if (jwOnObserveListener)
2429         {
2430             RemoveOnObserveListener(env, jwOnObserveListener);
2431         }
2432     }
2433     catch (OCException& e)
2434     {
2435         LOGE("%s", e.reason().c_str());
2436         ThrowOcException(e.code(), e.reason().c_str());
2437     }
2438 }
2439
2440 /*
2441 * Class:     org_iotivity_base_OcPlatform
2442 * Method:    subscribeDevicePresence0
2443 * Signature: (Ljava/lang/String;[Ljava/lang/String;I
2444 Lorg/iotivity/base/OcResource/OnObserveListener;)Lorg/iotivity/base/OcPresenceHandle;
2445 */
2446 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribeDevicePresence0(
2447     JNIEnv *env,
2448     jclass clazz,
2449     jstring jHost,
2450     jobjectArray jDiArray,
2451     jint jConnectivityType,
2452     jobject jListener)
2453 {
2454     LOGD("OcPlatform_subscribeDevicePresence0");
2455 #ifdef WITH_CLOUD
2456     std::string host;
2457     if (jHost)
2458     {
2459         host = env->GetStringUTFChars(jHost, nullptr);
2460     }
2461
2462     if (!jDiArray)
2463     {
2464         ThrowOcException(OC_STACK_INVALID_PARAM, "device id List cannot be null");
2465         return nullptr;
2466     }
2467
2468     std::vector<std::string> di;
2469     JniUtils::convertJavaStrArrToStrVector(env, jDiArray, di);
2470
2471     if (!jListener)
2472     {
2473         ThrowOcException(OC_STACK_INVALID_PARAM, "onObserveListener cannot be null");
2474         return nullptr;
2475     }
2476
2477     JniOnObserveListener *onObserveListener = AddOnObserveListener(env, jListener);
2478
2479     ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
2480         const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
2481     {
2482         onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
2483     };
2484
2485     OCPlatform::OCPresenceHandle presenceHandle;
2486     try
2487     {
2488         OCStackResult result = OCPlatform::subscribeDevicePresence(
2489             presenceHandle,
2490             host,
2491             di,
2492             static_cast<OCConnectivityType>(jConnectivityType),
2493             observeCallback);
2494
2495         if (OC_STACK_OK != result)
2496         {
2497             ThrowOcException(result, "subscribe device presence has failed");
2498         }
2499     }
2500     catch (OCException& e)
2501     {
2502         LOGE("%s", e.reason().c_str());
2503         ThrowOcException(e.code(), e.reason().c_str());
2504         return nullptr;
2505     }
2506
2507     JniOcPresenceHandle* jniPresenceHandle =
2508         new JniOcPresenceHandle(onObserveListener, presenceHandle);
2509     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2510     jobject jPresenceHandle =
2511         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2512     if (!jPresenceHandle)
2513     {
2514         LOGE("Failed to create OcPresenceHandle");
2515         delete jniPresenceHandle;
2516     }
2517     return jPresenceHandle;
2518 #else
2519     ThrowOcException(JNI_EXCEPTION, "Not support");
2520     return nullptr;
2521 #endif
2522 }
2523
2524 /*
2525 * Class:     org_iotivity_base_OcPlatform
2526 * Method:    constructResourceObject0
2527 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
2528 Lorg/iotivity/base/OcResource;
2529 */
2530 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
2531     JNIEnv *env,
2532     jclass clazz,
2533     jstring jHost,
2534     jstring jUri,
2535     jint jConnectivityType,
2536     jboolean jIsObservable,
2537     jobjectArray jResourceTypeArray,
2538     jobjectArray jInterfaceArray)
2539 {
2540     LOGD("OcPlatform_constructResourceObject");
2541     std::string host;
2542     if (jHost)
2543     {
2544         host = env->GetStringUTFChars(jHost, nullptr);
2545     }
2546     std::string uri;
2547     if (jUri)
2548     {
2549         uri = env->GetStringUTFChars(jUri, nullptr);
2550     }
2551     if (!jResourceTypeArray)
2552     {
2553         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
2554         return nullptr;
2555     }
2556     if (!jInterfaceArray)
2557     {
2558         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
2559         return nullptr;
2560     }
2561
2562     std::vector<std::string> resourceTypes;
2563     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
2564
2565     std::vector<std::string> interfaces;
2566     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
2567
2568     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
2569         host,
2570         uri,
2571         static_cast<OCConnectivityType>(jConnectivityType),
2572         static_cast<bool>(jIsObservable),
2573         resourceTypes,
2574         interfaces);
2575
2576     if (!resource)
2577     {
2578         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
2579         return nullptr;
2580     }
2581
2582     JniOcResource *jniOcResource = new JniOcResource(resource);
2583
2584     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
2585     if (!jResource)
2586     {
2587         delete jniOcResource;
2588         return nullptr;
2589     }
2590     SetHandle<JniOcResource>(env, jResource, jniOcResource);
2591     if (env->ExceptionCheck())
2592     {
2593         delete jniOcResource;
2594         return nullptr;
2595     }
2596     return jResource;
2597 }
2598
2599 /*
2600 * Class:     org_iotivity_base_OcPlatform
2601 * Method:    sendResponse0
2602 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
2603 */
2604 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
2605     JNIEnv *env, jclass clazz, jobject jResourceResponse)
2606 {
2607     LOGD("OcPlatform_sendResponse");
2608     if (!jResourceResponse)
2609     {
2610         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
2611         return;
2612     }
2613
2614     JniOcResourceResponse *jniResponse =
2615         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
2616     if (!jniResponse)
2617     {
2618         return;
2619     }
2620
2621     try
2622     {
2623         OCStackResult result =
2624             OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
2625
2626         if (OC_STACK_OK != result)
2627         {
2628             ThrowOcException(result, "failed to send response");
2629         }
2630     }
2631     catch (OCException& e)
2632     {
2633         LOGE("%s", e.reason().c_str());
2634         ThrowOcException(e.code(), e.reason().c_str());
2635     }
2636 }
2637
2638 /*
2639  * Class:     org_iotivity_base_OcPlatform
2640  * Method:    publishResourceToRD0
2641  * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPublishResourceListener;I)V
2642  */
2643 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_publishResourceToRD0(
2644         JNIEnv *env,
2645         jclass clazz,
2646         jstring jHost,
2647         jint jConnectivityType,
2648         jobject jListener,
2649         jint jQoS)
2650 {
2651     LOGD("OcPlatform_publishResourceToRD");
2652 #ifdef RD_CLIENT
2653     std::string host;
2654     if (jHost)
2655     {
2656         host = env->GetStringUTFChars(jHost, nullptr);
2657     }
2658     if (!jListener)
2659     {
2660         ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
2661         return;
2662     }
2663     JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
2664
2665     PublishResourceCallback pubResCallback = [onPubResListener](
2666             const OCRepresentation& ocRepresentation,
2667             const int eCode)
2668     {
2669         onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
2670     };
2671
2672     try
2673     {
2674         OCStackResult result = OCPlatform::publishResourceToRD(
2675             host,
2676             static_cast<OCConnectivityType>(jConnectivityType),
2677             pubResCallback,
2678             JniUtils::getQOS(env, static_cast<int>(jQoS)));
2679
2680         if (OC_STACK_OK != result)
2681         {
2682             ThrowOcException(result, "Publish resource has failed");
2683             return;
2684         }
2685     }
2686     catch (OCException& e)
2687     {
2688         LOGE("%s", e.reason().c_str());
2689         ThrowOcException(e.code(), e.reason().c_str());
2690     }
2691 #else
2692     ThrowOcException(OC_STACK_ERROR, "Publish resource has failed");
2693     return;
2694 #endif
2695 }
2696
2697 /*
2698  * Class:     org_iotivity_base_OcPlatform
2699  * Method:    publishResourceToRD1
2700  * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcPlatform/OnPublishResourceListener;I)V
2701  */
2702 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_publishResourceToRD1(
2703         JNIEnv *env,
2704         jclass clazz,
2705         jstring jHost,
2706         jint jConnectivityType,
2707         jobjectArray jResourceHandleArray,
2708         jobject jListener,
2709         jint jQoS)
2710 {
2711     LOGD("OcPlatform_publishResourceToRD");
2712 #ifdef RD_CLIENT
2713     if (!env)
2714     {
2715         ThrowOcException(OC_STACK_INVALID_PARAM, "env is null");
2716         return;
2717     }
2718     std::string host;
2719     if (jHost)
2720     {
2721         host = env->GetStringUTFChars(jHost, nullptr);
2722     }
2723     if (!jListener)
2724     {
2725         ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
2726         return;
2727     }
2728     if (!jResourceHandleArray)
2729     {
2730         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
2731         return;
2732     }
2733     JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
2734
2735     PublishResourceCallback pubResCallback = [onPubResListener](
2736             const OCRepresentation& ocRepresentation,
2737             const int eCode)
2738     {
2739         onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
2740     };
2741
2742     std::vector<OCResourceHandle> resourceHandleList;
2743     size_t len = env->GetArrayLength(jResourceHandleArray);
2744     for (size_t i = 0; i < len; ++i)
2745     {
2746         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
2747         if (!jResourceHandle)
2748         {
2749             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
2750             return;
2751         }
2752
2753         JniOcResourceHandle* jniOcResourceHandle =
2754             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2755         if (!jniOcResourceHandle)
2756         {
2757             ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
2758             return;
2759         }
2760
2761         resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
2762     }
2763
2764     try
2765     {
2766         OCStackResult result = OCPlatform::publishResourceToRD(
2767             host,
2768             static_cast<OCConnectivityType>(jConnectivityType),
2769             resourceHandleList,
2770             pubResCallback,
2771             JniUtils::getQOS(env, static_cast<int>(jQoS)));
2772
2773         if (OC_STACK_OK != result)
2774         {
2775             ThrowOcException(result, "Publish resource has failed");
2776             return;
2777         }
2778     }
2779     catch (OCException& e)
2780     {
2781         LOGE("%s", e.reason().c_str());
2782         ThrowOcException(e.code(), e.reason().c_str());
2783     }
2784 #else
2785     ThrowOcException(OC_STACK_ERROR, "Publish resource has failed");
2786     return;
2787 #endif
2788 }
2789
2790 /*
2791  * Class:     org_iotivity_base_OcPlatform
2792  * Method:    deleteResourceFromRD0
2793  * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeleteResourceListener;I)V
2794  */
2795 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_deleteResourceFromRD0(
2796         JNIEnv *env,
2797         jclass clazz,
2798         jstring jHost,
2799         jint jConnectivityType,
2800         jobject jListener,
2801         jint jQoS)
2802 {
2803     LOGD("OcPlatform_deleteResourceFromRD");
2804 #ifdef RD_CLIENT
2805     std::string host;
2806     if (jHost)
2807     {
2808         host = env->GetStringUTFChars(jHost, nullptr);
2809     }
2810     if (!jListener)
2811     {
2812         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
2813         return;
2814     }
2815     JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
2816
2817     DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
2818     {
2819         onDelResListener->onDeleteResourceCallback(eCode);
2820     };
2821
2822     try
2823     {
2824         OCStackResult result = OCPlatform::deleteResourceFromRD(
2825             host,
2826             static_cast<OCConnectivityType>(jConnectivityType),
2827             delResCallback,
2828             JniUtils::getQOS(env, static_cast<int>(jQoS)));
2829
2830         if (OC_STACK_OK != result)
2831         {
2832             ThrowOcException(result, "Delete resource has failed");
2833             return;
2834         }
2835     }
2836     catch (OCException& e)
2837     {
2838         LOGE("%s", e.reason().c_str());
2839         ThrowOcException(e.code(), e.reason().c_str());
2840     }
2841 #else
2842     ThrowOcException(OC_STACK_ERROR, "Delete resource has failed");
2843     return;
2844 #endif
2845 }
2846
2847 /*
2848  * Class:     org_iotivity_base_OcPlatform
2849  * Method:    deleteResourceFromRD1
2850  * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcPlatform/OnDeleteResourceListener;I)V
2851  */
2852 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_deleteResourceFromRD1(
2853         JNIEnv *env,
2854         jclass clazz,
2855         jstring jHost,
2856         jint jConnectivityType,
2857         jobjectArray jResourceHandleArray,
2858         jobject jListener,
2859         jint jQoS)
2860 {
2861     LOGD("OcPlatform_deleteResourceFromRD");
2862 #ifdef RD_CLIENT
2863     if (!env)
2864     {
2865         ThrowOcException(OC_STACK_INVALID_PARAM, "env is null");
2866         return;
2867     }
2868     std::string host;
2869     if (jHost)
2870     {
2871         host = env->GetStringUTFChars(jHost, nullptr);
2872     }
2873     if (!jListener)
2874     {
2875         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
2876         return;
2877     }
2878     if (!jResourceHandleArray)
2879     {
2880         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
2881         return;
2882     }
2883     JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
2884
2885     DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
2886     {
2887         onDelResListener->onDeleteResourceCallback(eCode);
2888     };
2889
2890     std::vector<OCResourceHandle> resourceHandleList;
2891     size_t len = env->GetArrayLength(jResourceHandleArray);
2892     for (size_t i = 0; i < len; ++i)
2893     {
2894         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
2895         if (!jResourceHandle)
2896         {
2897             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
2898             return;
2899         }
2900
2901         JniOcResourceHandle* jniOcResourceHandle =
2902             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2903         if (!jniOcResourceHandle)
2904         {
2905             ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
2906             return;
2907         }
2908
2909         resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
2910     }
2911
2912     try
2913     {
2914         OCStackResult result = OCPlatform::deleteResourceFromRD(
2915             host,
2916             static_cast<OCConnectivityType>(jConnectivityType),
2917             resourceHandleList,
2918             delResCallback,
2919             JniUtils::getQOS(env, static_cast<int>(jQoS)));
2920
2921         if (OC_STACK_OK != result)
2922         {
2923             ThrowOcException(result, "Delete resource has failed");
2924             return;
2925         }
2926     }
2927     catch (OCException& e)
2928     {
2929         LOGE("%s", e.reason().c_str());
2930         ThrowOcException(e.code(), e.reason().c_str());
2931     }
2932 #else
2933     ThrowOcException(OC_STACK_ERROR, "Delete resource has failed");
2934     return;
2935 #endif
2936 }
2937
2938 /*
2939 * Class:     org_iotivity_base_OcPlatform
2940 * Method:    constructAccountManagerObject0
2941 * Signature: (Ljava/lang/String;I)Lorg/iotivity/base/OcAccountManager;
2942 */
2943 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructAccountManagerObject0(
2944     JNIEnv *env,
2945     jclass clazz,
2946     jstring jHost,
2947     jint jConnectivityType)
2948 {
2949 #ifndef WITH_CLOUD
2950     ThrowOcException(OC_STACK_ERROR,
2951                      "OCAccountManager is not supported. (Please build with WITH_CLOUD=1 option)");
2952     return nullptr;
2953 #else
2954     LOGD("OcPlatform_constructAccountManagerObject");
2955     if (!jHost)
2956     {
2957         ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
2958         return nullptr;
2959     }
2960
2961     const char* charHost = env->GetStringUTFChars(jHost, nullptr);
2962     if (!charHost)
2963     {
2964         ThrowOcException(JNI_EXCEPTION, "charHost is null");
2965         return nullptr;
2966     }
2967     std::string host(charHost);
2968     env->ReleaseStringUTFChars(jHost, charHost);
2969
2970     std::shared_ptr<OCAccountManager> accountManager = OCPlatform::constructAccountManagerObject(
2971         host,
2972         static_cast<OCConnectivityType>(jConnectivityType));
2973
2974     if (!accountManager)
2975     {
2976         ThrowOcException(OC_STACK_ERROR, "Failed to create OCAccountManager");
2977         return nullptr;
2978     }
2979
2980     JniOcAccountManager *jniOcAccountManager = new JniOcAccountManager(accountManager);
2981
2982     jobject jAccountManager = env->NewObject(g_cls_OcAccountManager, g_mid_OcAccountManager_ctor);
2983     if (!jAccountManager)
2984     {
2985         delete jniOcAccountManager;
2986         return nullptr;
2987     }
2988     SetHandle<JniOcAccountManager>(env, jAccountManager, jniOcAccountManager);
2989     if (env->ExceptionCheck())
2990     {
2991         delete jniOcAccountManager;
2992         return nullptr;
2993     }
2994     return jAccountManager;
2995 #endif
2996 }