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