android/android_api/base/jni/JniOcPlatform.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Intel Corporation.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "JniOcPlatform.h"
  22 #include "OCPlatform.h"
  23 #include "JniOcResource.h"
  24 #include "JniOcResourceHandle.h"
  25 #include "JniOcPresenceHandle.h"
  26 #include "JniOcResourceResponse.h"
  27 #include "JniOcSecurity.h"
  28 #include "JniOcDirectPairDevice.h"
  29 #include "JniUtils.h"
  30 #include "ocpayload.h"
  31 #include "RDClient.h"
  32
  33 #ifdef WITH_CLOUD
  34 #include "JniOcAccountManager.h"
  35 #endif
  36
  37 using namespace OC;
  38
  39 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
  40 {
  41     JniOnResourceFoundListener *onResourceFoundListener = nullptr;
  42
  43     resourceFoundMapLock.lock();
  44
  45     for (auto it = onResourceFoundListenerMap.begin();
  46          it != onResourceFoundListenerMap.end();
  47          ++it)
  48     {
  49         if (env->IsSameObject(jListener, it->first))
  50         {
  51             auto refPair = it->second;
  52             onResourceFoundListener = refPair.first;
  53             refPair.second++;
  54             it->second = refPair;
  55             onResourceFoundListenerMap.insert(*it);
  56             LOGD("OnResourceFoundListener: ref. count incremented");
  57             break;
  58         }
  59     }
  60
  61     if (!onResourceFoundListener)
  62     {
  63         onResourceFoundListener =
  64             new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);
  65         jobject jgListener = env->NewGlobalRef(jListener);
  66
  67         onResourceFoundListenerMap.insert(
  68             std::pair<jobject,
  69                       std::pair<JniOnResourceFoundListener*, int >>(
  70                           jgListener,
  71                           std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener,
  72                                                                       1)));
  73         LOGD("OnResourceFoundListener: new listener");
  74     }
  75     resourceFoundMapLock.unlock();
  76     return onResourceFoundListener;
  77 }
  78
  79 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)
  80 {
  81     resourceFoundMapLock.lock();
  82
  83     for (auto it = onResourceFoundListenerMap.begin();
  84          it != onResourceFoundListenerMap.end();
  85          ++it)
  86     {
  87         if (env->IsSameObject(jListener, it->first))
  88         {
  89             auto refPair = it->second;
  90             if (refPair.second > 1)
  91             {
  92                 refPair.second--;
  93                 it->second = refPair;
  94                 onResourceFoundListenerMap.insert(*it);
  95                 LOGI("OnResourceFoundListener: ref. count decremented");
  96             }
  97             else
  98             {
  99                 env->DeleteGlobalRef(it->first);
 100                 JniOnResourceFoundListener* listener = refPair.first;
 101                 delete listener;
 102                 onResourceFoundListenerMap.erase(it);
 103                 LOGI("OnResourceFoundListener removed");
 104             }
 105             break;
 106         }
 107     }
 108     resourceFoundMapLock.unlock();
 109 }
 110
 111 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)
 112 {
 113     JniOnDeviceInfoListener *onDeviceInfoListener = nullptr;
 114
 115     deviceInfoMapLock.lock();
 116
 117     for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
 118     {
 119         if (env->IsSameObject(jListener, it->first))
 120         {
 121             auto refPair = it->second;
 122             onDeviceInfoListener = refPair.first;
 123             refPair.second++;
 124             it->second = refPair;
 125             onDeviceInfoListenerMap.insert(*it);
 126             LOGD("OnDeviceInfoListener: ref. count incremented");
 127             break;
 128         }
 129     }
 130
 131     if (!onDeviceInfoListener)
 132     {
 133         onDeviceInfoListener =
 134             new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);
 135         jobject jgListener = env->NewGlobalRef(jListener);
 136
 137         onDeviceInfoListenerMap.insert(
 138             std::pair<jobject,
 139                       std::pair<JniOnDeviceInfoListener*, int>>(
 140                           jgListener,
 141                           std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));
 142         LOGI("OnDeviceInfoListener: new listener");
 143     }
 144
 145     deviceInfoMapLock.unlock();
 146     return onDeviceInfoListener;
 147 }
 148
 149 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)
 150 {
 151     deviceInfoMapLock.lock();
 152     bool isFound = false;
 153     for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
 154     {
 155         if (env->IsSameObject(jListener, it->first))
 156         {
 157             auto refPair = it->second;
 158             if (refPair.second > 1)
 159             {
 160                 refPair.second--;
 161                 it->second = refPair;
 162                 onDeviceInfoListenerMap.insert(*it);
 163                 LOGI("OnDeviceInfoListener: ref. count decremented");
 164             }
 165             else
 166             {
 167                 env->DeleteGlobalRef(it->first);
 168                 JniOnDeviceInfoListener* listener = refPair.first;
 169                 delete listener;
 170                 onDeviceInfoListenerMap.erase(it);
 171
 172                 LOGI("OnDeviceInfoListener removed");
 173             }
 174
 175             isFound = true;
 176             break;
 177         }
 178     }
 179
 180     if (!isFound)
 181     {
 182         ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");
 183     }
 184     deviceInfoMapLock.unlock();
 185 }
 186
 187 JniOnPlatformInfoListener* AddOnPlatformInfoListener(JNIEnv* env, jobject jListener)
 188 {
 189     JniOnPlatformInfoListener *onPlatformInfoListener = nullptr;
 190
 191     platformInfoMapLock.lock();
 192
 193     for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
 194     {
 195         if (env->IsSameObject(jListener, it->first))
 196         {
 197             auto refPair = it->second;
 198             onPlatformInfoListener = refPair.first;
 199             refPair.second++;
 200             it->second = refPair;
 201             onPlatformInfoListenerMap.insert(*it);
 202             LOGD("OnPlatformInfoListener: ref. count incremented");
 203             break;
 204         }
 205     }
 206
 207     if (!onPlatformInfoListener)
 208     {
 209         onPlatformInfoListener =
 210             new JniOnPlatformInfoListener(env, jListener, RemoveOnPlatformInfoListener);
 211         jobject jgListener = env->NewGlobalRef(jListener);
 212
 213         onPlatformInfoListenerMap.insert(
 214             std::pair<jobject, std::pair<JniOnPlatformInfoListener*, int>>(
 215                 jgListener,
 216                 std::pair<JniOnPlatformInfoListener*, int>(onPlatformInfoListener, 1)));
 217         LOGI("OnPlatformInfoListener: new listener");
 218     }
 219
 220     platformInfoMapLock.unlock();
 221     return onPlatformInfoListener;
 222 }
 223
 224 void RemoveOnPlatformInfoListener(JNIEnv* env, jobject jListener)
 225 {
 226     platformInfoMapLock.lock();
 227     bool isFound = false;
 228     for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
 229     {
 230         if (env->IsSameObject(jListener, it->first))
 231         {
 232             auto refPair = it->second;
 233             if (refPair.second > 1)
 234             {
 235                 refPair.second--;
 236                 it->second = refPair;
 237                 onPlatformInfoListenerMap.insert(*it);
 238                 LOGI("OnPlatformInfoListener: ref. count decremented");
 239             }
 240             else
 241             {
 242                 env->DeleteGlobalRef(it->first);
 243                 JniOnPlatformInfoListener* listener = refPair.first;
 244                 delete listener;
 245                 onPlatformInfoListenerMap.erase(it);
 246
 247                 LOGI("OnPlatformInfoListener removed");
 248             }
 249
 250             isFound = true;
 251             break;
 252         }
 253     }
 254
 255     if (!isFound)
 256     {
 257         ThrowOcException(JNI_EXCEPTION, "OnPlatformInfoListenet not found");
 258     }
 259     platformInfoMapLock.unlock();
 260 }
 261
 262 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)
 263 {
 264     JniOnPresenceListener *onPresenceListener = nullptr;
 265
 266     presenceMapLock.lock();
 267
 268     for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
 269     {
 270         if (env->IsSameObject(jListener, it->first))
 271         {
 272             auto refPair = it->second;
 273             onPresenceListener = refPair.first;
 274             refPair.second++;
 275             it->second = refPair;
 276             onPresenceListenerMap.insert(*it);
 277             LOGD("OnPresenceListener: ref. count incremented");
 278             break;
 279         }
 280     }
 281     if (!onPresenceListener)
 282     {
 283         onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);
 284         jobject jgListener = env->NewGlobalRef(jListener);
 285         onPresenceListenerMap.insert(
 286             std::pair<jobject, std::pair<JniOnPresenceListener*, int>>(
 287                 jgListener,
 288                 std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));
 289         LOGI("OnPresenceListener: new listener");
 290     }
 291     presenceMapLock.unlock();
 292     return onPresenceListener;
 293 }
 294
 295 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)
 296 {
 297     presenceMapLock.lock();
 298     bool isFound = false;
 299     for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
 300     {
 301         if (env->IsSameObject(jListener, it->first))
 302         {
 303             auto refPair = it->second;
 304             if (refPair.second > 1)
 305             {
 306                 refPair.second--;
 307                 it->second = refPair;
 308                 onPresenceListenerMap.insert(*it);
 309                 LOGI("OnPresenceListener: ref. count decremented");
 310             }
 311             else
 312             {
 313                 env->DeleteGlobalRef(it->first);
 314                 JniOnPresenceListener* listener = refPair.first;
 315                 delete listener;
 316                 onPresenceListenerMap.erase(it);
 317                 LOGI("OnPresenceListener is removed");
 318             }
 319             isFound = true;
 320             break;
 321         }
 322     }
 323     if (!isFound)
 324     {
 325         ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");
 326     }
 327     presenceMapLock.unlock();
 328 }
 329
 330 JniOnObserveListener* AddOnObserveListener(JNIEnv* env, jobject jListener)
 331 {
 332     JniOnObserveListener *onObserveListener = nullptr;
 333
 334     observeMapLock.lock();
 335
 336     for (auto it = onObserveListenerMap.begin(); it != onObserveListenerMap.end(); ++it)
 337     {
 338         if (env->IsSameObject(jListener, it->first))
 339         {
 340             auto refPair = it->second;
 341             onObserveListener = refPair.first;
 342             refPair.second++;
 343             it->second = refPair;
 344             onObserveListenerMap.insert(*it);
 345             LOGD("OnObserveListener: ref. count incremented");
 346             break;
 347         }
 348     }
 349     if (!onObserveListener)
 350     {
 351         onObserveListener = new JniOnObserveListener(env, jListener, (JniOcResource*)nullptr);
 352         jobject jgListener = env->NewGlobalRef(jListener);
 353         onObserveListenerMap.insert(
 354             std::pair<jobject, std::pair<JniOnObserveListener*, int>>(
 355                 jgListener,
 356                 std::pair<JniOnObserveListener*, int>(onObserveListener, 1)));
 357         LOGI("OnObserveListener: new listener");
 358     }
 359     observeMapLock.unlock();
 360     return onObserveListener;
 361 }
 362
 363 void RemoveOnObserveListener(JNIEnv* env, jobject jListener)
 364 {
 365     observeMapLock.lock();
 366     bool isFound = false;
 367     for (auto it = onObserveListenerMap.begin(); it != onObserveListenerMap.end(); ++it)
 368     {
 369         if (env->IsSameObject(jListener, it->first))
 370         {
 371             auto refPair = it->second;
 372             if (refPair.second > 1)
 373             {
 374                 refPair.second--;
 375                 it->second = refPair;
 376                 onObserveListenerMap.insert(*it);
 377                 LOGI("OnObserveListener: ref. count decremented");
 378             }
 379             else
 380             {
 381                 env->DeleteGlobalRef(it->first);
 382                 JniOnObserveListener* listener = refPair.first;
 383                 delete listener;
 384                 onObserveListenerMap.erase(it);
 385                 LOGI("OnObserveListener is removed");
 386             }
 387             isFound = true;
 388             break;
 389         }
 390     }
 391     if (!isFound)
 392     {
 393         ThrowOcException(JNI_EXCEPTION, "OnObserveListener not found");
 394     }
 395     observeMapLock.unlock();
 396 }
 397
 398 JniOnDPDevicesFoundListener* AddOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
 399 {
 400     JniOnDPDevicesFoundListener *onDPDeviceListener = nullptr;
 401
 402     dpDevicesFoundListenerMapLock.lock();
 403
 404     for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
 405             onDPDevicesFoundListenerMap.end(); ++it)
 406     {
 407         if (env->IsSameObject(jListener, it->first))
 408         {
 409             auto refPair = it->second;
 410             onDPDeviceListener = refPair.first;
 411             refPair.second++;
 412             it->second = refPair;
 413             onDPDevicesFoundListenerMap.insert(*it);
 414             LOGD("onDPDeviceListener: ref. count incremented");
 415             break;
 416         }
 417     }
 418     if (!onDPDeviceListener)
 419     {
 420         onDPDeviceListener = new JniOnDPDevicesFoundListener(env, jListener,
 421                 RemoveOnDPDevicesFoundListener);
 422         jobject jgListener = env->NewGlobalRef(jListener);
 423         onDPDevicesFoundListenerMap.insert(
 424                 std::pair<jobject, std::pair<JniOnDPDevicesFoundListener*, int>>(
 425                     jgListener,
 426                     std::pair<JniOnDPDevicesFoundListener*, int>(onDPDeviceListener, 1)));
 427         LOGI("onDPDeviceListener: new listener");
 428     }
 429     dpDevicesFoundListenerMapLock.unlock();
 430     return onDPDeviceListener;
 431 }
 432
 433 void RemoveOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
 434 {
 435     dpDevicesFoundListenerMapLock.lock();
 436     bool isFound = false;
 437     for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
 438             onDPDevicesFoundListenerMap.end(); ++it)
 439     {
 440         if (env->IsSameObject(jListener, it->first))
 441         {
 442             auto refPair = it->second;
 443             if (refPair.second > 1)
 444             {
 445                 refPair.second--;
 446                 it->second = refPair;
 447                 onDPDevicesFoundListenerMap.insert(*it);
 448                 LOGI("onDPDeviceListener: ref. count decremented");
 449             }
 450             else
 451             {
 452                 env->DeleteGlobalRef(it->first);
 453                 JniOnDPDevicesFoundListener* listener = refPair.first;
 454                 delete listener;
 455                 onDPDevicesFoundListenerMap.erase(it);
 456                 LOGI("onDPDeviceListener is removed");
 457             }
 458             isFound = true;
 459             break;
 460         }
 461     }
 462     if (!isFound)
 463     {
 464         ThrowOcException(JNI_EXCEPTION, "onDPDeviceListener not found");
 465     }
 466     dpDevicesFoundListenerMapLock.unlock();
 467 }
 468
 469 JniOnDirectPairingListener* AddOnDirectPairingListener(JNIEnv* env, jobject jListener)
 470 {
 471     JniOnDirectPairingListener *onDirectPairingListener = nullptr;
 472
 473     directPairingListenerMapLock.lock();
 474
 475     for (auto it = directPairingListenerMap.begin(); it !=
 476             directPairingListenerMap.end(); ++it)
 477     {
 478         if (env->IsSameObject(jListener, it->first))
 479         {
 480             auto refPair = it->second;
 481             onDirectPairingListener = refPair.first;
 482             refPair.second++;
 483             it->second = refPair;
 484             directPairingListenerMap.insert(*it);
 485             LOGD("onDirectPairingListener: ref. count incremented");
 486             break;
 487         }
 488     }
 489     if (!onDirectPairingListener)
 490     {
 491         onDirectPairingListener = new JniOnDirectPairingListener(env, jListener,
 492                 RemoveOnDirectPairingListener);
 493         jobject jgListener = env->NewGlobalRef(jListener);
 494         directPairingListenerMap.insert(
 495                 std::pair<jobject, std::pair<JniOnDirectPairingListener*, int>>(
 496                     jgListener,
 497                     std::pair<JniOnDirectPairingListener*, int>(onDirectPairingListener, 1)));
 498         LOGI("onDirectPairingListener: new listener");
 499     }
 500     directPairingListenerMapLock.unlock();
 501     return onDirectPairingListener;
 502 }
 503
 504 void RemoveOnDirectPairingListener(JNIEnv* env, jobject jListener)
 505 {
 506     directPairingListenerMapLock.lock();
 507     bool isFound = false;
 508     for (auto it = directPairingListenerMap.begin(); it !=
 509             directPairingListenerMap.end(); ++it)
 510     {
 511         if (env->IsSameObject(jListener, it->first))
 512         {
 513             auto refPair = it->second;
 514             if (refPair.second > 1)
 515             {
 516                 refPair.second--;
 517                 it->second = refPair;
 518                 directPairingListenerMap.insert(*it);
 519                 LOGI("onDirectPairingListener: ref. count decremented");
 520             }
 521             else
 522             {
 523                 env->DeleteGlobalRef(it->first);
 524                 JniOnDirectPairingListener* listener = refPair.first;
 525                 delete listener;
 526                 directPairingListenerMap.erase(it);
 527                 LOGI("onDirectPairingListener is removed");
 528             }
 529             isFound = true;
 530             break;
 531         }
 532     }
 533     if (!isFound)
 534     {
 535         ThrowOcException(JNI_EXCEPTION, "onDirectPairingListener not found");
 536     }
 537     directPairingListenerMapLock.unlock();
 538 }
 539
 540 /*
 541 * Class:     org_iotivity_base_OcPlatform
 542 * Method:    configure
 543 * Signature: (IILjava/lang/String;II)V
 544 */
 545 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
 546 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort,
 547                                                                  jint jQOS, jstring jDbPath)
 548 {
 549     LOGI("OcPlatform_configure");
 550
 551     std::string ipAddress;
 552     std::string dbfile;
 553     if (jIpAddress)
 554     {
 555         ipAddress = env->GetStringUTFChars(jIpAddress, nullptr);
 556     }
 557     if (jDbPath)
 558     {
 559         dbfile = env->GetStringUTFChars(jDbPath, nullptr);
 560         JniOcSecurity::StoreDbPath(dbfile);
 561     }
 562     uint16_t port = 0;
 563     if (jPort > 0)
 564     {
 565         port = static_cast<uint16_t>(jPort);
 566     }
 567
 568     PlatformConfig cfg{
 569         JniUtils::getServiceType(env, jServiceType),
 570         JniUtils::getModeType(env, jModeType),
 571         ipAddress,
 572         port,
 573         JniUtils::getQOS(env, static_cast<int>(jQOS)),
 574         JniOcSecurity::getOCPersistentStorage()
 575     };
 576     OCPlatform::Configure(cfg);
 577 }
 578
 579 /*
 580 * Class:     org_iotivity_base_OcPlatform
 581 * Method:    notifyAllObservers0
 582 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
 583 */
 584 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0
 585 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
 586 {
 587     LOGI("OcPlatform_notifyAllObservers");
 588     if (!jResourceHandle)
 589     {
 590         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 591         return;
 592     }
 593
 594     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
 595         env, jResourceHandle);
 596     if (!jniOcResourceHandle)
 597     {
 598         return;
 599     }
 600
 601     try
 602     {
 603         OCStackResult result =
 604             OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());
 605
 606         if (OC_STACK_OK != result)
 607         {
 608             ThrowOcException(result, "Failed to notify all observers");
 609             return;
 610         }
 611     }
 612     catch (OCException& e)
 613     {
 614         LOGE("%s", e.reason().c_str());
 615         ThrowOcException(e.code(), e.reason().c_str());
 616     }
 617 }
 618
 619 /*
 620 * Class:     org_iotivity_base_OcPlatform
 621 * Method:    notifyAllObservers1
 622 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V
 623 */
 624 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1
 625 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)
 626 {
 627     LOGI("OcPlatform_notifyAllObservers1");
 628
 629     if (!jResourceHandle)
 630     {
 631         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 632         return;
 633     }
 634
 635     JniOcResourceHandle* jniOcResourceHandle =
 636         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 637     if (!jniOcResourceHandle)
 638     {
 639         return;
 640     }
 641
 642     try {
 643         OCStackResult result = OCPlatform::notifyAllObservers(
 644             jniOcResourceHandle->getOCResourceHandle(),
 645             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 646
 647         if (OC_STACK_OK != result)
 648         {
 649             ThrowOcException(result, "Failed to notify all observers");
 650             return;
 651         }
 652     }
 653     catch (OCException& e)
 654     {
 655         LOGE("%s", e.reason().c_str());
 656         ThrowOcException(e.code(), e.reason().c_str());
 657     }
 658 }
 659
 660 /*
 661 * Class:     org_iotivity_base_OcPlatform
 662 * Method:    notifyListOfObservers2
 663 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V
 664 */
 665 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2(
 666     JNIEnv *env,
 667     jclass clazz,
 668     jobject jResourceHandle,
 669     jbyteArray jObservationIdArr,
 670     jobject jResourceResponse)
 671 {
 672     LOGD("OcPlatform_notifyListOfObservers2");
 673     if (!jResourceHandle)
 674     {
 675         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 676         return;
 677     }
 678     if (!jObservationIdArr)
 679     {
 680         ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
 681         return;
 682     }
 683     if (!jResourceResponse)
 684     {
 685         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
 686         return;
 687     }
 688
 689     JniOcResourceHandle* jniOcResourceHandle =
 690         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 691     if (!jniOcResourceHandle)
 692     {
 693         return;
 694     }
 695
 696     JniOcResourceResponse* jniOcResourceResponse =
 697         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
 698     if (!jniOcResourceResponse)
 699     {
 700         return;
 701     }
 702
 703     int len = env->GetArrayLength(jObservationIdArr);
 704     uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
 705
 706     ObservationIds observationIds;
 707     for (int i = 0; i < len; ++i)
 708     {
 709         observationIds.push_back(bArr[i]);
 710     }
 711
 712     env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
 713
 714     try
 715     {
 716         OCStackResult result = OCPlatform::notifyListOfObservers(
 717             jniOcResourceHandle->getOCResourceHandle(),
 718             observationIds,
 719             jniOcResourceResponse->getOCResourceResponse());
 720
 721         if (OC_STACK_OK != result)
 722         {
 723             ThrowOcException(result, "Failed to notify all observers");
 724         }
 725     }
 726     catch (OCException& e)
 727     {
 728         LOGE("%s", e.reason().c_str());
 729         ThrowOcException(e.code(), e.reason().c_str());
 730     }
 731 }
 732
 733 /*
 734 * Class:     org_iotivity_base_OcPlatform
 735 * Method:    notifyListOfObservers3
 736 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V
 737 */
 738 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3(
 739     JNIEnv *env,
 740     jclass clazz,
 741     jobject jResourceHandle,
 742     jbyteArray jObservationIdArr,
 743     jobject jResourceResponse,
 744     jint jQoS)
 745 {
 746     LOGD("OcPlatform_notifyListOfObservers3");
 747     if (!jResourceHandle)
 748     {
 749         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 750         return;
 751     }
 752     if (!jObservationIdArr)
 753     {
 754         ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
 755         return;
 756     }
 757     if (!jResourceResponse)
 758     {
 759         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
 760         return;
 761     }
 762
 763     JniOcResourceHandle* jniOcResourceHandle =
 764         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 765     if (!jniOcResourceHandle)
 766     {
 767         return;
 768     }
 769
 770     JniOcResourceResponse* jniOcResourceResponse =
 771         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
 772     if (!jniOcResourceResponse)
 773     {
 774         return;
 775     }
 776
 777     int len = env->GetArrayLength(jObservationIdArr);
 778     uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
 779
 780     ObservationIds observationIds;
 781     for (int i = 0; i < len; ++i)
 782     {
 783         observationIds.push_back(bArr[i]);
 784     }
 785
 786     env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
 787
 788     try
 789     {
 790         OCStackResult result = OCPlatform::notifyListOfObservers(
 791             jniOcResourceHandle->getOCResourceHandle(),
 792             observationIds,
 793             jniOcResourceResponse->getOCResourceResponse(),
 794             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 795
 796         if (OC_STACK_OK != result)
 797         {
 798             ThrowOcException(result, "Failed to notify all observers");
 799         }
 800     }
 801     catch (OCException& e)
 802     {
 803         LOGE("%s", e.reason().c_str());
 804         ThrowOcException(e.code(), e.reason().c_str());
 805     }
 806 }
 807
 808 /*
 809 * Class:     org_iotivity_base_OcPlatform
 810 * Method:    findResource0
 811 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V
 812 */
 813 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0(
 814     JNIEnv *env,
 815     jclass clazz,
 816     jstring jHost,
 817     jstring jResourceUri,
 818     jint jConnectivityType,
 819     jobject jListener)
 820 {
 821     LOGD("OcPlatform_findResource");
 822     std::string host;
 823     if (jHost)
 824     {
 825         host = env->GetStringUTFChars(jHost, nullptr);
 826     }
 827     std::string resourceUri;
 828     if (jResourceUri)
 829     {
 830         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
 831     }
 832     if (!jListener)
 833     {
 834         ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
 835         return;
 836     }
 837
 838     JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
 839
 840     FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
 841     {
 842         onResFoundListener->foundResourceCallback(resource);
 843     };
 844
 845     FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
 846     {
 847         onResFoundListener->findResourceErrorCallback(uri, eCode);
 848     };
 849
 850     try
 851     {
 852         OCStackResult result = OCPlatform::findResource(
 853             host,
 854             resourceUri,
 855             static_cast<OCConnectivityType>(jConnectivityType),
 856             findCallback,
 857             findErrorCallback);
 858
 859         if (OC_STACK_OK != result)
 860         {
 861             ThrowOcException(result, "Find resource has failed");
 862             return;
 863         }
 864     }
 865     catch (OCException& e)
 866     {
 867         LOGE("%s", e.reason().c_str());
 868         ThrowOcException(e.code(), e.reason().c_str());
 869     }
 870 }
 871
 872 /*
 873 * Class:     org_iotivity_base_OcPlatform
 874 * Method:    findResource1
 875 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
 876 */
 877 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1(
 878     JNIEnv *env,
 879     jclass clazz,
 880     jstring jHost,
 881     jstring jResourceUri,
 882     jint jConnectivityType,
 883     jobject jListener,
 884     jint jQoS)
 885 {
 886     LOGD("OcPlatform_findResource");
 887     std::string host;
 888     if (jHost)
 889     {
 890         host = env->GetStringUTFChars(jHost, nullptr);
 891     }
 892     std::string resourceUri;
 893     if (jResourceUri)
 894     {
 895         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
 896     }
 897     if (!jListener)
 898     {
 899         ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
 900         return;
 901     }
 902     JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
 903
 904     FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
 905     {
 906         onResFoundListener->foundResourceCallback(resource);
 907     };
 908
 909     FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
 910     {
 911         onResFoundListener->findResourceErrorCallback(uri, eCode);
 912     };
 913
 914     try
 915     {
 916         OCStackResult result = OCPlatform::findResource(
 917             host,
 918             resourceUri,
 919             static_cast<OCConnectivityType>(jConnectivityType),
 920             findCallback,
 921             findErrorCallback,
 922             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 923
 924         if (OC_STACK_OK != result)
 925         {
 926             ThrowOcException(result, "Find resource has failed");
 927             return;
 928         }
 929     }
 930     catch (OCException& e)
 931     {
 932         LOGE("%s", e.reason().c_str());
 933         ThrowOcException(e.code(), e.reason().c_str());
 934     }
 935 }
 936
 937 /*
 938  * Class:     org_iotivity_base_OcPlatform
 939  * Method:    findDirectPairingDevices
 940  * Signature: (ILorg/iotivity/base/OcPlatform/FindDirectPairingListener;)V
 941  */
 942 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findDirectPairingDevices
 943   (JNIEnv * env, jclass clazz, jint jTimeout, jobject jListener)
 944 {
 945     LOGD("OcPlatform_findDirectPairingDevices");
 946
 947     if (!jListener)
 948     {
 949         ThrowOcException(OC_STACK_INVALID_PARAM, "onDPDevicesFoundListener cannot be null");
 950         return;
 951     }
 952     JniOnDPDevicesFoundListener *onDPDevsFoundListener = AddOnDPDevicesFoundListener(env,
 953             jListener);
 954
 955     GetDirectPairedCallback getDirectPairedCallback =
 956         [onDPDevsFoundListener](PairedDevices pairingDevList)
 957         {
 958             onDPDevsFoundListener->directPairingDevicesCallback(pairingDevList,
 959                     DPFunc::FIND_DIRECT_PAIRED_DEV_LIST);
 960         };
 961
 962     try
 963     {
 964         OCStackResult result = OCPlatform::findDirectPairingDevices(jTimeout,
 965                 getDirectPairedCallback);
 966         if (OC_STACK_OK != result)
 967         {
 968             ThrowOcException(result, "OCPlatform::findDirectPairingDevices has failed");
 969             return;
 970         }
 971     }
 972     catch (OCException& e)
 973     {
 974         LOGE("%s", e.reason().c_str());
 975         ThrowOcException(e.code(), e.reason().c_str());
 976     }
 977 }
 978
 979 /*
 980  * Class:     org_iotivity_base_OcPlatform
 981  * Method:    getDirectPairedDevices
 982  * Signature: (Lorg/iotivity/base/OcDirectPairDevice/GetDirectPairedListener;)V
 983  */
 984 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDirectPairedDevices
 985 (JNIEnv *env, jclass jclazz, jobject jListener)
 986 {
 987     LOGD("OcPlatform_getDirectPairedDevices");
 988
 989     if (!jListener)
 990     {
 991         ThrowOcException(OC_STACK_INVALID_PARAM, "getPairedDevList Callback cannot be null");
 992         return;
 993     }
 994     JniOnDPDevicesFoundListener *onGetPairedDevicesListener = AddOnDPDevicesFoundListener(env,
 995             jListener);
 996
 997     GetDirectPairedCallback getDirectPairedCallback =
 998         [onGetPairedDevicesListener](PairedDevices pairedDevList)
 999         {
1000             onGetPairedDevicesListener->directPairingDevicesCallback(pairedDevList,
1001                     DPFunc::GET_PAIRED_DEV_LIST);
1002         };
1003
1004     try
1005     {
1006         OCStackResult result = OCPlatform::getDirectPairedDevices(getDirectPairedCallback);
1007         if (OC_STACK_OK != result)
1008         {
1009             ThrowOcException(result, "OcDirectPairDevice_getDirectPairedDevices");
1010             return;
1011         }
1012     }
1013     catch (OCException& e)
1014     {
1015         LOGE("%s", e.reason().c_str());
1016         ThrowOcException(e.code(), e.reason().c_str());
1017     }
1018 }
1019
1020 /*
1021  * Class:     org_iotivity_base_OcPlatform
1022  * Method:    doDirectPairing
1023  * Signature: (Lorg/iotivity/base/OcDirectPairDevice;Lorg/iotivity/base/OcPrmType;
1024  *           Ljava/lang/String;Lorg/iotivity/base/OcDirectPairDevice/DirectPairingListener;)V
1025  */
1026 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_doDirectPairing0
1027 (JNIEnv *env, jclass clazz, jobject jpeer, jint jprmType, jstring jpin, jobject jListener)
1028 {
1029     LOGD("OcPlatform_doDirectPairing");
1030
1031     if (!jListener)
1032     {
1033         ThrowOcException(OC_STACK_INVALID_PARAM, "doDirectPairing Callback cannot be null");
1034         return;
1035     }
1036     if (!jpeer)
1037     {
1038         ThrowOcException(OC_STACK_INVALID_PARAM, "Peer cannot be null");
1039         return;
1040     }
1041
1042     JniOnDirectPairingListener *onDirectPairingListener = AddOnDirectPairingListener(env,
1043             jListener);
1044
1045     DirectPairingCallback DirectPairingCB =
1046         [onDirectPairingListener](std::shared_ptr<OCDirectPairing> dpDev, OCStackResult result)
1047         {
1048             onDirectPairingListener->doDirectPairingCB(dpDev, result);
1049         };
1050
1051     JniOcDirectPairDevice *dev = JniOcDirectPairDevice::getJniOcDirectPairDevicePtr(env, jpeer);
1052
1053     if (!dev)
1054     {
1055         return ;
1056     }
1057     std::string pin = env->GetStringUTFChars(jpin, 0);
1058
1059     try
1060     {
1061         OCStackResult result = OCPlatform::doDirectPairing(dev->getPtr(), (OCPrm_t)jprmType,
1062                 pin, DirectPairingCB);
1063         if (OC_STACK_OK != result)
1064         {
1065             ThrowOcException(result, "OcPlatform_oDirectPairing");
1066             return;
1067         }
1068     }
1069     catch (OCException& e)
1070     {
1071         LOGE("%s", e.reason().c_str());
1072         ThrowOcException(e.code(), e.reason().c_str());
1073     }
1074 }
1075
1076 /*
1077 * Class:     org_iotivity_base_OcPlatform
1078 * Method:    getDeviceInfo0
1079 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
1080 */
1081 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0(
1082     JNIEnv *env,
1083     jclass clazz,
1084     jstring jHost,
1085     jstring jResourceUri,
1086     jint jConnectivityType,
1087     jobject jListener)
1088 {
1089     LOGD("OcPlatform_getDeviceInfo0");
1090     std::string host;
1091     if (jHost)
1092     {
1093         host = env->GetStringUTFChars(jHost, nullptr);
1094     }
1095     std::string resourceUri;
1096     if (jResourceUri)
1097     {
1098         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1099     }
1100     if (!jListener)
1101     {
1102         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1103         return;
1104     }
1105     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1106
1107     FindDeviceCallback findDeviceCallback =
1108         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1109         {
1110             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1111         };
1112
1113     try
1114     {
1115         OCStackResult result = OCPlatform::getDeviceInfo(
1116             host,
1117             resourceUri,
1118             static_cast<OCConnectivityType>(jConnectivityType),
1119             findDeviceCallback);
1120
1121         if (OC_STACK_OK != result)
1122         {
1123             ThrowOcException(result, "Find device has failed");
1124         }
1125     }
1126     catch (OCException& e)
1127     {
1128         LOGE("%s", e.reason().c_str());
1129         ThrowOcException(e.code(), e.reason().c_str());
1130     }
1131 }
1132
1133 /*
1134 * Class:     org_iotivity_base_OcPlatform
1135 * Method:    getDeviceInfo1
1136 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
1137 */
1138 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1(
1139     JNIEnv *env,
1140     jclass clazz,
1141     jstring jHost,
1142     jstring jResourceUri,
1143     jint jConnectivityType,
1144     jobject jListener,
1145     jint jQoS)
1146 {
1147     LOGD("OcPlatform_getDeviceInfo1");
1148     std::string host;
1149     if (jHost)
1150     {
1151         host = env->GetStringUTFChars(jHost, nullptr);
1152     }
1153     std::string resourceUri;
1154     if (jResourceUri)
1155     {
1156         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1157     }
1158     if (!jListener)
1159     {
1160         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1161         return;
1162     }
1163     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1164
1165     FindDeviceCallback findDeviceCallback =
1166         [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1167         {
1168             onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1169         };
1170
1171     try
1172     {
1173         OCStackResult result = OCPlatform::getDeviceInfo(
1174             host,
1175             resourceUri,
1176             static_cast<OCConnectivityType>(jConnectivityType),
1177             findDeviceCallback,
1178             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1179
1180         if (OC_STACK_OK != result)
1181         {
1182             ThrowOcException(result, "Find device has failed");
1183         }
1184     }
1185     catch (OCException& e)
1186     {
1187         LOGE("%s", e.reason().c_str());
1188         ThrowOcException(e.code(), e.reason().c_str());
1189     }
1190 }
1191
1192 /*
1193 * Class:     org_iotivity_base_OcPlatform
1194 * Method:    getPlatformInfo0
1195 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
1196 */
1197 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0(
1198     JNIEnv *env,
1199     jclass clazz,
1200     jstring jHost,
1201     jstring jResourceUri,
1202     jint jConnectivityType,
1203     jobject jListener)
1204 {
1205     LOGD("OcPlatform_getPlatformInfo0");
1206     std::string host;
1207     if (jHost)
1208     {
1209         host = env->GetStringUTFChars(jHost, nullptr);
1210     }
1211     std::string resourceUri;
1212     if (jResourceUri)
1213     {
1214         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1215     }
1216     if (!jListener)
1217     {
1218         ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1219         return;
1220     }
1221     JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
1222
1223     FindPlatformCallback findPlatformCallback =
1224         [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
1225         {
1226             onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
1227         };
1228
1229     try
1230     {
1231         OCStackResult result = OCPlatform::getPlatformInfo(
1232             host,
1233             resourceUri,
1234             static_cast<OCConnectivityType>(jConnectivityType),
1235             findPlatformCallback);
1236
1237         if (OC_STACK_OK != result)
1238         {
1239             ThrowOcException(result, "Find platform has failed");
1240         }
1241     }
1242     catch (OCException& e)
1243     {
1244         LOGE("%s", e.reason().c_str());
1245         ThrowOcException(e.code(), e.reason().c_str());
1246     }
1247 }
1248
1249 /*
1250 * Class:     org_iotivity_base_OcPlatform
1251 * Method:    getPlatformInfo1
1252 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
1253 */
1254 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1(
1255     JNIEnv *env,
1256     jclass clazz,
1257     jstring jHost,
1258     jstring jResourceUri,
1259     jint jConnectivityType,
1260     jobject jListener,
1261     jint jQoS)
1262 {
1263     LOGD("OcPlatform_getPlatformInfo1");
1264     std::string host;
1265     if (jHost)
1266     {
1267         host = env->GetStringUTFChars(jHost, nullptr);
1268     }
1269     std::string resourceUri;
1270     if (jResourceUri)
1271     {
1272         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1273     }
1274     if (!jListener)
1275     {
1276         ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1277         return;
1278     }
1279     JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
1280
1281     FindPlatformCallback findPlatformCallback =
1282         [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
1283         {
1284             onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
1285         };
1286
1287     try
1288     {
1289         OCStackResult result = OCPlatform::getPlatformInfo(
1290             host,
1291             resourceUri,
1292             static_cast<OCConnectivityType>(jConnectivityType),
1293             findPlatformCallback,
1294             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1295
1296         if (OC_STACK_OK != result)
1297         {
1298             ThrowOcException(result, "Find platform has failed");
1299         }
1300     }
1301     catch (OCException& e)
1302     {
1303         LOGE("%s", e.reason().c_str());
1304         ThrowOcException(e.code(), e.reason().c_str());
1305     }
1306 }
1307
1308 /*
1309 * Class:     org_iotivity_base_OcPlatform
1310 * Method:    registerResource0
1311 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
1312 */
1313 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0(
1314     JNIEnv *env, jclass clazz, jobject jResource)
1315 {
1316     LOGD("OcPlatform_registerResource");
1317     if (!jResource)
1318     {
1319         ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
1320         return nullptr;
1321     }
1322     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
1323     if (!resource)
1324     {
1325         return nullptr;
1326     }
1327
1328     OCResourceHandle resourceHandle;
1329     try
1330     {
1331         OCStackResult result = OCPlatform::registerResource(
1332             resourceHandle,
1333             resource->getOCResource());
1334
1335         if (OC_STACK_OK != result)
1336         {
1337             ThrowOcException(result, "register resource");
1338         }
1339     }
1340     catch (OCException& e)
1341     {
1342         LOGE("%s", e.reason().c_str());
1343         ThrowOcException(e.code(), e.reason().c_str());
1344         return nullptr;
1345     }
1346     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1347     jlong handle = reinterpret_cast<jlong>(jniHandle);
1348     jobject jResourceHandle =
1349         env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1350
1351     if (!jResourceHandle)
1352     {
1353         LOGE("Failed to create OcResourceHandle");
1354         delete jniHandle;
1355     }
1356     return jResourceHandle;
1357 }
1358
1359 /*
1360 * Class:     org_iotivity_base_OcPlatform
1361 * Method:    registerResource1
1362 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
1363 */
1364 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1(
1365     JNIEnv *env,
1366     jclass clazz,
1367     jstring jResourceUri,
1368     jstring jResourceTypeName,
1369     jstring jResourceInterface,
1370 jobject jListener, jint jResourceProperty)
1371 {
1372     LOGI("OcPlatform_registerResource1");
1373     std::string resourceUri;
1374     if (jResourceUri)
1375     {
1376         resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1377     }
1378     std::string resourceTypeName;
1379     if (jResourceTypeName)
1380     {
1381         resourceTypeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1382     }
1383     std::string resourceInterface;
1384     if (jResourceInterface)
1385     {
1386         resourceInterface = env->GetStringUTFChars(jResourceInterface, nullptr);
1387     }
1388     JniEntityHandler* entityHandler = NULL;
1389     EntityHandler handleEntityCallback = NULL;
1390     if (jListener)
1391     {
1392         entityHandler = new JniEntityHandler(env, jListener);
1393         handleEntityCallback =
1394             [entityHandler](const std::shared_ptr<OCResourceRequest> request) -> OCEntityHandlerResult
1395             {
1396                 return entityHandler->handleEntity(request);
1397             };
1398     }
1399
1400     OCResourceHandle resourceHandle;
1401     try
1402     {
1403         OCStackResult result = OCPlatform::registerResource(
1404             resourceHandle,
1405             resourceUri,
1406             resourceTypeName,
1407             resourceInterface,
1408             handleEntityCallback,
1409             static_cast<int>(jResourceProperty));
1410
1411         if (OC_STACK_OK != result)
1412         {
1413             delete entityHandler;
1414             ThrowOcException(result, "register resource");
1415             return nullptr;
1416         }
1417     }
1418     catch (OCException& e)
1419     {
1420         LOGE("%s", e.reason().c_str());
1421         delete entityHandler;
1422         ThrowOcException(e.code(), e.reason().c_str());
1423         return nullptr;
1424     }
1425
1426     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1427     jlong handle = reinterpret_cast<jlong>(jniHandle);
1428     jobject jResourceHandle =
1429         env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1430     if (!jResourceHandle)
1431     {
1432         LOGE("Failed to create OcResourceHandle");
1433         delete jniHandle;
1434     }
1435
1436     return jResourceHandle;
1437 }
1438
1439 /*
1440 * Class:     org_iotivity_base_OcPlatform
1441 * Method:    registerDeviceInfo0
1442 * 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
1443 */
1444 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0(
1445     JNIEnv *env,
1446     jclass clazz,
1447     jstring jDeviceName,
1448     jobjectArray jDeviceTypes)
1449 {
1450     LOGI("OcPlatform_registerDeviceInfo");
1451
1452     if (!jDeviceName)
1453     {
1454         ThrowOcException(OC_STACK_INVALID_PARAM, "deviceName cannot be null");
1455         return;
1456     }
1457
1458     if (!jDeviceTypes)
1459     {
1460         ThrowOcException(OC_STACK_INVALID_PARAM, "deviceTypes cannot be null");
1461         return;
1462     }
1463
1464     OCDeviceInfo deviceInfo;
1465     memset(&deviceInfo, 0, sizeof(deviceInfo));
1466     try
1467     {
1468         DuplicateString(&deviceInfo.deviceName, env->GetStringUTFChars(jDeviceName, nullptr));
1469
1470         jsize len = env->GetArrayLength(jDeviceTypes);
1471         for (jsize i = 0; i < len; ++i)
1472         {
1473             jstring jStr = (jstring)env->GetObjectArrayElement(jDeviceTypes, i);
1474             if (!jStr)
1475             {
1476                 delete deviceInfo.deviceName;
1477                 ThrowOcException(OC_STACK_INVALID_PARAM, "device type cannot be null");
1478                 return;
1479             }
1480
1481             OCResourcePayloadAddStringLL(&deviceInfo.types, env->GetStringUTFChars(jStr, nullptr));
1482             if (env->ExceptionCheck())
1483             {
1484                 delete deviceInfo.deviceName;
1485                 return;
1486             }
1487
1488             env->DeleteLocalRef(jStr);
1489         }
1490     }
1491     catch (std::exception &e)
1492     {
1493         ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1494         return;
1495     }
1496
1497     try
1498     {
1499         OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1500
1501         delete deviceInfo.deviceName;
1502
1503         if (OC_STACK_OK != result)
1504         {
1505             ThrowOcException(result, "Failed to register device info");
1506             return;
1507         }
1508     }
1509     catch (OCException& e)
1510     {
1511         LOGE("%s", e.reason().c_str());
1512         ThrowOcException(e.code(), e.reason().c_str());
1513     }
1514 }
1515
1516 /*
1517 * Class:     org_iotivity_base_OcPlatform
1518 * Method:    registerPlatformInfo0
1519 * 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
1520 */
1521 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0(
1522     JNIEnv *env,
1523     jclass clazz,
1524     jstring jPlatformID,
1525     jstring jManufacturerName,
1526     jstring jManufacturerUrl,
1527     jstring jModelNumber,
1528     jstring jDateOfManufacture,
1529     jstring jPlatformVersion,
1530     jstring jOperatingSystemVersion,
1531     jstring jHardwareVersion,
1532     jstring jFirmwareVersion,
1533     jstring jSupportUrl,
1534     jstring jSystemTime)
1535 {
1536     LOGI("OcPlatform_registerPlatformInfo");
1537
1538
1539     std::string platformID;
1540         std::string manufacturerName;
1541         std::string manufacturerUrl;
1542         std::string modelNumber;
1543         std::string dateOfManufacture;
1544         std::string platformVersion;
1545         std::string operatingSystemVersion;
1546         std::string hardwareVersion;
1547         std::string firmwareVersion;
1548         std::string supportUrl;
1549         std::string systemTime;
1550
1551         if (jPlatformID)
1552         {
1553             platformID = env->GetStringUTFChars(jPlatformID, nullptr);
1554         }
1555         if (jManufacturerName)
1556         {
1557             manufacturerName = env->GetStringUTFChars(jManufacturerName, nullptr);
1558         }
1559         if (jManufacturerUrl)
1560         {
1561             manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, nullptr);
1562         }
1563         if (jModelNumber)
1564         {
1565             modelNumber = env->GetStringUTFChars(jModelNumber, nullptr);
1566         }
1567         if (jDateOfManufacture)
1568         {
1569             dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, nullptr);
1570         }
1571         if (jPlatformVersion)
1572         {
1573             platformVersion = env->GetStringUTFChars(jPlatformVersion, nullptr);
1574         }
1575         if (jOperatingSystemVersion)
1576         {
1577             operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, nullptr);
1578         }
1579         if (jHardwareVersion)
1580         {
1581             hardwareVersion = env->GetStringUTFChars(jHardwareVersion, nullptr);
1582         }
1583         if (jFirmwareVersion)
1584         {
1585             firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, nullptr);
1586         }
1587         if (jSupportUrl)
1588         {
1589             supportUrl = env->GetStringUTFChars(jSupportUrl, nullptr);
1590         }
1591         if (jSystemTime)
1592         {
1593             systemTime = env->GetStringUTFChars(jSystemTime, nullptr);
1594         }
1595
1596         OCPlatformInfo platformInfo;
1597         try
1598         {
1599             DuplicateString(&platformInfo.platformID, platformID);
1600             DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1601             DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1602             DuplicateString(&platformInfo.modelNumber, modelNumber);
1603             DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1604             DuplicateString(&platformInfo.platformVersion, platformVersion);
1605             DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1606             DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1607             DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1608             DuplicateString(&platformInfo.supportUrl, supportUrl);
1609             DuplicateString(&platformInfo.systemTime, systemTime);
1610         }
1611         catch (std::exception &e)
1612         {
1613             ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1614             return;
1615         }
1616
1617        // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID  = %s", platformID);
1618         try
1619         {
1620             OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1621
1622             delete platformInfo.platformID;
1623             delete platformInfo.manufacturerName;
1624             delete platformInfo.manufacturerUrl;
1625             delete platformInfo.modelNumber;
1626             delete platformInfo.dateOfManufacture;
1627             delete platformInfo.platformVersion;
1628             delete platformInfo.operatingSystemVersion;
1629             delete platformInfo.hardwareVersion;
1630             delete platformInfo.firmwareVersion;
1631             delete platformInfo.supportUrl;
1632             delete platformInfo.systemTime;
1633
1634             if (OC_STACK_OK != result)
1635             {
1636                 ThrowOcException(result, "Failed to register platform info");
1637                 return;
1638             }
1639         }
1640         catch (OCException& e)
1641         {
1642             LOGE("Error is due to %s", e.reason().c_str());
1643             ThrowOcException(e.code(), e.reason().c_str());
1644         }
1645 }
1646
1647 /*
1648 * Class:     org_iotivity_base_OcPlatform
1649 * Method:    unregisterResource0
1650 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1651 */
1652 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1653     JNIEnv *env, jclass clazz, jobject jResourceHandle)
1654 {
1655     LOGI("OcPlatform_unregisterResource");
1656     if (!jResourceHandle)
1657     {
1658         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1659         return;
1660     }
1661     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1662         env, jResourceHandle);
1663     if (!jniOcResourceHandle)
1664     {
1665         return;
1666     }
1667
1668     try
1669     {
1670         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1671         OCStackResult result = OCPlatform::unregisterResource(resHandle);
1672         if (OC_STACK_OK != result)
1673         {
1674             ThrowOcException(result, "Failed to unregister resource");
1675         }
1676     }
1677     catch (OCException& e)
1678     {
1679         LOGE("%s", e.reason().c_str());
1680         ThrowOcException(e.code(), e.reason().c_str());
1681     }
1682 }
1683
1684 /*
1685 * Class:     org_iotivity_base_OcPlatform
1686 * Method:    bindResource0
1687 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1688 */
1689 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1690 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1691 {
1692     LOGI("OcPlatform_bindResource");
1693     if (!jResourceCollectionHandle)
1694     {
1695         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1696         return;
1697     }
1698     if (!jResourceHandle)
1699     {
1700         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1701         return;
1702     }
1703     JniOcResourceHandle* jniOcResourceCollectionHandle =
1704         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1705     if (!jniOcResourceCollectionHandle)
1706     {
1707         return;
1708     }
1709
1710     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1711         env, jResourceHandle);
1712     if (!jniOcResourceHandle)
1713     {
1714         return;
1715     }
1716
1717     try
1718     {
1719         OCStackResult result = OCPlatform::bindResource(
1720             jniOcResourceCollectionHandle->getOCResourceHandle(),
1721             jniOcResourceHandle->getOCResourceHandle()
1722             );
1723
1724         if (OC_STACK_OK != result)
1725         {
1726             ThrowOcException(result, "Failed to bind resource");
1727         }
1728     }
1729     catch (OCException& e)
1730     {
1731         LOGE("%s", e.reason().c_str());
1732         ThrowOcException(e.code(), e.reason().c_str());
1733     }
1734 }
1735
1736 /*
1737 * Class:     org_iotivity_base_OcPlatform
1738 * Method:    bindResources0
1739 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1740 */
1741 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1742     JNIEnv *env,
1743     jclass clazz,
1744     jobject jResourceCollectionHandle,
1745     jobjectArray jResourceHandleArray)
1746 {
1747     LOGI("OcPlatform_bindResources");
1748
1749     if (!jResourceCollectionHandle)
1750     {
1751         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1752         return;
1753     }
1754     if (!jResourceHandleArray)
1755     {
1756         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1757         return;
1758     }
1759
1760     JniOcResourceHandle* jniOcResourceCollectionHandle =
1761         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1762     if (!jniOcResourceCollectionHandle)
1763     {
1764         return;
1765     }
1766
1767     std::vector<OCResourceHandle> resourceHandleList;
1768     int len = env->GetArrayLength(jResourceHandleArray);
1769     for (int i = 0; i < len; ++i)
1770     {
1771         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1772         if (!jResourceHandle)
1773         {
1774             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1775             return;
1776         }
1777
1778         JniOcResourceHandle* jniOcResourceHandle =
1779             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1780         if (!jniOcResourceHandle)
1781         {
1782             return;
1783         }
1784
1785         resourceHandleList.push_back(
1786             jniOcResourceHandle->getOCResourceHandle());
1787     }
1788
1789     try
1790     {
1791         OCStackResult result = OCPlatform::bindResources(
1792             jniOcResourceCollectionHandle->getOCResourceHandle(),
1793             resourceHandleList
1794             );
1795
1796         if (OC_STACK_OK != result)
1797         {
1798             ThrowOcException(result, "Failed to bind resources");
1799         }
1800     }
1801     catch (OCException& e)
1802     {
1803         LOGE("%s", e.reason().c_str());
1804         ThrowOcException(e.code(), e.reason().c_str());
1805     }
1806 }
1807
1808 /*
1809 * Class:     org_iotivity_base_OcPlatform
1810 * Method:    unbindResource0
1811 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1812 */
1813 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1814     JNIEnv *env,
1815     jclass clazz,
1816     jobject jResourceCollectionHandle,
1817     jobject jResourceHandle)
1818 {
1819     LOGI("OcPlatform_unbindResource");
1820     if (!jResourceCollectionHandle)
1821     {
1822         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1823         return;
1824     }
1825     if (!jResourceHandle)
1826     {
1827         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1828         return;
1829     }
1830
1831     JniOcResourceHandle* jniOcResourceCollectionHandle =
1832         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1833     if (!jniOcResourceCollectionHandle)
1834     {
1835         return;
1836     }
1837
1838     JniOcResourceHandle* jniOcResourceHandle =
1839         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1840     if (!jniOcResourceHandle)
1841     {
1842         return;
1843     }
1844
1845     try
1846     {
1847         OCStackResult result = OCPlatform::unbindResource(
1848             jniOcResourceCollectionHandle->getOCResourceHandle(),
1849             jniOcResourceHandle->getOCResourceHandle());
1850
1851         if (OC_STACK_OK != result)
1852         {
1853             ThrowOcException(result, "Failed to unbind resource");
1854         }
1855     }
1856     catch (OCException& e)
1857     {
1858         LOGE("%s", e.reason().c_str());
1859         ThrowOcException(e.code(), e.reason().c_str());
1860     }
1861 }
1862
1863 /*
1864 * Class:     org_iotivity_base_OcPlatform
1865 * Method:    unbindResources0
1866 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1867 */
1868 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
1869     JNIEnv *env,
1870     jclass clazz,
1871     jobject jResourceCollectionHandle,
1872     jobjectArray jResourceHandleArray)
1873 {
1874     LOGI("OcPlatform_unbindResources");
1875     if (!jResourceCollectionHandle)
1876     {
1877         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1878         return;
1879     }
1880     if (!jResourceHandleArray)
1881     {
1882         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1883         return;
1884     }
1885
1886     JniOcResourceHandle* jniOcResourceCollectionHandle =
1887         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1888     if (!jniOcResourceCollectionHandle)
1889     {
1890         return;
1891     }
1892
1893     std::vector<OCResourceHandle> resourceHandleList;
1894     int len = env->GetArrayLength(jResourceHandleArray);
1895     for (int i = 0; i < len; ++i)
1896     {
1897         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1898         if (!jResourceHandle)
1899         {
1900             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1901             return;
1902         }
1903
1904         JniOcResourceHandle* jniOcResourceHandle =
1905             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1906         if (!jniOcResourceHandle)
1907         {
1908             return;
1909         }
1910
1911         resourceHandleList.push_back(
1912             jniOcResourceHandle->getOCResourceHandle());
1913     }
1914
1915     try
1916     {
1917         OCStackResult result = OCPlatform::unbindResources(
1918             jniOcResourceCollectionHandle->getOCResourceHandle(),
1919             resourceHandleList
1920             );
1921
1922         if (OC_STACK_OK != result)
1923         {
1924             ThrowOcException(result, "Failed to unbind resources");
1925         }
1926     }
1927     catch (OCException& e)
1928     {
1929         LOGE("%s", e.reason().c_str());
1930         ThrowOcException(e.code(), e.reason().c_str());
1931     }
1932 }
1933
1934 /*
1935 * Class:     org_iotivity_base_OcPlatform
1936 * Method:    bindTypeToResource0
1937 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1938 */
1939 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
1940     JNIEnv *env,
1941     jclass clazz,
1942     jobject jResourceHandle,
1943     jstring jResourceTypeName)
1944 {
1945     LOGI("OcPlatform_bindTypeToResource");
1946     if (!jResourceHandle)
1947     {
1948         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1949         return;
1950     }
1951     std::string typeName;
1952     if (jResourceTypeName)
1953     {
1954         typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1955     }
1956
1957     JniOcResourceHandle* jniOcResourceHandle =
1958         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1959     if (!jniOcResourceHandle)
1960     {
1961         return;
1962     }
1963
1964     try
1965     {
1966         OCStackResult result = OCPlatform::bindTypeToResource(
1967             jniOcResourceHandle->getOCResourceHandle(),
1968             typeName
1969             );
1970
1971         if (OC_STACK_OK != result)
1972         {
1973             ThrowOcException(result, "Failed to bind type to resource");
1974         }
1975     }
1976     catch (OCException& e)
1977     {
1978         LOGE("%s", e.reason().c_str());
1979         ThrowOcException(e.code(), e.reason().c_str());
1980     }
1981 }
1982
1983 /*
1984 * Class:     org_iotivity_base_OcPlatform
1985 * Method:    bindInterfaceToResource0
1986 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1987 */
1988 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
1989 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
1990 {
1991     LOGI("OcPlatform_bindInterfaceToResource");
1992     if (!jResourceHandle)
1993     {
1994         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1995         return;
1996     }
1997     std::string interfaceName;
1998     if (jResourceInterfaceName)
1999     {
2000         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
2001     }
2002
2003     JniOcResourceHandle* jniOcResourceHandle =
2004         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2005     if (!jniOcResourceHandle)
2006     {
2007         return;
2008     }
2009
2010     try
2011     {
2012         OCStackResult result = OCPlatform::bindInterfaceToResource(
2013             jniOcResourceHandle->getOCResourceHandle(),
2014             interfaceName
2015             );
2016
2017         if (OC_STACK_OK != result)
2018         {
2019             ThrowOcException(result, "Failed to bind interface to resource");
2020         }
2021     }
2022     catch (OCException& e)
2023     {
2024         LOGE("%s", e.reason().c_str());
2025         ThrowOcException(e.code(), e.reason().c_str());
2026     }
2027 }
2028
2029 /*
2030 * Class:     org_iotivity_base_OcPlatform
2031 * Method:    startPresence0
2032 * Signature: (I)V
2033 */
2034 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
2035     JNIEnv *env, jclass clazz, jint ttl)
2036 {
2037     LOGI("OcPlatform_startPresence");
2038
2039     try
2040     {
2041         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
2042
2043         if (OC_STACK_OK != result)
2044         {
2045             ThrowOcException(result, "Failed to start presence");
2046         }
2047     }
2048     catch (OCException& e)
2049     {
2050         LOGE("%s", e.reason().c_str());
2051         ThrowOcException(e.code(), e.reason().c_str());
2052     }
2053 }
2054
2055 /*
2056 * Class:     org_iotivity_base_OcPlatform
2057 * Method:    stopPresence0
2058 * Signature: ()V
2059 */
2060 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
2061     JNIEnv *env, jclass clazz)
2062 {
2063     LOGI("OcPlatform_stopPresence");
2064
2065     try
2066     {
2067         OCStackResult result = OCPlatform::stopPresence();
2068
2069         if (OC_STACK_OK != result)
2070         {
2071             ThrowOcException(result, "Failed to stop presence");
2072         }
2073     }
2074     catch (OCException& e)
2075     {
2076         LOGE("%s", e.reason().c_str());
2077         ThrowOcException(e.code(), e.reason().c_str());
2078     }
2079 }
2080
2081 /*
2082 * Class:     org_iotivity_base_OcPlatform
2083 * Method:    subscribePresence0
2084 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2085 */
2086 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
2087     JNIEnv *env,
2088     jclass clazz,
2089     jstring jHost,
2090     jint jConnectivityType,
2091     jobject jListener)
2092 {
2093     LOGD("OcPlatform_subscribePresence");
2094     std::string host;
2095     if (jHost)
2096     {
2097         host = env->GetStringUTFChars(jHost, nullptr);
2098     }
2099     if (!jListener)
2100     {
2101         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2102         return nullptr;
2103     }
2104
2105     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2106
2107     SubscribeCallback subscribeCallback =
2108         [onPresenceListener](OCStackResult result,
2109                              const unsigned int nonce,
2110                              const std::string& hostAddress)
2111         {
2112             onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2113         };
2114
2115     OCPlatform::OCPresenceHandle presenceHandle;
2116     try
2117     {
2118         OCStackResult result = OCPlatform::subscribePresence(
2119             presenceHandle,
2120             host,
2121             static_cast<OCConnectivityType>(jConnectivityType),
2122             subscribeCallback);
2123
2124         if (OC_STACK_OK != result)
2125         {
2126             ThrowOcException(result, "subscribe presence has failed");
2127         }
2128     }
2129     catch (OCException& e)
2130     {
2131         LOGE("%s", e.reason().c_str());
2132         ThrowOcException(e.code(), e.reason().c_str());
2133         return nullptr;
2134     }
2135
2136     JniOcPresenceHandle* jniPresenceHandle =
2137         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2138     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2139     jobject jPresenceHandle =
2140         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2141     if (!jPresenceHandle)
2142     {
2143         LOGE("Failed to create OcPresenceHandle");
2144         delete jniPresenceHandle;
2145     }
2146     return jPresenceHandle;
2147 }
2148
2149 /*
2150 * Class:     org_iotivity_base_OcPlatform
2151 * Method:    subscribePresence1
2152 * Signature: (Ljava/lang/String;Ljava/lang/String;I
2153 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2154 */
2155 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
2156     JNIEnv *env,
2157     jclass clazz,
2158     jstring jHost,
2159     jstring jResourceType,
2160     jint jConnectivityType,
2161     jobject jListener)
2162 {
2163     LOGD("OcPlatform_subscribePresence1");
2164     std::string host;
2165     if (jHost)
2166     {
2167         host = env->GetStringUTFChars(jHost, nullptr);
2168     }
2169     std::string resourceType;
2170     if (jResourceType)
2171     {
2172         resourceType = env->GetStringUTFChars(jResourceType, nullptr);
2173     }
2174     if (!jListener)
2175     {
2176         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2177         return nullptr;
2178     }
2179
2180     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2181
2182     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
2183         const unsigned int nonce, const std::string& hostAddress)
2184     {
2185         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2186     };
2187
2188     OCPlatform::OCPresenceHandle presenceHandle;
2189     try
2190     {
2191         OCStackResult result = OCPlatform::subscribePresence(
2192             presenceHandle,
2193             host,
2194             resourceType,
2195             static_cast<OCConnectivityType>(jConnectivityType),
2196             subscribeCallback);
2197
2198         if (OC_STACK_OK != result)
2199         {
2200             ThrowOcException(result, "subscribe presence has failed");
2201         }
2202     }
2203     catch (OCException& e)
2204     {
2205         LOGE("%s", e.reason().c_str());
2206         ThrowOcException(e.code(), e.reason().c_str());
2207         return nullptr;
2208     }
2209
2210     JniOcPresenceHandle* jniPresenceHandle =
2211         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2212     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2213     jobject jPresenceHandle =
2214         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2215     if (!jPresenceHandle)
2216     {
2217         LOGE("Failed to create OcPresenceHandle");
2218         delete jniPresenceHandle;
2219     }
2220     return jPresenceHandle;
2221 }
2222
2223 /*
2224 * Class:     org_iotivity_base_OcPlatform
2225 * Method:    unsubscribePresence0
2226 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
2227 */
2228 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
2229     JNIEnv *env, jclass clazz, jobject jPresenceHandle)
2230 {
2231     LOGD("OcPlatform_unsubscribePresence");
2232     if (!jPresenceHandle)
2233     {
2234         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
2235         return;
2236     }
2237     JniOcPresenceHandle* jniPresenceHandle =
2238         JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
2239     if (!jniPresenceHandle)
2240     {
2241         return;
2242     }
2243
2244     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
2245
2246     try
2247     {
2248         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
2249
2250         if (OC_STACK_OK != result)
2251         {
2252             ThrowOcException(result, "unsubscribe presence has failed");
2253             return;
2254         }
2255
2256         JniOnPresenceListener* jniPresenceListener = jniPresenceHandle->getJniOnPresenceListener();
2257         if (jniPresenceListener)
2258         {
2259             jweak jwOnPresenceListener = jniPresenceListener->getJWListener();
2260             if (jwOnPresenceListener)
2261             {
2262                 RemoveOnPresenceListener(env, jwOnPresenceListener);
2263             }
2264         }
2265     }
2266     catch (OCException& e)
2267     {
2268         LOGE("%s", e.reason().c_str());
2269         ThrowOcException(e.code(), e.reason().c_str());
2270     }
2271 }
2272
2273 /*
2274 * Class:     org_iotivity_base_OcPlatform
2275 * Method:    subscribeDevicePresence0
2276 * Signature: (Ljava/lang/String;[Ljava/lang/String;I
2277 Lorg/iotivity/base/OcResource/OnObserveListener;)Lorg/iotivity/base/OcPresenceHandle;
2278 */
2279 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribeDevicePresence0(
2280     JNIEnv *env,
2281     jclass clazz,
2282     jstring jHost,
2283     jobjectArray jDiArray,
2284     jint jConnectivityType,
2285     jobject jListener)
2286 {
2287     LOGD("OcPlatform_subscribeDevicePresence0");
2288 #ifdef WITH_CLOUD
2289     std::string host;
2290     if (jHost)
2291     {
2292         host = env->GetStringUTFChars(jHost, nullptr);
2293     }
2294
2295     if (!jDiArray)
2296     {
2297         ThrowOcException(OC_STACK_INVALID_PARAM, "device id List cannot be null");
2298         return nullptr;
2299     }
2300
2301     std::vector<std::string> di;
2302     JniUtils::convertJavaStrArrToStrVector(env, jDiArray, di);
2303
2304     if (!jListener)
2305     {
2306         ThrowOcException(OC_STACK_INVALID_PARAM, "onObserveListener cannot be null");
2307         return nullptr;
2308     }
2309
2310     JniOnObserveListener *onObserveListener = AddOnObserveListener(env, jListener);
2311
2312     ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
2313         const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
2314     {
2315         onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
2316     };
2317
2318     OCPlatform::OCPresenceHandle presenceHandle;
2319     try
2320     {
2321         OCStackResult result = OCPlatform::subscribeDevicePresence(
2322             presenceHandle,
2323             host,
2324             di,
2325             static_cast<OCConnectivityType>(jConnectivityType),
2326             observeCallback);
2327
2328         if (OC_STACK_OK != result)
2329         {
2330             ThrowOcException(result, "subscribe device presence has failed");
2331         }
2332     }
2333     catch (OCException& e)
2334     {
2335         LOGE("%s", e.reason().c_str());
2336         ThrowOcException(e.code(), e.reason().c_str());
2337         return nullptr;
2338     }
2339
2340     JniOcPresenceHandle* jniPresenceHandle =
2341         new JniOcPresenceHandle(onObserveListener, presenceHandle);
2342     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2343     jobject jPresenceHandle =
2344         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2345     if (!jPresenceHandle)
2346     {
2347         LOGE("Failed to create OcPresenceHandle");
2348         delete jniPresenceHandle;
2349     }
2350     return jPresenceHandle;
2351 #else
2352     ThrowOcException(JNI_NO_SUPPORT, "Not supported");
2353     return nullptr;
2354 #endif
2355 }
2356
2357 /*
2358 * Class:     org_iotivity_base_OcPlatform
2359 * Method:    constructResourceObject0
2360 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
2361 Lorg/iotivity/base/OcResource;
2362 */
2363 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
2364     JNIEnv *env,
2365     jclass clazz,
2366     jstring jHost,
2367     jstring jUri,
2368     jint jConnectivityType,
2369     jboolean jIsObservable,
2370     jobjectArray jResourceTypeArray,
2371     jobjectArray jInterfaceArray)
2372 {
2373     LOGD("OcPlatform_constructResourceObject");
2374     std::string host;
2375     if (jHost)
2376     {
2377         host = env->GetStringUTFChars(jHost, nullptr);
2378     }
2379     std::string uri;
2380     if (jUri)
2381     {
2382         uri = env->GetStringUTFChars(jUri, nullptr);
2383     }
2384     if (!jResourceTypeArray)
2385     {
2386         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
2387         return nullptr;
2388     }
2389     if (!jInterfaceArray)
2390     {
2391         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
2392         return nullptr;
2393     }
2394
2395     std::vector<std::string> resourceTypes;
2396     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
2397
2398     std::vector<std::string> interfaces;
2399     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
2400
2401     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
2402         host,
2403         uri,
2404         static_cast<OCConnectivityType>(jConnectivityType),
2405         static_cast<bool>(jIsObservable),
2406         resourceTypes,
2407         interfaces);
2408
2409     if (!resource)
2410     {
2411         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
2412         return nullptr;
2413     }
2414
2415     JniOcResource *jniOcResource = new JniOcResource(resource);
2416
2417     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
2418     if (!jResource)
2419     {
2420         delete jniOcResource;
2421         return nullptr;
2422     }
2423     SetHandle<JniOcResource>(env, jResource, jniOcResource);
2424     if (env->ExceptionCheck())
2425     {
2426         delete jniOcResource;
2427         return nullptr;
2428     }
2429     return jResource;
2430 }
2431
2432 /*
2433 * Class:     org_iotivity_base_OcPlatform
2434 * Method:    sendResponse0
2435 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
2436 */
2437 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
2438     JNIEnv *env, jclass clazz, jobject jResourceResponse)
2439 {
2440     LOGD("OcPlatform_sendResponse");
2441     if (!jResourceResponse)
2442     {
2443         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
2444         return;
2445     }
2446
2447     JniOcResourceResponse *jniResponse =
2448         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
2449     if (!jniResponse)
2450     {
2451         return;
2452     }
2453
2454     try
2455     {
2456         OCStackResult result =
2457             OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
2458
2459         if (OC_STACK_OK != result)
2460         {
2461             ThrowOcException(result, "failed to send response");
2462         }
2463     }
2464     catch (OCException& e)
2465     {
2466         LOGE("%s", e.reason().c_str());
2467         ThrowOcException(e.code(), e.reason().c_str());
2468     }
2469 }
2470
2471 /*
2472 * Class:     org_iotivity_base_OcPlatform
2473 * Method:    constructAccountManagerObject0
2474 * Signature: (Ljava/lang/String;I)Lorg/iotivity/base/OcAccountManager;
2475 */
2476 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructAccountManagerObject0(
2477     JNIEnv *env,
2478     jclass clazz,
2479     jstring jHost,
2480     jint jConnectivityType)
2481 {
2482 #ifndef WITH_CLOUD
2483     ThrowOcException(OC_STACK_ERROR,
2484                      "OCAccountManager is not supported. (Please build with WITH_CLOUD=1 option)");
2485     return nullptr;
2486 #else
2487     LOGD("OcPlatform_constructAccountManagerObject");
2488     if (!jHost)
2489     {
2490         ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
2491         return nullptr;
2492     }
2493
2494     const char* charHost = env->GetStringUTFChars(jHost, nullptr);
2495     if (!charHost)
2496     {
2497         ThrowOcException(JNI_EXCEPTION, "charHost is null");
2498         return nullptr;
2499     }
2500     std::string host(charHost);
2501     env->ReleaseStringUTFChars(jHost, charHost);
2502
2503     std::shared_ptr<OCAccountManager> accountManager = OCPlatform::constructAccountManagerObject(
2504         host,
2505         static_cast<OCConnectivityType>(jConnectivityType));
2506
2507     if (!accountManager)
2508     {
2509         ThrowOcException(OC_STACK_ERROR, "Failed to create OCAccountManager");
2510         return nullptr;
2511     }
2512
2513     JniOcAccountManager *jniOcAccountManager = new JniOcAccountManager(accountManager);
2514
2515     jobject jAccountManager = env->NewObject(g_cls_OcAccountManager, g_mid_OcAccountManager_ctor);
2516     if (!jAccountManager)
2517     {
2518         delete jniOcAccountManager;
2519         return nullptr;
2520     }
2521     SetHandle<JniOcAccountManager>(env, jAccountManager, jniOcAccountManager);
2522     if (env->ExceptionCheck())
2523     {
2524         delete jniOcAccountManager;
2525         return nullptr;
2526     }
2527     return jAccountManager;
2528 #endif
2529 }
2530
2531 /*
2532 * Class:     org_iotivity_base_OcPlatform
2533 * Method:    getDeviceId
2534 * Signature: (I)V
2535 */
2536 JNIEXPORT jbyteArray JNICALL Java_org_iotivity_base_OcPlatform_getDeviceId
2537 (JNIEnv *env, jobject thiz)
2538 {
2539     LOGD("OcPlatform_getDeviceId");
2540     OCUUIdentity deviceId;
2541
2542     jbyteArray ret = env->NewByteArray(UUID_IDENTITY_SIZE);
2543     jbyte uuid[UUID_IDENTITY_SIZE];
2544     try
2545     {
2546
2547         OCStackResult result = OCPlatform::getDeviceId(&deviceId);
2548         LOGD("OcPlatform_getDeviceId return from CPP");
2549         if (OC_STACK_OK != result)
2550         {
2551             ThrowOcException(result, "Error while getting my device Id");
2552         }
2553         else
2554         {
2555             for(int i=0;i < UUID_IDENTITY_SIZE; i++)
2556             {
2557                 uuid[i] =(jbyte) deviceId.id[i];
2558             }
2559         }
2560
2561     }
2562     catch (OCException& e)
2563     {
2564         LOGE("%s", e.reason().c_str());
2565         ThrowOcException(e.code(), e.reason().c_str());
2566     }
2567
2568     env->SetByteArrayRegion(ret, 0, UUID_IDENTITY_SIZE, uuid);
2569
2570     return ret;
2571 }
2572
2573 /*
2574 * Class:     org_iotivity_base_OcPlatform
2575 * Method:    setDeviceId
2576 * Signature: (Ljava/lang/byte;)V
2577 */
2578 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_setDeviceId(
2579     JNIEnv *env, jobject thiz, jbyteArray data)
2580 {
2581     LOGI("OcPlatform_setDeviceId");
2582     OCUUIdentity deviceId;
2583     try
2584     {
2585         OCStackResult result;
2586         jbyte* uuid = env->GetByteArrayElements(data, 0);
2587         jsize arrayLength = env->GetArrayLength(data);
2588         if(arrayLength!=UUID_IDENTITY_SIZE)
2589         {
2590             ThrowOcException(OC_STACK_INVALID_PARAM, "Byte length not equal to UUID_IDENTITY_SIZE");
2591         }
2592         else
2593         {
2594             for(int i=0;i < UUID_IDENTITY_SIZE; i++)
2595             {
2596                 deviceId.id[i]=(jchar)uuid[i];
2597             }
2598             result = OCPlatform::setDeviceId(&deviceId);
2599             if (OC_STACK_OK != result)
2600             {
2601                 ThrowOcException(result, "Failed to set DeviceId");
2602             }
2603         }
2604     }
2605     catch (OCException& e)
2606     {
2607         LOGE("%s", e.reason().c_str());
2608         ThrowOcException(e.code(), e.reason().c_str());
2609     }
2610 }