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     FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
 773     {
 774         onResFoundListener->findResourceErrorCallback(uri, eCode);
 775     };
 776
 777     try
 778     {
 779         OCStackResult result = OCPlatform::findResource(
 780             host,
 781             resourceUri,
 782             static_cast<OCConnectivityType>(jConnectivityType),
 783             findCallback,
 784             findErrorCallback);
 785
 786         if (OC_STACK_OK != result)
 787         {
 788             ThrowOcException(result, "Find resource has failed");
 789             return;
 790         }
 791     }
 792     catch (OCException& e)
 793     {
 794         LOGE("%s", e.reason().c_str());
 795         ThrowOcException(e.code(), e.reason().c_str());
 796     }
 797 }
 798
 799 /*
 800 * Class:     org_iotivity_base_OcPlatform
 801 * Method:    findResource1
 802 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
 803 */
 804 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1(
 805     JNIEnv *env,
 806     jclass clazz,
 807     jstring jHost,
 808     jstring jResourceUri,
 809     jint jConnectivityType,
 810     jobject jListener,
 811     jint jQoS)
 812 {
 813     LOGD("OcPlatform_findResource");
 814     std::string host;
 815     if (jHost)
 816     {
 817         host = env->GetStringUTFChars(jHost, nullptr);
 818     }
 819     std::string resourceUri;
 820     if (jResourceUri)
 821     {
 822         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
 823     }
 824     if (!jListener)
 825     {
 826         ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
 827         return;
 828     }
 829     JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
 830
 831     FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
 832     {
 833         onResFoundListener->foundResourceCallback(resource);
 834     };
 835
 836     FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
 837     {
 838         onResFoundListener->findResourceErrorCallback(uri, eCode);
 839     };
 840
 841     try
 842     {
 843         OCStackResult result = OCPlatform::findResource(
 844             host,
 845             resourceUri,
 846             static_cast<OCConnectivityType>(jConnectivityType),
 847             findCallback,
 848             findErrorCallback,
 849             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 850
 851         if (OC_STACK_OK != result)
 852         {
 853             ThrowOcException(result, "Find resource has failed");
 854             return;
 855         }
 856     }
 857     catch (OCException& e)
 858     {
 859         LOGE("%s", e.reason().c_str());
 860         ThrowOcException(e.code(), e.reason().c_str());
 861     }
 862 }
 863
 864 /*
 865  * Class:     org_iotivity_base_OcPlatform
 866  * Method:    findDirectPairingDevices
 867  * Signature: (ILorg/iotivity/base/OcPlatform/FindDirectPairingListener;)V
 868  */
 869 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findDirectPairingDevices
 870   (JNIEnv * env, jclass clazz, jint jTimeout, jobject jListener)
 871 {
 872     LOGD("OcPlatform_findDirectPairingDevices");
 873
 874     if (!jListener)
 875     {
 876         ThrowOcException(OC_STACK_INVALID_PARAM, "onDPDevicesFoundListener cannot be null");
 877         return;
 878     }
 879     JniOnDPDevicesFoundListener *onDPDevsFoundListener = AddOnDPDevicesFoundListener(env,
 880             jListener);
 881
 882     GetDirectPairedCallback getDirectPairedCallback =
 883         [onDPDevsFoundListener](PairedDevices pairingDevList)
 884         {
 885             onDPDevsFoundListener->directPairingDevicesCallback(pairingDevList,
 886                     DPFunc::FIND_DIRECT_PAIRED_DEV_LIST);
 887         };
 888
 889     try
 890     {
 891         OCStackResult result = OCPlatform::findDirectPairingDevices(jTimeout,
 892                 getDirectPairedCallback);
 893         if (OC_STACK_OK != result)
 894         {
 895             ThrowOcException(result, "OCPlatform::findDirectPairingDevices has failed");
 896             return;
 897         }
 898     }
 899     catch (OCException& e)
 900     {
 901         LOGE("%s", e.reason().c_str());
 902         ThrowOcException(e.code(), e.reason().c_str());
 903     }
 904 }
 905
 906 /*
 907  * Class:     org_iotivity_base_OcPlatform
 908  * Method:    getDirectPairedDevices
 909  * Signature: (Lorg/iotivity/base/OcDirectPairDevice/GetDirectPairedListener;)V
 910  */
 911 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDirectPairedDevices
 912 (JNIEnv *env, jclass jclazz, jobject jListener)
 913 {
 914     LOGD("OcPlatform_getDirectPairedDevices");
 915
 916     if (!jListener)
 917     {
 918         ThrowOcException(OC_STACK_INVALID_PARAM, "getPairedDevList Callback cannot be null");
 919         return;
 920     }
 921     JniOnDPDevicesFoundListener *onGetPairedDevicesListener = AddOnDPDevicesFoundListener(env,
 922             jListener);
 923
 924     GetDirectPairedCallback getDirectPairedCallback =
 925         [onGetPairedDevicesListener](PairedDevices pairedDevList)
 926         {
 927             onGetPairedDevicesListener->directPairingDevicesCallback(pairedDevList,
 928                     DPFunc::GET_PAIRED_DEV_LIST);
 929         };
 930
 931     try
 932     {
 933         OCStackResult result = OCPlatform::getDirectPairedDevices(getDirectPairedCallback);
 934         if (OC_STACK_OK != result)
 935         {
 936             ThrowOcException(result, "OcDirectPairDevice_getDirectPairedDevices");
 937             return;
 938         }
 939     }
 940     catch (OCException& e)
 941     {
 942         LOGE("%s", e.reason().c_str());
 943         ThrowOcException(e.code(), e.reason().c_str());
 944     }
 945 }
 946
 947 /*
 948  * Class:     org_iotivity_base_OcPlatform
 949  * Method:    doDirectPairing
 950  * Signature: (Lorg/iotivity/base/OcDirectPairDevice;Lorg/iotivity/base/OcPrmType;
 951  *           Ljava/lang/String;Lorg/iotivity/base/OcDirectPairDevice/DirectPairingListener;)V
 952  */
 953 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_doDirectPairing0
 954 (JNIEnv *env, jclass clazz, jobject jpeer, jint jprmType, jstring jpin, jobject jListener)
 955 {
 956     LOGD("OcPlatform_doDirectPairing");
 957
 958     if (!jListener)
 959     {
 960         ThrowOcException(OC_STACK_INVALID_PARAM, "doDirectPairing Callback cannot be null");
 961         return;
 962     }
 963     if (!jpeer)
 964     {
 965         ThrowOcException(OC_STACK_INVALID_PARAM, "Peer cannot be null");
 966         return;
 967     }
 968
 969     JniOnDirectPairingListener *onDirectPairingListener = AddOnDirectPairingListener(env,
 970             jListener);
 971
 972     DirectPairingCallback DirectPairingCB =
 973         [onDirectPairingListener](std::shared_ptr<OCDirectPairing> dpDev, OCStackResult result)
 974         {
 975             onDirectPairingListener->doDirectPairingCB(dpDev, result);
 976         };
 977
 978     JniOcDirectPairDevice *dev = JniOcDirectPairDevice::getJniOcDirectPairDevicePtr(env, jpeer);
 979
 980     if (!dev)
 981     {
 982         return ;
 983     }
 984     std::string pin = env->GetStringUTFChars(jpin, 0);
 985
 986     try
 987     {
 988         OCStackResult result = OCPlatform::doDirectPairing(dev->getPtr(), (OCPrm_t)jprmType,
 989                 pin, DirectPairingCB);
 990         if (OC_STACK_OK != result)
 991         {
 992             ThrowOcException(result, "OcPlatform_oDirectPairing");
 993             return;
 994         }
 995     }
 996     catch (OCException& e)
 997     {
 998         LOGE("%s", e.reason().c_str());
 999         ThrowOcException(e.code(), e.reason().c_str());
1000     }
1001 }
1002
1003 /*
1004 * Class:     org_iotivity_base_OcPlatform
1005 * Method:    getDeviceInfo0
1006 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
1007 */
1008 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0(
1009     JNIEnv *env,
1010     jclass clazz,
1011     jstring jHost,
1012     jstring jResourceUri,
1013     jint jConnectivityType,
1014     jobject jListener)
1015 {
1016     LOGD("OcPlatform_getDeviceInfo0");
1017     std::string host;
1018     if (jHost)
1019     {
1020         host = env->GetStringUTFChars(jHost, nullptr);
1021     }
1022     std::string resourceUri;
1023     if (jResourceUri)
1024     {
1025         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1026     }
1027     if (!jListener)
1028     {
1029         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1030         return;
1031     }
1032     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1033
1034     FindDeviceCallback findDeviceCallback =
1035         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1036         {
1037             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1038         };
1039
1040     try
1041     {
1042         OCStackResult result = OCPlatform::getDeviceInfo(
1043             host,
1044             resourceUri,
1045             static_cast<OCConnectivityType>(jConnectivityType),
1046             findDeviceCallback);
1047
1048         if (OC_STACK_OK != result)
1049         {
1050             ThrowOcException(result, "Find device has failed");
1051         }
1052     }
1053     catch (OCException& e)
1054     {
1055         LOGE("%s", e.reason().c_str());
1056         ThrowOcException(e.code(), e.reason().c_str());
1057     }
1058 }
1059
1060 /*
1061 * Class:     org_iotivity_base_OcPlatform
1062 * Method:    getDeviceInfo1
1063 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
1064 */
1065 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1(
1066     JNIEnv *env,
1067     jclass clazz,
1068     jstring jHost,
1069     jstring jResourceUri,
1070     jint jConnectivityType,
1071     jobject jListener,
1072     jint jQoS)
1073 {
1074     LOGD("OcPlatform_getDeviceInfo1");
1075     std::string host;
1076     if (jHost)
1077     {
1078         host = env->GetStringUTFChars(jHost, nullptr);
1079     }
1080     std::string resourceUri;
1081     if (jResourceUri)
1082     {
1083         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1084     }
1085     if (!jListener)
1086     {
1087         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1088         return;
1089     }
1090     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1091
1092     FindDeviceCallback findDeviceCallback =
1093         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1094         {
1095             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1096         };
1097
1098     try
1099     {
1100         OCStackResult result = OCPlatform::getDeviceInfo(
1101             host,
1102             resourceUri,
1103             static_cast<OCConnectivityType>(jConnectivityType),
1104             findDeviceCallback,
1105             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1106
1107         if (OC_STACK_OK != result)
1108         {
1109             ThrowOcException(result, "Find device has failed");
1110         }
1111     }
1112     catch (OCException& e)
1113     {
1114         LOGE("%s", e.reason().c_str());
1115         ThrowOcException(e.code(), e.reason().c_str());
1116     }
1117 }
1118
1119 /*
1120 * Class:     org_iotivity_base_OcPlatform
1121 * Method:    getPlatformInfo0
1122 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
1123 */
1124 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0(
1125     JNIEnv *env,
1126     jclass clazz,
1127     jstring jHost,
1128     jstring jResourceUri,
1129     jint jConnectivityType,
1130     jobject jListener)
1131 {
1132     LOGD("OcPlatform_getPlatformInfo0");
1133     std::string host;
1134     if (jHost)
1135     {
1136         host = env->GetStringUTFChars(jHost, nullptr);
1137     }
1138     std::string resourceUri;
1139     if (jResourceUri)
1140     {
1141         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1142     }
1143     if (!jListener)
1144     {
1145         ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1146         return;
1147     }
1148     JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
1149
1150     FindPlatformCallback findPlatformCallback =
1151         [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
1152         {
1153             onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
1154         };
1155
1156     try
1157     {
1158         OCStackResult result = OCPlatform::getPlatformInfo(
1159             host,
1160             resourceUri,
1161             static_cast<OCConnectivityType>(jConnectivityType),
1162             findPlatformCallback);
1163
1164         if (OC_STACK_OK != result)
1165         {
1166             ThrowOcException(result, "Find platform has failed");
1167         }
1168     }
1169     catch (OCException& e)
1170     {
1171         LOGE("%s", e.reason().c_str());
1172         ThrowOcException(e.code(), e.reason().c_str());
1173     }
1174 }
1175
1176 /*
1177 * Class:     org_iotivity_base_OcPlatform
1178 * Method:    getPlatformInfo1
1179 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
1180 */
1181 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1(
1182     JNIEnv *env,
1183     jclass clazz,
1184     jstring jHost,
1185     jstring jResourceUri,
1186     jint jConnectivityType,
1187     jobject jListener,
1188     jint jQoS)
1189 {
1190     LOGD("OcPlatform_getPlatformInfo1");
1191     std::string host;
1192     if (jHost)
1193     {
1194         host = env->GetStringUTFChars(jHost, nullptr);
1195     }
1196     std::string resourceUri;
1197     if (jResourceUri)
1198     {
1199         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1200     }
1201     if (!jListener)
1202     {
1203         ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1204         return;
1205     }
1206     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1207
1208     FindDeviceCallback findDeviceCallback =
1209         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1210         {
1211             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1212         };
1213
1214     try
1215     {
1216         OCStackResult result = OCPlatform::getPlatformInfo(
1217             host,
1218             resourceUri,
1219             static_cast<OCConnectivityType>(jConnectivityType),
1220             findDeviceCallback,
1221             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1222
1223         if (OC_STACK_OK != result)
1224         {
1225             ThrowOcException(result, "Find platform has failed");
1226         }
1227     }
1228     catch (OCException& e)
1229     {
1230         LOGE("%s", e.reason().c_str());
1231         ThrowOcException(e.code(), e.reason().c_str());
1232     }
1233 }
1234
1235 /*
1236 * Class:     org_iotivity_base_OcPlatform
1237 * Method:    registerResource0
1238 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
1239 */
1240 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0(
1241     JNIEnv *env, jclass clazz, jobject jResource)
1242 {
1243     LOGD("OcPlatform_registerResource");
1244     if (!jResource)
1245     {
1246         ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
1247         return nullptr;
1248     }
1249     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
1250     if (!resource)
1251     {
1252         return nullptr;
1253     }
1254
1255     OCResourceHandle resourceHandle;
1256     try
1257     {
1258         OCStackResult result = OCPlatform::registerResource(
1259             resourceHandle,
1260             resource->getOCResource());
1261
1262         if (OC_STACK_OK != result)
1263         {
1264             ThrowOcException(result, "register resource");
1265         }
1266     }
1267     catch (OCException& e)
1268     {
1269         LOGE("%s", e.reason().c_str());
1270         ThrowOcException(e.code(), e.reason().c_str());
1271         return nullptr;
1272     }
1273     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1274     jlong handle = reinterpret_cast<jlong>(jniHandle);
1275     jobject jResourceHandle =
1276         env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1277
1278     if (!jResourceHandle)
1279     {
1280         LOGE("Failed to create OcResourceHandle");
1281         delete jniHandle;
1282     }
1283     return jResourceHandle;
1284 }
1285
1286 /*
1287 * Class:     org_iotivity_base_OcPlatform
1288 * Method:    registerResource1
1289 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
1290 */
1291 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1(
1292     JNIEnv *env,
1293     jclass clazz,
1294     jstring jResourceUri,
1295     jstring jResourceTypeName,
1296     jstring jResourceInterface,
1297 jobject jListener, jint jResourceProperty)
1298 {
1299     LOGI("OcPlatform_registerResource1");
1300     std::string resourceUri;
1301     if (jResourceUri)
1302     {
1303         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1304     }
1305     std::string resourceTypeName;
1306     if (jResourceTypeName)
1307     {
1308         resourceTypeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1309     }
1310     std::string resourceInterface;
1311     if (jResourceInterface)
1312     {
1313         resourceInterface = env->GetStringUTFChars(jResourceInterface, nullptr);
1314     }
1315     JniEntityHandler* entityHandler = NULL;
1316     EntityHandler handleEntityCallback = NULL;
1317     if (jListener)
1318     {
1319         entityHandler = new JniEntityHandler(env, jListener);
1320         handleEntityCallback =
1321             [entityHandler](const std::shared_ptr<OCResourceRequest> request) -> OCEntityHandlerResult
1322             {
1323                 return entityHandler->handleEntity(request);
1324             };
1325     }
1326
1327     OCResourceHandle resourceHandle;
1328     try
1329     {
1330         OCStackResult result = OCPlatform::registerResource(
1331             resourceHandle,
1332             resourceUri,
1333             resourceTypeName,
1334             resourceInterface,
1335             handleEntityCallback,
1336             static_cast<int>(jResourceProperty));
1337
1338         if (OC_STACK_OK != result)
1339         {
1340             delete entityHandler;
1341             ThrowOcException(result, "register resource");
1342             return nullptr;
1343         }
1344     }
1345     catch (OCException& e)
1346     {
1347         LOGE("%s", e.reason().c_str());
1348         delete entityHandler;
1349         ThrowOcException(e.code(), e.reason().c_str());
1350         return nullptr;
1351     }
1352
1353     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1354     jlong handle = reinterpret_cast<jlong>(jniHandle);
1355     jobject jResourceHandle =
1356         env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1357     if (!jResourceHandle)
1358     {
1359         LOGE("Failed to create OcResourceHandle");
1360         delete jniHandle;
1361     }
1362
1363     return jResourceHandle;
1364 }
1365
1366 /*
1367 * Class:     org_iotivity_base_OcPlatform
1368 * Method:    registerDeviceInfo0
1369 * 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
1370 */
1371 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0(
1372     JNIEnv *env,
1373     jclass clazz,
1374     jstring jDeviceName,
1375     jobjectArray jDeviceTypes)
1376 {
1377     LOGI("OcPlatform_registerDeviceInfo");
1378
1379     if (!jDeviceName)
1380     {
1381         ThrowOcException(OC_STACK_INVALID_PARAM, "deviceName cannot be null");
1382         return;
1383     }
1384
1385     if (!jDeviceTypes)
1386     {
1387         ThrowOcException(OC_STACK_INVALID_PARAM, "deviceTypes cannot be null");
1388         return;
1389     }
1390
1391     OCDeviceInfo deviceInfo;
1392     try
1393     {
1394         DuplicateString(&deviceInfo.deviceName, env->GetStringUTFChars(jDeviceName, nullptr));
1395         deviceInfo.types = NULL;
1396
1397         jsize len = env->GetArrayLength(jDeviceTypes);
1398         for (jsize i = 0; i < len; ++i)
1399         {
1400             jstring jStr = (jstring)env->GetObjectArrayElement(jDeviceTypes, i);
1401             if (!jStr)
1402             {
1403                 delete deviceInfo.deviceName;
1404                 ThrowOcException(OC_STACK_INVALID_PARAM, "device type cannot be null");
1405                 return;
1406             }
1407
1408             OCResourcePayloadAddStringLL(&deviceInfo.types, env->GetStringUTFChars(jStr, nullptr));
1409             if (env->ExceptionCheck())
1410             {
1411                 delete deviceInfo.deviceName;
1412                 return;
1413             }
1414
1415             env->DeleteLocalRef(jStr);
1416         }
1417     }
1418     catch (std::exception &e)
1419     {
1420         ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1421         return;
1422     }
1423
1424     try
1425     {
1426         OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1427
1428         delete deviceInfo.deviceName;
1429
1430         if (OC_STACK_OK != result)
1431         {
1432             ThrowOcException(result, "Failed to register device info");
1433             return;
1434         }
1435     }
1436     catch (OCException& e)
1437     {
1438         LOGE("%s", e.reason().c_str());
1439         ThrowOcException(e.code(), e.reason().c_str());
1440     }
1441 }
1442
1443 /*
1444 * Class:     org_iotivity_base_OcPlatform
1445 * Method:    registerPlatformInfo0
1446 * 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
1447 */
1448 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0(
1449     JNIEnv *env,
1450     jclass clazz,
1451     jstring jPlatformID,
1452     jstring jManufacturerName,
1453     jstring jManufacturerUrl,
1454     jstring jModelNumber,
1455     jstring jDateOfManufacture,
1456     jstring jPlatformVersion,
1457     jstring jOperatingSystemVersion,
1458     jstring jHardwareVersion,
1459     jstring jFirmwareVersion,
1460     jstring jSupportUrl,
1461     jstring jSystemTime)
1462 {
1463     LOGI("OcPlatform_registerPlatformInfo");
1464
1465
1466     std::string platformID;
1467         std::string manufacturerName;
1468         std::string manufacturerUrl;
1469         std::string modelNumber;
1470         std::string dateOfManufacture;
1471         std::string platformVersion;
1472         std::string operatingSystemVersion;
1473         std::string hardwareVersion;
1474         std::string firmwareVersion;
1475         std::string supportUrl;
1476         std::string systemTime;
1477
1478         if (jPlatformID)
1479         {
1480             platformID = env->GetStringUTFChars(jPlatformID, nullptr);
1481         }
1482         if (jManufacturerName)
1483         {
1484             manufacturerName = env->GetStringUTFChars(jManufacturerName, nullptr);
1485         }
1486         if (jManufacturerUrl)
1487         {
1488             manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, nullptr);
1489         }
1490         if (jModelNumber)
1491         {
1492             modelNumber = env->GetStringUTFChars(jModelNumber, nullptr);
1493         }
1494         if (jDateOfManufacture)
1495         {
1496             dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, nullptr);
1497         }
1498         if (jPlatformVersion)
1499         {
1500             platformVersion = env->GetStringUTFChars(jPlatformVersion, nullptr);
1501         }
1502         if (jOperatingSystemVersion)
1503         {
1504             operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, nullptr);
1505         }
1506         if (jHardwareVersion)
1507         {
1508             hardwareVersion = env->GetStringUTFChars(jHardwareVersion, nullptr);
1509         }
1510         if (jFirmwareVersion)
1511         {
1512             firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, nullptr);
1513         }
1514         if (jSupportUrl)
1515         {
1516             supportUrl = env->GetStringUTFChars(jSupportUrl, nullptr);
1517         }
1518         if (jSystemTime)
1519         {
1520             systemTime = env->GetStringUTFChars(jSystemTime, nullptr);
1521         }
1522
1523         OCPlatformInfo platformInfo;
1524         try
1525         {
1526             DuplicateString(&platformInfo.platformID, platformID);
1527             DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1528             DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1529             DuplicateString(&platformInfo.modelNumber, modelNumber);
1530             DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1531             DuplicateString(&platformInfo.platformVersion, platformVersion);
1532             DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1533             DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1534             DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1535             DuplicateString(&platformInfo.supportUrl, supportUrl);
1536             DuplicateString(&platformInfo.systemTime, systemTime);
1537         }
1538         catch (std::exception &e)
1539         {
1540             ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1541             return;
1542         }
1543
1544        // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID  = %s", platformID);
1545         try
1546         {
1547             OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1548
1549             delete platformInfo.platformID;
1550             delete platformInfo.manufacturerName;
1551             delete platformInfo.manufacturerUrl;
1552             delete platformInfo.modelNumber;
1553             delete platformInfo.dateOfManufacture;
1554             delete platformInfo.platformVersion;
1555             delete platformInfo.operatingSystemVersion;
1556             delete platformInfo.hardwareVersion;
1557             delete platformInfo.firmwareVersion;
1558             delete platformInfo.supportUrl;
1559             delete platformInfo.systemTime;
1560
1561             if (OC_STACK_OK != result)
1562             {
1563                 ThrowOcException(result, "Failed to register platform info");
1564                 return;
1565             }
1566         }
1567         catch (OCException& e)
1568         {
1569             LOGE("Error is due to %s", e.reason().c_str());
1570             ThrowOcException(e.code(), e.reason().c_str());
1571         }
1572 }
1573
1574 /*
1575 * Class:     org_iotivity_base_OcPlatform
1576 * Method:    unregisterResource0
1577 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1578 */
1579 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1580     JNIEnv *env, jclass clazz, jobject jResourceHandle)
1581 {
1582     LOGI("OcPlatform_unregisterResource");
1583     if (!jResourceHandle)
1584     {
1585         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1586         return;
1587     }
1588     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1589         env, jResourceHandle);
1590     if (!jniOcResourceHandle)
1591     {
1592         return;
1593     }
1594
1595     try
1596     {
1597         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1598         OCStackResult result = OCPlatform::unregisterResource(resHandle);
1599         if (OC_STACK_OK != result)
1600         {
1601             ThrowOcException(result, "Failed to unregister resource");
1602         }
1603     }
1604     catch (OCException& e)
1605     {
1606         LOGE("%s", e.reason().c_str());
1607         ThrowOcException(e.code(), e.reason().c_str());
1608     }
1609 }
1610
1611 /*
1612 * Class:     org_iotivity_base_OcPlatform
1613 * Method:    bindResource0
1614 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1615 */
1616 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1617 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1618 {
1619     LOGI("OcPlatform_bindResource");
1620     if (!jResourceCollectionHandle)
1621     {
1622         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1623         return;
1624     }
1625     if (!jResourceHandle)
1626     {
1627         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1628         return;
1629     }
1630     JniOcResourceHandle* jniOcResourceCollectionHandle =
1631         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1632     if (!jniOcResourceCollectionHandle)
1633     {
1634         return;
1635     }
1636
1637     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1638         env, jResourceHandle);
1639     if (!jniOcResourceHandle)
1640     {
1641         return;
1642     }
1643
1644     try
1645     {
1646         OCStackResult result = OCPlatform::bindResource(
1647             jniOcResourceCollectionHandle->getOCResourceHandle(),
1648             jniOcResourceHandle->getOCResourceHandle()
1649             );
1650
1651         if (OC_STACK_OK != result)
1652         {
1653             ThrowOcException(result, "Failed to bind resource");
1654         }
1655     }
1656     catch (OCException& e)
1657     {
1658         LOGE("%s", e.reason().c_str());
1659         ThrowOcException(e.code(), e.reason().c_str());
1660     }
1661 }
1662
1663 /*
1664 * Class:     org_iotivity_base_OcPlatform
1665 * Method:    bindResources0
1666 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1667 */
1668 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1669     JNIEnv *env,
1670     jclass clazz,
1671     jobject jResourceCollectionHandle,
1672     jobjectArray jResourceHandleArray)
1673 {
1674     LOGI("OcPlatform_bindResources");
1675
1676     if (!jResourceCollectionHandle)
1677     {
1678         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1679         return;
1680     }
1681     if (!jResourceHandleArray)
1682     {
1683         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1684         return;
1685     }
1686
1687     JniOcResourceHandle* jniOcResourceCollectionHandle =
1688         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1689     if (!jniOcResourceCollectionHandle)
1690     {
1691         return;
1692     }
1693
1694     std::vector<OCResourceHandle> resourceHandleList;
1695     int len = env->GetArrayLength(jResourceHandleArray);
1696     for (int i = 0; i < len; ++i)
1697     {
1698         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1699         if (!jResourceHandle)
1700         {
1701             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1702             return;
1703         }
1704
1705         JniOcResourceHandle* jniOcResourceHandle =
1706             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1707         if (!jniOcResourceHandle)
1708         {
1709             return;
1710         }
1711
1712         resourceHandleList.push_back(
1713             jniOcResourceHandle->getOCResourceHandle());
1714     }
1715
1716     try
1717     {
1718         OCStackResult result = OCPlatform::bindResources(
1719             jniOcResourceCollectionHandle->getOCResourceHandle(),
1720             resourceHandleList
1721             );
1722
1723         if (OC_STACK_OK != result)
1724         {
1725             ThrowOcException(result, "Failed to bind resources");
1726         }
1727     }
1728     catch (OCException& e)
1729     {
1730         LOGE("%s", e.reason().c_str());
1731         ThrowOcException(e.code(), e.reason().c_str());
1732     }
1733 }
1734
1735 /*
1736 * Class:     org_iotivity_base_OcPlatform
1737 * Method:    unbindResource0
1738 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1739 */
1740 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1741     JNIEnv *env,
1742     jclass clazz,
1743     jobject jResourceCollectionHandle,
1744     jobject jResourceHandle)
1745 {
1746     LOGI("OcPlatform_unbindResource");
1747     if (!jResourceCollectionHandle)
1748     {
1749         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1750         return;
1751     }
1752     if (!jResourceHandle)
1753     {
1754         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1755         return;
1756     }
1757
1758     JniOcResourceHandle* jniOcResourceCollectionHandle =
1759         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1760     if (!jniOcResourceCollectionHandle)
1761     {
1762         return;
1763     }
1764
1765     JniOcResourceHandle* jniOcResourceHandle =
1766         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1767     if (!jniOcResourceHandle)
1768     {
1769         return;
1770     }
1771
1772     try
1773     {
1774         OCStackResult result = OCPlatform::unbindResource(
1775             jniOcResourceCollectionHandle->getOCResourceHandle(),
1776             jniOcResourceHandle->getOCResourceHandle());
1777
1778         if (OC_STACK_OK != result)
1779         {
1780             ThrowOcException(result, "Failed to unbind resource");
1781         }
1782     }
1783     catch (OCException& e)
1784     {
1785         LOGE("%s", e.reason().c_str());
1786         ThrowOcException(e.code(), e.reason().c_str());
1787     }
1788 }
1789
1790 /*
1791 * Class:     org_iotivity_base_OcPlatform
1792 * Method:    unbindResources0
1793 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1794 */
1795 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
1796     JNIEnv *env,
1797     jclass clazz,
1798     jobject jResourceCollectionHandle,
1799     jobjectArray jResourceHandleArray)
1800 {
1801     LOGI("OcPlatform_unbindResources");
1802     if (!jResourceCollectionHandle)
1803     {
1804         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1805         return;
1806     }
1807     if (!jResourceHandleArray)
1808     {
1809         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1810         return;
1811     }
1812
1813     JniOcResourceHandle* jniOcResourceCollectionHandle =
1814         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1815     if (!jniOcResourceCollectionHandle)
1816     {
1817         return;
1818     }
1819
1820     std::vector<OCResourceHandle> resourceHandleList;
1821     int len = env->GetArrayLength(jResourceHandleArray);
1822     for (int i = 0; i < len; ++i)
1823     {
1824         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1825         if (!jResourceHandle)
1826         {
1827             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1828             return;
1829         }
1830
1831         JniOcResourceHandle* jniOcResourceHandle =
1832             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1833         if (!jniOcResourceHandle)
1834         {
1835             return;
1836         }
1837
1838         resourceHandleList.push_back(
1839             jniOcResourceHandle->getOCResourceHandle());
1840     }
1841
1842     try
1843     {
1844         OCStackResult result = OCPlatform::unbindResources(
1845             jniOcResourceCollectionHandle->getOCResourceHandle(),
1846             resourceHandleList
1847             );
1848
1849         if (OC_STACK_OK != result)
1850         {
1851             ThrowOcException(result, "Failed to unbind resources");
1852         }
1853     }
1854     catch (OCException& e)
1855     {
1856         LOGE("%s", e.reason().c_str());
1857         ThrowOcException(e.code(), e.reason().c_str());
1858     }
1859 }
1860
1861 /*
1862 * Class:     org_iotivity_base_OcPlatform
1863 * Method:    bindTypeToResource0
1864 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1865 */
1866 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
1867     JNIEnv *env,
1868     jclass clazz,
1869     jobject jResourceHandle,
1870     jstring jResourceTypeName)
1871 {
1872     LOGI("OcPlatform_bindTypeToResource");
1873     if (!jResourceHandle)
1874     {
1875         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1876         return;
1877     }
1878     std::string typeName;
1879     if (jResourceTypeName)
1880     {
1881         typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1882     }
1883
1884     JniOcResourceHandle* jniOcResourceHandle =
1885         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1886     if (!jniOcResourceHandle)
1887     {
1888         return;
1889     }
1890
1891     try
1892     {
1893         OCStackResult result = OCPlatform::bindTypeToResource(
1894             jniOcResourceHandle->getOCResourceHandle(),
1895             typeName
1896             );
1897
1898         if (OC_STACK_OK != result)
1899         {
1900             ThrowOcException(result, "Failed to bind type to resource");
1901         }
1902     }
1903     catch (OCException& e)
1904     {
1905         LOGE("%s", e.reason().c_str());
1906         ThrowOcException(e.code(), e.reason().c_str());
1907     }
1908 }
1909
1910 /*
1911 * Class:     org_iotivity_base_OcPlatform
1912 * Method:    bindInterfaceToResource0
1913 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1914 */
1915 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
1916 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
1917 {
1918     LOGI("OcPlatform_bindInterfaceToResource");
1919     if (!jResourceHandle)
1920     {
1921         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1922         return;
1923     }
1924     std::string interfaceName;
1925     if (jResourceInterfaceName)
1926     {
1927         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
1928     }
1929
1930     JniOcResourceHandle* jniOcResourceHandle =
1931         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1932     if (!jniOcResourceHandle)
1933     {
1934         return;
1935     }
1936
1937     try
1938     {
1939         OCStackResult result = OCPlatform::bindInterfaceToResource(
1940             jniOcResourceHandle->getOCResourceHandle(),
1941             interfaceName
1942             );
1943
1944         if (OC_STACK_OK != result)
1945         {
1946             ThrowOcException(result, "Failed to bind interface to resource");
1947         }
1948     }
1949     catch (OCException& e)
1950     {
1951         LOGE("%s", e.reason().c_str());
1952         ThrowOcException(e.code(), e.reason().c_str());
1953     }
1954 }
1955
1956 /*
1957 * Class:     org_iotivity_base_OcPlatform
1958 * Method:    startPresence0
1959 * Signature: (I)V
1960 */
1961 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
1962     JNIEnv *env, jclass clazz, jint ttl)
1963 {
1964     LOGI("OcPlatform_startPresence");
1965
1966     try
1967     {
1968         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
1969
1970         if (OC_STACK_OK != result)
1971         {
1972             ThrowOcException(result, "Failed to start presence");
1973         }
1974     }
1975     catch (OCException& e)
1976     {
1977         LOGE("%s", e.reason().c_str());
1978         ThrowOcException(e.code(), e.reason().c_str());
1979     }
1980 }
1981
1982 /*
1983 * Class:     org_iotivity_base_OcPlatform
1984 * Method:    stopPresence0
1985 * Signature: ()V
1986 */
1987 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
1988     JNIEnv *env, jclass clazz)
1989 {
1990     LOGI("OcPlatform_stopPresence");
1991
1992     try
1993     {
1994         OCStackResult result = OCPlatform::stopPresence();
1995
1996         if (OC_STACK_OK != result)
1997         {
1998             ThrowOcException(result, "Failed to stop presence");
1999         }
2000     }
2001     catch (OCException& e)
2002     {
2003         LOGE("%s", e.reason().c_str());
2004         ThrowOcException(e.code(), e.reason().c_str());
2005     }
2006 }
2007
2008 /*
2009 * Class:     org_iotivity_base_OcPlatform
2010 * Method:    subscribePresence0
2011 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2012 */
2013 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
2014     JNIEnv *env,
2015     jclass clazz,
2016     jstring jHost,
2017     jint jConnectivityType,
2018     jobject jListener)
2019 {
2020     LOGD("OcPlatform_subscribePresence");
2021     std::string host;
2022     if (jHost)
2023     {
2024         host = env->GetStringUTFChars(jHost, nullptr);
2025     }
2026     if (!jListener)
2027     {
2028         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2029         return nullptr;
2030     }
2031
2032     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2033
2034     SubscribeCallback subscribeCallback =
2035         [onPresenceListener](OCStackResult result,
2036                              const unsigned int nonce,
2037                              const std::string& hostAddress)
2038         {
2039             onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2040         };
2041
2042     OCPlatform::OCPresenceHandle presenceHandle;
2043     try
2044     {
2045         OCStackResult result = OCPlatform::subscribePresence(
2046             presenceHandle,
2047             host,
2048             static_cast<OCConnectivityType>(jConnectivityType),
2049             subscribeCallback);
2050
2051         if (OC_STACK_OK != result)
2052         {
2053             ThrowOcException(result, "subscribe presence has failed");
2054         }
2055     }
2056     catch (OCException& e)
2057     {
2058         LOGE("%s", e.reason().c_str());
2059         ThrowOcException(e.code(), e.reason().c_str());
2060         return nullptr;
2061     }
2062
2063     JniOcPresenceHandle* jniPresenceHandle =
2064         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2065     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2066     jobject jPresenceHandle =
2067         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2068     if (!jPresenceHandle)
2069     {
2070         LOGE("Failed to create OcPresenceHandle");
2071         delete jniPresenceHandle;
2072     }
2073     return jPresenceHandle;
2074 }
2075
2076 /*
2077 * Class:     org_iotivity_base_OcPlatform
2078 * Method:    subscribePresence1
2079 * Signature: (Ljava/lang/String;Ljava/lang/String;I
2080 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2081 */
2082 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
2083     JNIEnv *env,
2084     jclass clazz,
2085     jstring jHost,
2086     jstring jResourceType,
2087     jint jConnectivityType,
2088     jobject jListener)
2089 {
2090     LOGD("OcPlatform_subscribePresence1");
2091     std::string host;
2092     if (jHost)
2093     {
2094         host = env->GetStringUTFChars(jHost, nullptr);
2095     }
2096     std::string resourceType;
2097     if (jResourceType)
2098     {
2099         resourceType = env->GetStringUTFChars(jResourceType, nullptr);
2100     }
2101     if (!jListener)
2102     {
2103         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2104         return nullptr;
2105     }
2106
2107     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2108
2109     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
2110         const unsigned int nonce, const std::string& hostAddress)
2111     {
2112         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2113     };
2114
2115     OCPlatform::OCPresenceHandle presenceHandle;
2116     try
2117     {
2118         OCStackResult result = OCPlatform::subscribePresence(
2119             presenceHandle,
2120             host,
2121             resourceType,
2122             static_cast<OCConnectivityType>(jConnectivityType),
2123             subscribeCallback);
2124
2125         if (OC_STACK_OK != result)
2126         {
2127             ThrowOcException(result, "subscribe presence has failed");
2128         }
2129     }
2130     catch (OCException& e)
2131     {
2132         LOGE("%s", e.reason().c_str());
2133         ThrowOcException(e.code(), e.reason().c_str());
2134         return nullptr;
2135     }
2136
2137     JniOcPresenceHandle* jniPresenceHandle =
2138         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2139     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2140     jobject jPresenceHandle =
2141         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2142     if (!jPresenceHandle)
2143     {
2144         LOGE("Failed to create OcPresenceHandle");
2145         delete jniPresenceHandle;
2146     }
2147     return jPresenceHandle;
2148 }
2149
2150 /*
2151 * Class:     org_iotivity_base_OcPlatform
2152 * Method:    unsubscribePresence0
2153 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
2154 */
2155 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
2156     JNIEnv *env, jclass clazz, jobject jPresenceHandle)
2157 {
2158     LOGD("OcPlatform_unsubscribePresence");
2159     if (!jPresenceHandle)
2160     {
2161         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
2162         return;
2163     }
2164     JniOcPresenceHandle* jniPresenceHandle =
2165         JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
2166     if (!jniPresenceHandle)
2167     {
2168         return;
2169     }
2170
2171     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
2172
2173     try
2174     {
2175         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
2176
2177         if (OC_STACK_OK != result)
2178         {
2179             ThrowOcException(result, "unsubscribe presence has failed");
2180             return;
2181         }
2182         jweak jwOnPresenceListener =
2183             jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
2184         if (jwOnPresenceListener)
2185         {
2186             RemoveOnPresenceListener(env, jwOnPresenceListener);
2187         }
2188     }
2189     catch (OCException& e)
2190     {
2191         LOGE("%s", e.reason().c_str());
2192         ThrowOcException(e.code(), e.reason().c_str());
2193     }
2194 }
2195
2196 /*
2197 * Class:     org_iotivity_base_OcPlatform
2198 * Method:    constructResourceObject0
2199 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
2200 Lorg/iotivity/base/OcResource;
2201 */
2202 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
2203     JNIEnv *env,
2204     jclass clazz,
2205     jstring jHost,
2206     jstring jUri,
2207     jint jConnectivityType,
2208     jboolean jIsObservable,
2209     jobjectArray jResourceTypeArray,
2210     jobjectArray jInterfaceArray)
2211 {
2212     LOGD("OcPlatform_constructResourceObject");
2213     std::string host;
2214     if (jHost)
2215     {
2216         host = env->GetStringUTFChars(jHost, nullptr);
2217     }
2218     std::string uri;
2219     if (jUri)
2220     {
2221         uri = env->GetStringUTFChars(jUri, nullptr);
2222     }
2223     if (!jResourceTypeArray)
2224     {
2225         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
2226         return nullptr;
2227     }
2228     if (!jInterfaceArray)
2229     {
2230         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
2231         return nullptr;
2232     }
2233
2234     std::vector<std::string> resourceTypes;
2235     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
2236
2237     std::vector<std::string> interfaces;
2238     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
2239
2240     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
2241         host,
2242         uri,
2243         static_cast<OCConnectivityType>(jConnectivityType),
2244         static_cast<bool>(jIsObservable),
2245         resourceTypes,
2246         interfaces);
2247
2248     if (!resource)
2249     {
2250         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
2251         return nullptr;
2252     }
2253
2254     JniOcResource *jniOcResource = new JniOcResource(resource);
2255     jlong handle = reinterpret_cast<jlong>(jniOcResource);
2256
2257     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
2258     if (!jResource)
2259     {
2260         delete jniOcResource;
2261         return nullptr;
2262     }
2263     SetHandle<JniOcResource>(env, jResource, jniOcResource);
2264     if (env->ExceptionCheck())
2265     {
2266         delete jniOcResource;
2267         return nullptr;
2268     }
2269     return jResource;
2270 }
2271
2272 /*
2273 * Class:     org_iotivity_base_OcPlatform
2274 * Method:    sendResponse0
2275 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
2276 */
2277 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
2278     JNIEnv *env, jclass clazz, jobject jResourceResponse)
2279 {
2280     LOGD("OcPlatform_sendResponse");
2281     if (!jResourceResponse)
2282     {
2283         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
2284         return;
2285     }
2286
2287     JniOcResourceResponse *jniResponse =
2288         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
2289     if (!jniResponse)
2290     {
2291         return;
2292     }
2293
2294     try
2295     {
2296         OCStackResult result =
2297             OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
2298
2299         if (OC_STACK_OK != result)
2300         {
2301             ThrowOcException(result, "failed to send response");
2302         }
2303     }
2304     catch (OCException& e)
2305     {
2306         LOGE("%s", e.reason().c_str());
2307         ThrowOcException(e.code(), e.reason().c_str());
2308     }
2309 }