android/android_api/base/jni/JniOcPlatform.cpp

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