android/android_api/base/jni/JniOcPlatform.cpp

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