android/android_api/base/jni/JniOcPlatform.cpp

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