android/android_api/base/jni/JniOcPlatform.cpp

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