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