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
  30 using namespace OC;
  31
  32 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
  33 {
  34     JniOnResourceFoundListener *onResourceFoundListener = NULL;
  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 = NULL;
 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 = NULL;
 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 = NULL;
 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, NULL);
 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     PlatformConfig cfg{
 351         JniUtils::getServiceType(env, jServiceType),
 352         JniUtils::getModeType(env, jModeType),
 353         ipAddress,
 354         port,
 355         JniUtils::getQOS(env, static_cast<int>(jQOS)),
 356         JniOcSecurity::getOCPersistentStorage()
 357     };
 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(OC_STACK_ERROR, 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(OC_STACK_ERROR, 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(OC_STACK_ERROR, 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(OC_STACK_ERROR, 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, NULL);
 606     }
 607     std::string resourceUri;
 608     if (jResourceUri)
 609     {
 610         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
 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(OC_STACK_ERROR, 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, NULL);
 665     }
 666     std::string resourceUri;
 667     if (jResourceUri)
 668     {
 669         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
 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(OC_STACK_ERROR, 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, NULL);
 723     }
 724     std::string resourceUri;
 725     if (jResourceUri)
 726     {
 727         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
 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(OC_STACK_ERROR, 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, NULL);
 781     }
 782     std::string resourceUri;
 783     if (jResourceUri)
 784     {
 785         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
 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(OC_STACK_ERROR, 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, NULL);
 839     }
 840     std::string resourceUri;
 841     if (jResourceUri)
 842     {
 843         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
 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(OC_STACK_ERROR, 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, NULL);
 897     }
 898     std::string resourceUri;
 899     if (jResourceUri)
 900     {
 901         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
 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(OC_STACK_ERROR, 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(OC_STACK_ERROR, 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, NULL);
1003     }
1004     std::string resourceTypeName;
1005     if (jResourceTypeName)
1006     {
1007         resourceTypeName = env->GetStringUTFChars(jResourceTypeName, NULL);
1008     }
1009     std::string resourceInterface;
1010     if (jResourceInterface)
1011     {
1012         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
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(OC_STACK_ERROR, 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, NULL);
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(OC_STACK_ERROR, 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, NULL);
1151         }
1152         if (jManufacturerName)
1153         {
1154             manufacturerName = env->GetStringUTFChars(jManufacturerName, NULL);
1155         }
1156         if (jManufacturerUrl)
1157         {
1158             manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, NULL);
1159         }
1160         if (jModelNumber)
1161         {
1162             modelNumber = env->GetStringUTFChars(jModelNumber, NULL);
1163         }
1164         if (jDateOfManufacture)
1165         {
1166             dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, NULL);
1167         }
1168         if (jPlatformVersion)
1169         {
1170             platformVersion = env->GetStringUTFChars(jPlatformVersion, NULL);
1171         }
1172         if (jOperatingSystemVersion)
1173         {
1174             operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, NULL);
1175         }
1176         if (jHardwareVersion)
1177         {
1178             hardwareVersion = env->GetStringUTFChars(jHardwareVersion, NULL);
1179         }
1180         if (jFirmwareVersion)
1181         {
1182             firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, NULL);
1183         }
1184         if (jSupportUrl)
1185         {
1186             supportUrl = env->GetStringUTFChars(jSupportUrl, NULL);
1187         }
1188         if (jSystemTime)
1189         {
1190             systemTime = env->GetStringUTFChars(jSystemTime, NULL);
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        // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID  = %s", platformID);
1215         try
1216         {
1217             OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1218
1219             delete platformInfo.platformID;
1220             delete platformInfo.manufacturerName;
1221             delete platformInfo.manufacturerUrl;
1222             delete platformInfo.modelNumber;
1223             delete platformInfo.dateOfManufacture;
1224             delete platformInfo.platformVersion;
1225             delete platformInfo.operatingSystemVersion;
1226             delete platformInfo.hardwareVersion;
1227             delete platformInfo.firmwareVersion;
1228             delete platformInfo.supportUrl;
1229             delete platformInfo.systemTime;
1230
1231             if (OC_STACK_OK != result)
1232             {
1233                 ThrowOcException(result, "Failed to register platform info");
1234                 return;
1235             }
1236         }
1237         catch (OCException& e)
1238         {
1239             LOGE("Error is due to %s", e.reason().c_str());
1240             ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1241         }
1242 }
1243
1244 /*
1245 * Class:     org_iotivity_base_OcPlatform
1246 * Method:    unregisterResource0
1247 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1248 */
1249 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1250     JNIEnv *env, jclass clazz, jobject jResourceHandle)
1251 {
1252     LOGI("OcPlatform_unregisterResource");
1253     if (!jResourceHandle)
1254     {
1255         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1256         return;
1257     }
1258     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1259         env, jResourceHandle);
1260     if (!jniOcResourceHandle)
1261     {
1262         return;
1263     }
1264
1265     try
1266     {
1267         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1268         OCStackResult result = OCPlatform::unregisterResource(resHandle);
1269         if (OC_STACK_OK != result)
1270         {
1271             ThrowOcException(result, "Failed to unregister resource");
1272         }
1273     }
1274     catch (OCException& e)
1275     {
1276         LOGE("%s", e.reason().c_str());
1277         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1278     }
1279 }
1280
1281 /*
1282 * Class:     org_iotivity_base_OcPlatform
1283 * Method:    bindResource0
1284 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1285 */
1286 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1287 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1288 {
1289     LOGI("OcPlatform_bindResource");
1290     if (!jResourceCollectionHandle)
1291     {
1292         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1293         return;
1294     }
1295     if (!jResourceHandle)
1296     {
1297         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1298         return;
1299     }
1300     JniOcResourceHandle* jniOcResourceCollectionHandle =
1301         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1302     if (!jniOcResourceCollectionHandle) return;
1303
1304     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1305         env, jResourceHandle);
1306     if (!jniOcResourceHandle)
1307     {
1308         return;
1309     }
1310
1311     try
1312     {
1313         OCStackResult result = OCPlatform::bindResource(
1314             jniOcResourceCollectionHandle->getOCResourceHandle(),
1315             jniOcResourceHandle->getOCResourceHandle()
1316             );
1317
1318         if (OC_STACK_OK != result)
1319         {
1320             ThrowOcException(result, "Failed to bind resource");
1321         }
1322     }
1323     catch (OCException& e)
1324     {
1325         LOGE("%s", e.reason().c_str());
1326         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1327     }
1328 }
1329
1330 /*
1331 * Class:     org_iotivity_base_OcPlatform
1332 * Method:    bindResources0
1333 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1334 */
1335 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1336     JNIEnv *env,
1337     jclass clazz,
1338     jobject jResourceCollectionHandle,
1339     jobjectArray jResourceHandleArray)
1340 {
1341     LOGI("OcPlatform_bindResources");
1342
1343     if (!jResourceCollectionHandle)
1344     {
1345         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1346         return;
1347     }
1348     if (!jResourceHandleArray)
1349     {
1350         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1351         return;
1352     }
1353
1354     JniOcResourceHandle* jniOcResourceCollectionHandle =
1355         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1356     if (!jniOcResourceCollectionHandle)
1357     {
1358         return;
1359     }
1360
1361     std::vector<OCResourceHandle> resourceHandleList;
1362     int len = env->GetArrayLength(jResourceHandleArray);
1363     for (int i = 0; i < len; ++i)
1364     {
1365         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1366         if (!jResourceHandle)
1367         {
1368             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1369             return;
1370         }
1371
1372         JniOcResourceHandle* jniOcResourceHandle =
1373             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1374         if (!jniOcResourceHandle)
1375         {
1376             return;
1377         }
1378
1379         resourceHandleList.push_back(
1380             jniOcResourceHandle->getOCResourceHandle());
1381     }
1382
1383     try
1384     {
1385         OCStackResult result = OCPlatform::bindResources(
1386             jniOcResourceCollectionHandle->getOCResourceHandle(),
1387             resourceHandleList
1388             );
1389
1390         if (OC_STACK_OK != result)
1391         {
1392             ThrowOcException(result, "Failed to bind resources");
1393         }
1394     }
1395     catch (OCException& e)
1396     {
1397         LOGE("%s", e.reason().c_str());
1398         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1399     }
1400 }
1401
1402 /*
1403 * Class:     org_iotivity_base_OcPlatform
1404 * Method:    unbindResource0
1405 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1406 */
1407 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1408     JNIEnv *env,
1409     jclass clazz,
1410     jobject jResourceCollectionHandle,
1411     jobject jResourceHandle)
1412 {
1413     LOGI("OcPlatform_unbindResource");
1414     if (!jResourceCollectionHandle)
1415     {
1416         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1417         return;
1418     }
1419     if (!jResourceHandle)
1420     {
1421         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1422         return;
1423     }
1424
1425     JniOcResourceHandle* jniOcResourceCollectionHandle =
1426         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1427     if (!jniOcResourceCollectionHandle)
1428     {
1429         return;
1430     }
1431
1432     JniOcResourceHandle* jniOcResourceHandle =
1433         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1434     if (!jniOcResourceHandle)
1435     {
1436         return;
1437     }
1438
1439     try
1440     {
1441         OCStackResult result = OCPlatform::unbindResource(
1442             jniOcResourceCollectionHandle->getOCResourceHandle(),
1443             jniOcResourceHandle->getOCResourceHandle());
1444
1445         if (OC_STACK_OK != result)
1446         {
1447             ThrowOcException(result, "Failed to unbind resource");
1448         }
1449     }
1450     catch (OCException& e)
1451     {
1452         LOGE("%s", e.reason().c_str());
1453         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1454     }
1455 }
1456
1457 /*
1458 * Class:     org_iotivity_base_OcPlatform
1459 * Method:    unbindResources0
1460 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1461 */
1462 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
1463     JNIEnv *env,
1464     jclass clazz,
1465     jobject jResourceCollectionHandle,
1466     jobjectArray jResourceHandleArray)
1467 {
1468     LOGI("OcPlatform_unbindResources");
1469     if (!jResourceCollectionHandle)
1470     {
1471         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1472         return;
1473     }
1474     if (!jResourceHandleArray)
1475     {
1476         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1477         return;
1478     }
1479
1480     JniOcResourceHandle* jniOcResourceCollectionHandle =
1481         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1482     if (!jniOcResourceCollectionHandle)
1483     {
1484         return;
1485     }
1486
1487     std::vector<OCResourceHandle> resourceHandleList;
1488     int len = env->GetArrayLength(jResourceHandleArray);
1489     for (int i = 0; i < len; ++i)
1490     {
1491         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1492         if (!jResourceHandle)
1493         {
1494             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1495             return;
1496         }
1497
1498         JniOcResourceHandle* jniOcResourceHandle =
1499             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1500         if (!jniOcResourceHandle)
1501         {
1502             return;
1503         }
1504
1505         resourceHandleList.push_back(
1506             jniOcResourceHandle->getOCResourceHandle());
1507     }
1508
1509     try
1510     {
1511         OCStackResult result = OCPlatform::unbindResources(
1512             jniOcResourceCollectionHandle->getOCResourceHandle(),
1513             resourceHandleList
1514             );
1515
1516         if (OC_STACK_OK != result)
1517         {
1518             ThrowOcException(result, "Failed to unbind resources");
1519         }
1520     }
1521     catch (OCException& e)
1522     {
1523         LOGE("%s", e.reason().c_str());
1524         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1525     }
1526 }
1527
1528 /*
1529 * Class:     org_iotivity_base_OcPlatform
1530 * Method:    bindTypeToResource0
1531 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1532 */
1533 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
1534     JNIEnv *env,
1535     jclass clazz,
1536     jobject jResourceHandle,
1537     jstring jResourceTypeName)
1538 {
1539     LOGI("OcPlatform_bindTypeToResource");
1540     if (!jResourceHandle)
1541     {
1542         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1543         return;
1544     }
1545     std::string typeName;
1546     if (jResourceTypeName)
1547     {
1548         typeName = env->GetStringUTFChars(jResourceTypeName, NULL);
1549     }
1550
1551     JniOcResourceHandle* jniOcResourceHandle =
1552         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1553     if (!jniOcResourceHandle) return;
1554
1555     try
1556     {
1557         OCStackResult result = OCPlatform::bindTypeToResource(
1558             jniOcResourceHandle->getOCResourceHandle(),
1559             typeName
1560             );
1561
1562         if (OC_STACK_OK != result)
1563         {
1564             ThrowOcException(result, "Failed to bind type to resource");
1565         }
1566     }
1567     catch (OCException& e)
1568     {
1569         LOGE("%s", e.reason().c_str());
1570         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1571     }
1572 }
1573
1574 /*
1575 * Class:     org_iotivity_base_OcPlatform
1576 * Method:    bindInterfaceToResource0
1577 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1578 */
1579 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
1580 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
1581 {
1582     LOGI("OcPlatform_bindInterfaceToResource");
1583     if (!jResourceHandle)
1584     {
1585         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1586         return;
1587     }
1588     std::string interfaceName;
1589     if (jResourceInterfaceName)
1590     {
1591         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, NULL);
1592     }
1593
1594     JniOcResourceHandle* jniOcResourceHandle =
1595         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1596     if (!jniOcResourceHandle)
1597     {
1598         return;
1599     }
1600
1601     try
1602     {
1603         OCStackResult result = OCPlatform::bindInterfaceToResource(
1604             jniOcResourceHandle->getOCResourceHandle(),
1605             interfaceName
1606             );
1607
1608         if (OC_STACK_OK != result)
1609         {
1610             ThrowOcException(result, "Failed to bind interface to resource");
1611         }
1612     }
1613     catch (OCException& e)
1614     {
1615         LOGE("%s", e.reason().c_str());
1616         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1617     }
1618 }
1619
1620 /*
1621 * Class:     org_iotivity_base_OcPlatform
1622 * Method:    startPresence0
1623 * Signature: (I)V
1624 */
1625 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
1626     JNIEnv *env, jclass clazz, jint ttl)
1627 {
1628     LOGI("OcPlatform_startPresence");
1629
1630     try
1631     {
1632         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
1633
1634         if (OC_STACK_OK != result)
1635         {
1636             ThrowOcException(result, "Failed to start presence");
1637         }
1638     }
1639     catch (OCException& e)
1640     {
1641         LOGE("%s", e.reason().c_str());
1642         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1643     }
1644 }
1645
1646 /*
1647 * Class:     org_iotivity_base_OcPlatform
1648 * Method:    stopPresence0
1649 * Signature: ()V
1650 */
1651 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
1652     JNIEnv *env, jclass clazz)
1653 {
1654     LOGI("OcPlatform_stopPresence");
1655
1656     try
1657     {
1658         OCStackResult result = OCPlatform::stopPresence();
1659
1660         if (OC_STACK_OK != result)
1661         {
1662             ThrowOcException(result, "Failed to stop presence");
1663         }
1664     }
1665     catch (OCException& e)
1666     {
1667         LOGE("%s", e.reason().c_str());
1668         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1669     }
1670 }
1671
1672 /*
1673 * Class:     org_iotivity_base_OcPlatform
1674 * Method:    subscribePresence0
1675 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
1676 */
1677 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
1678     JNIEnv *env,
1679     jclass clazz,
1680     jstring jHost,
1681     jint jConnectivityType,
1682     jobject jListener)
1683 {
1684     LOGD("OcPlatform_subscribePresence");
1685     std::string host;
1686     if (jHost)
1687     {
1688         host = env->GetStringUTFChars(jHost, NULL);
1689     }
1690     if (!jListener)
1691     {
1692         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
1693         return nullptr;
1694     }
1695
1696     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
1697
1698     SubscribeCallback subscribeCallback =
1699         [onPresenceListener](OCStackResult result,
1700                              const unsigned int nonce,
1701                              const std::string& hostAddress)
1702         {
1703             onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
1704         };
1705
1706     OCPlatform::OCPresenceHandle presenceHandle;
1707     try
1708     {
1709         OCStackResult result = OCPlatform::subscribePresence(
1710             presenceHandle,
1711             host,
1712             static_cast<OCConnectivityType>(jConnectivityType),
1713             subscribeCallback);
1714
1715         if (OC_STACK_OK != result)
1716         {
1717             ThrowOcException(result, "subscribe presence has failed");
1718         }
1719     }
1720     catch (OCException& e)
1721     {
1722         LOGE("%s", e.reason().c_str());
1723         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1724         return nullptr;
1725     }
1726
1727     JniOcPresenceHandle* jniPresenceHandle =
1728         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
1729     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
1730     jobject jPresenceHandle =
1731         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
1732     if (!jPresenceHandle)
1733     {
1734         LOGE("Failed to create OcPresenceHandle");
1735         delete jniPresenceHandle;
1736     }
1737     return jPresenceHandle;
1738 }
1739
1740 /*
1741 * Class:     org_iotivity_base_OcPlatform
1742 * Method:    subscribePresence1
1743 * Signature: (Ljava/lang/String;Ljava/lang/String;I
1744 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
1745 */
1746 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
1747     JNIEnv *env,
1748     jclass clazz,
1749     jstring jHost,
1750     jstring jResourceType,
1751     jint jConnectivityType,
1752     jobject jListener)
1753 {
1754     LOGD("OcPlatform_subscribePresence1");
1755     std::string host;
1756     if (jHost)
1757     {
1758         host = env->GetStringUTFChars(jHost, NULL);
1759     }
1760     std::string resourceType;
1761     if (jResourceType)
1762     {
1763         resourceType = env->GetStringUTFChars(jResourceType, NULL);
1764     }
1765     if (!jListener)
1766     {
1767         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
1768         return nullptr;
1769     }
1770
1771     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
1772
1773     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
1774         const unsigned int nonce, const std::string& hostAddress)
1775     {
1776         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
1777     };
1778
1779     OCPlatform::OCPresenceHandle presenceHandle;
1780     try
1781     {
1782         OCStackResult result = OCPlatform::subscribePresence(
1783             presenceHandle,
1784             host,
1785             resourceType,
1786             static_cast<OCConnectivityType>(jConnectivityType),
1787             subscribeCallback);
1788
1789         if (OC_STACK_OK != result)
1790         {
1791             ThrowOcException(result, "subscribe presence has failed");
1792         }
1793     }
1794     catch (OCException& e)
1795     {
1796         LOGE("%s", e.reason().c_str());
1797         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1798         return nullptr;
1799     }
1800
1801     JniOcPresenceHandle* jniPresenceHandle =
1802         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
1803     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
1804     jobject jPresenceHandle =
1805         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
1806     if (!jPresenceHandle)
1807     {
1808         LOGE("Failed to create OcPresenceHandle");
1809         delete jniPresenceHandle;
1810     }
1811     return jPresenceHandle;
1812 }
1813
1814 /*
1815 * Class:     org_iotivity_base_OcPlatform
1816 * Method:    unsubscribePresence0
1817 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
1818 */
1819 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
1820     JNIEnv *env, jclass clazz, jobject jPresenceHandle)
1821 {
1822     LOGD("OcPlatform_unsubscribePresence");
1823     if (!jPresenceHandle)
1824     {
1825         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
1826         return;
1827     }
1828     JniOcPresenceHandle* jniPresenceHandle =
1829         JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
1830     if (!jniPresenceHandle)
1831     {
1832         return;
1833     }
1834
1835     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
1836
1837     try
1838     {
1839         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
1840
1841         if (OC_STACK_OK != result)
1842         {
1843             ThrowOcException(result, "unsubscribe presence has failed");
1844             return;
1845         }
1846         jweak jwOnPresenceListener =
1847             jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
1848         if (jwOnPresenceListener)
1849         {
1850             RemoveOnPresenceListener(env, jwOnPresenceListener);
1851         }
1852     }
1853     catch (OCException& e)
1854     {
1855         LOGE("%s", e.reason().c_str());
1856         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1857     }
1858 }
1859
1860 /*
1861 * Class:     org_iotivity_base_OcPlatform
1862 * Method:    constructResourceObject0
1863 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
1864 Lorg/iotivity/base/OcResource;
1865 */
1866 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
1867     JNIEnv *env,
1868     jclass clazz,
1869     jstring jHost,
1870     jstring jUri,
1871     jint jConnectivityType,
1872     jboolean jIsObservable,
1873     jobjectArray jResourceTypeArray,
1874     jobjectArray jInterfaceArray)
1875 {
1876     LOGD("OcPlatform_constructResourceObject");
1877     std::string host;
1878     if (jHost)
1879     {
1880         host = env->GetStringUTFChars(jHost, NULL);
1881     }
1882     std::string uri;
1883     if (jUri)
1884     {
1885         uri = env->GetStringUTFChars(jUri, NULL);
1886     }
1887     if (!jResourceTypeArray)
1888     {
1889         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
1890         return nullptr;
1891     }
1892     if (!jInterfaceArray)
1893     {
1894         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
1895         return nullptr;
1896     }
1897
1898     std::vector<std::string> resourceTypes;
1899     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
1900
1901     std::vector<std::string> interfaces;
1902     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
1903
1904     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
1905         host,
1906         uri,
1907         static_cast<OCConnectivityType>(jConnectivityType),
1908         static_cast<bool>(jIsObservable),
1909         resourceTypes,
1910         interfaces);
1911
1912     if (!resource)
1913     {
1914         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
1915         return nullptr;
1916     }
1917
1918     JniOcResource *jniOcResource = new JniOcResource(resource);
1919     jlong handle = reinterpret_cast<jlong>(jniOcResource);
1920
1921     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
1922     if (!jResource)
1923     {
1924         delete jniOcResource;
1925         return nullptr;
1926     }
1927     SetHandle<JniOcResource>(env, jResource, jniOcResource);
1928     if (env->ExceptionCheck())
1929     {
1930         delete jniOcResource;
1931         return nullptr;
1932     }
1933     return jResource;
1934 }
1935
1936 /*
1937 * Class:     org_iotivity_base_OcPlatform
1938 * Method:    sendResponse0
1939 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
1940 */
1941 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
1942     JNIEnv *env, jclass clazz, jobject jResourceResponse)
1943 {
1944     LOGD("OcPlatform_sendResponse");
1945     if (!jResourceResponse)
1946     {
1947         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
1948         return;
1949     }
1950
1951     JniOcResourceResponse *jniResponse =
1952         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
1953     if (!jniResponse) return;
1954
1955     try
1956     {
1957         OCStackResult result =
1958             OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
1959
1960         if (OC_STACK_OK != result)
1961         {
1962             ThrowOcException(result, "failed to send response");
1963         }
1964     }
1965     catch (OCException& e)
1966     {
1967         LOGE("%s", e.reason().c_str());
1968         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1969     }
1970 }