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