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