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 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_setPropertyValue0
1648     (JNIEnv *env, jclass clazz, jint jType, jstring jPropName, jobjectArray jPropValue)
1649 {
1650     try
1651     {
1652         OCPayloadType type = (OCPayloadType)jType;
1653         std::string propName;
1654         std::vector<std::string> propValue;
1655         if (jPropName)
1656         {
1657             propName = env->GetStringUTFChars(jPropName, nullptr);
1658         }
1659         if (jPropValue)
1660         {
1661             JniUtils::convertJavaStrArrToStrVector(env, jPropValue, propValue);
1662         }
1663         OCStackResult result = OCPlatform::setPropertyValue(type, propName, propValue);
1664         if (OC_STACK_OK != result)
1665         {
1666             ThrowOcException(result, "Failed to set property");
1667             return;
1668         }
1669     }
1670     catch (OCException& e)
1671     {
1672         LOGE("Error is due to %s", e.reason().c_str());
1673         ThrowOcException(e.code(), e.reason().c_str());
1674     }
1675
1676 }
1677
1678 /*
1679 * Class:     org_iotivity_base_OcPlatform
1680 * Method:    setPropertyValue0
1681 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
1682 */
1683 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_setPropertyValue1
1684     (JNIEnv *env, jclass clazz, jint jType, jstring jPropName, jstring jPropValue)
1685 {
1686     try
1687     {
1688         OCPayloadType type = (OCPayloadType)jType;
1689         std::string propName;
1690         std::string propValue;
1691         if (jPropName)
1692         {
1693             propName = env->GetStringUTFChars(jPropName, nullptr);
1694         }
1695         if (jPropValue)
1696         {
1697             propValue = env->GetStringUTFChars(jPropValue, nullptr);
1698         }
1699         OCStackResult result = OCPlatform::setPropertyValue(type, propName, propValue);
1700         if (OC_STACK_OK != result)
1701         {
1702             ThrowOcException(result, "Failed to set property");
1703             return;
1704         }
1705     }
1706     catch (OCException& e)
1707     {
1708         LOGE("Error is due to %s", e.reason().c_str());
1709         ThrowOcException(e.code(), e.reason().c_str());
1710     }
1711 }
1712
1713 /*
1714 * Class:     org_iotivity_base_OcPlatform
1715 * Method:    getPropertyValue
1716 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
1717 */
1718 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPropertyValue0
1719     (JNIEnv *env, jclass clazz, jint jType, jstring jPropName, jstring jPropValue)
1720 {
1721     try
1722     {
1723         OCPayloadType type = (OCPayloadType) jType;
1724         std::string propName;
1725         std::string propValue;
1726
1727         if (jPropName)
1728         {
1729             propName = env->GetStringUTFChars(jPropName, nullptr);
1730         }
1731         OCStackResult result = OCPlatform::getPropertyValue(type, propName, propValue);
1732         if (OC_STACK_OK != result)
1733         {
1734             ThrowOcException(result, "Failed to get property value.");
1735             return;
1736         }
1737     }
1738     catch (OCException& e)
1739     {
1740         LOGE("Error is due to %s", e.reason().c_str());
1741         ThrowOcException(e.code(), e.reason().c_str());
1742     }
1743 }
1744
1745 /*
1746 * Class:     org_iotivity_base_OcPlatform
1747 * Method:    unregisterResource0
1748 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1749 */
1750 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1751     JNIEnv *env, jclass clazz, jobject jResourceHandle)
1752 {
1753     LOGI("OcPlatform_unregisterResource");
1754     if (!jResourceHandle)
1755     {
1756         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1757         return;
1758     }
1759     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1760         env, jResourceHandle);
1761     if (!jniOcResourceHandle)
1762     {
1763         return;
1764     }
1765
1766     try
1767     {
1768         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1769         OCStackResult result = OCPlatform::unregisterResource(resHandle);
1770         if (OC_STACK_OK != result)
1771         {
1772             ThrowOcException(result, "Failed to unregister resource");
1773         }
1774     }
1775     catch (OCException& e)
1776     {
1777         LOGE("%s", e.reason().c_str());
1778         ThrowOcException(e.code(), e.reason().c_str());
1779     }
1780 }
1781
1782 /*
1783 * Class:     org_iotivity_base_OcPlatform
1784 * Method:    bindResource0
1785 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1786 */
1787 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1788 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1789 {
1790     LOGI("OcPlatform_bindResource");
1791     if (!jResourceCollectionHandle)
1792     {
1793         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1794         return;
1795     }
1796     if (!jResourceHandle)
1797     {
1798         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1799         return;
1800     }
1801     JniOcResourceHandle* jniOcResourceCollectionHandle =
1802         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1803     if (!jniOcResourceCollectionHandle)
1804     {
1805         return;
1806     }
1807
1808     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1809         env, jResourceHandle);
1810     if (!jniOcResourceHandle)
1811     {
1812         return;
1813     }
1814
1815     try
1816     {
1817         OCStackResult result = OCPlatform::bindResource(
1818             jniOcResourceCollectionHandle->getOCResourceHandle(),
1819             jniOcResourceHandle->getOCResourceHandle()
1820             );
1821
1822         if (OC_STACK_OK != result)
1823         {
1824             ThrowOcException(result, "Failed to bind resource");
1825         }
1826     }
1827     catch (OCException& e)
1828     {
1829         LOGE("%s", e.reason().c_str());
1830         ThrowOcException(e.code(), e.reason().c_str());
1831     }
1832 }
1833
1834 /*
1835 * Class:     org_iotivity_base_OcPlatform
1836 * Method:    bindResources0
1837 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1838 */
1839 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1840     JNIEnv *env,
1841     jclass clazz,
1842     jobject jResourceCollectionHandle,
1843     jobjectArray jResourceHandleArray)
1844 {
1845     LOGI("OcPlatform_bindResources");
1846
1847     if (!jResourceCollectionHandle)
1848     {
1849         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1850         return;
1851     }
1852     if (!jResourceHandleArray)
1853     {
1854         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1855         return;
1856     }
1857
1858     JniOcResourceHandle* jniOcResourceCollectionHandle =
1859         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1860     if (!jniOcResourceCollectionHandle)
1861     {
1862         return;
1863     }
1864
1865     std::vector<OCResourceHandle> resourceHandleList;
1866     int len = env->GetArrayLength(jResourceHandleArray);
1867     for (int i = 0; i < len; ++i)
1868     {
1869         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1870         if (!jResourceHandle)
1871         {
1872             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1873             return;
1874         }
1875
1876         JniOcResourceHandle* jniOcResourceHandle =
1877             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1878         if (!jniOcResourceHandle)
1879         {
1880             return;
1881         }
1882
1883         resourceHandleList.push_back(
1884             jniOcResourceHandle->getOCResourceHandle());
1885     }
1886
1887     try
1888     {
1889         OCStackResult result = OCPlatform::bindResources(
1890             jniOcResourceCollectionHandle->getOCResourceHandle(),
1891             resourceHandleList
1892             );
1893
1894         if (OC_STACK_OK != result)
1895         {
1896             ThrowOcException(result, "Failed to bind resources");
1897         }
1898     }
1899     catch (OCException& e)
1900     {
1901         LOGE("%s", e.reason().c_str());
1902         ThrowOcException(e.code(), e.reason().c_str());
1903     }
1904 }
1905
1906 /*
1907 * Class:     org_iotivity_base_OcPlatform
1908 * Method:    unbindResource0
1909 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1910 */
1911 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1912     JNIEnv *env,
1913     jclass clazz,
1914     jobject jResourceCollectionHandle,
1915     jobject jResourceHandle)
1916 {
1917     LOGI("OcPlatform_unbindResource");
1918     if (!jResourceCollectionHandle)
1919     {
1920         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1921         return;
1922     }
1923     if (!jResourceHandle)
1924     {
1925         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1926         return;
1927     }
1928
1929     JniOcResourceHandle* jniOcResourceCollectionHandle =
1930         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1931     if (!jniOcResourceCollectionHandle)
1932     {
1933         return;
1934     }
1935
1936     JniOcResourceHandle* jniOcResourceHandle =
1937         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1938     if (!jniOcResourceHandle)
1939     {
1940         return;
1941     }
1942
1943     try
1944     {
1945         OCStackResult result = OCPlatform::unbindResource(
1946             jniOcResourceCollectionHandle->getOCResourceHandle(),
1947             jniOcResourceHandle->getOCResourceHandle());
1948
1949         if (OC_STACK_OK != result)
1950         {
1951             ThrowOcException(result, "Failed to unbind resource");
1952         }
1953     }
1954     catch (OCException& e)
1955     {
1956         LOGE("%s", e.reason().c_str());
1957         ThrowOcException(e.code(), e.reason().c_str());
1958     }
1959 }
1960
1961 /*
1962 * Class:     org_iotivity_base_OcPlatform
1963 * Method:    unbindResources0
1964 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1965 */
1966 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
1967     JNIEnv *env,
1968     jclass clazz,
1969     jobject jResourceCollectionHandle,
1970     jobjectArray jResourceHandleArray)
1971 {
1972     LOGI("OcPlatform_unbindResources");
1973     if (!jResourceCollectionHandle)
1974     {
1975         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1976         return;
1977     }
1978     if (!jResourceHandleArray)
1979     {
1980         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1981         return;
1982     }
1983
1984     JniOcResourceHandle* jniOcResourceCollectionHandle =
1985         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1986     if (!jniOcResourceCollectionHandle)
1987     {
1988         return;
1989     }
1990
1991     std::vector<OCResourceHandle> resourceHandleList;
1992     int len = env->GetArrayLength(jResourceHandleArray);
1993     for (int i = 0; i < len; ++i)
1994     {
1995         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1996         if (!jResourceHandle)
1997         {
1998             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1999             return;
2000         }
2001
2002         JniOcResourceHandle* jniOcResourceHandle =
2003             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2004         if (!jniOcResourceHandle)
2005         {
2006             return;
2007         }
2008
2009         resourceHandleList.push_back(
2010             jniOcResourceHandle->getOCResourceHandle());
2011     }
2012
2013     try
2014     {
2015         OCStackResult result = OCPlatform::unbindResources(
2016             jniOcResourceCollectionHandle->getOCResourceHandle(),
2017             resourceHandleList
2018             );
2019
2020         if (OC_STACK_OK != result)
2021         {
2022             ThrowOcException(result, "Failed to unbind resources");
2023         }
2024     }
2025     catch (OCException& e)
2026     {
2027         LOGE("%s", e.reason().c_str());
2028         ThrowOcException(e.code(), e.reason().c_str());
2029     }
2030 }
2031
2032 /*
2033 * Class:     org_iotivity_base_OcPlatform
2034 * Method:    bindTypeToResource0
2035 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
2036 */
2037 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
2038     JNIEnv *env,
2039     jclass clazz,
2040     jobject jResourceHandle,
2041     jstring jResourceTypeName)
2042 {
2043     LOGI("OcPlatform_bindTypeToResource");
2044     if (!jResourceHandle)
2045     {
2046         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
2047         return;
2048     }
2049     std::string typeName;
2050     if (jResourceTypeName)
2051     {
2052         typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
2053     }
2054
2055     JniOcResourceHandle* jniOcResourceHandle =
2056         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2057     if (!jniOcResourceHandle)
2058     {
2059         return;
2060     }
2061
2062     try
2063     {
2064         OCStackResult result = OCPlatform::bindTypeToResource(
2065             jniOcResourceHandle->getOCResourceHandle(),
2066             typeName
2067             );
2068
2069         if (OC_STACK_OK != result)
2070         {
2071             ThrowOcException(result, "Failed to bind type to resource");
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:    bindInterfaceToResource0
2084 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
2085 */
2086 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
2087 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
2088 {
2089     LOGI("OcPlatform_bindInterfaceToResource");
2090     if (!jResourceHandle)
2091     {
2092         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
2093         return;
2094     }
2095     std::string interfaceName;
2096     if (jResourceInterfaceName)
2097     {
2098         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
2099     }
2100
2101     JniOcResourceHandle* jniOcResourceHandle =
2102         JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2103     if (!jniOcResourceHandle)
2104     {
2105         return;
2106     }
2107
2108     try
2109     {
2110         OCStackResult result = OCPlatform::bindInterfaceToResource(
2111             jniOcResourceHandle->getOCResourceHandle(),
2112             interfaceName
2113             );
2114
2115         if (OC_STACK_OK != result)
2116         {
2117             ThrowOcException(result, "Failed to bind interface to resource");
2118         }
2119     }
2120     catch (OCException& e)
2121     {
2122         LOGE("%s", e.reason().c_str());
2123         ThrowOcException(e.code(), e.reason().c_str());
2124     }
2125 }
2126
2127 /*
2128 * Class:     org_iotivity_base_OcPlatform
2129 * Method:    startPresence0
2130 * Signature: (I)V
2131 */
2132 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
2133     JNIEnv *env, jclass clazz, jint ttl)
2134 {
2135     LOGI("OcPlatform_startPresence");
2136
2137     try
2138     {
2139         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
2140
2141         if (OC_STACK_OK != result)
2142         {
2143             ThrowOcException(result, "Failed to start presence");
2144         }
2145     }
2146     catch (OCException& e)
2147     {
2148         LOGE("%s", e.reason().c_str());
2149         ThrowOcException(e.code(), e.reason().c_str());
2150     }
2151 }
2152
2153 /*
2154 * Class:     org_iotivity_base_OcPlatform
2155 * Method:    stopPresence0
2156 * Signature: ()V
2157 */
2158 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
2159     JNIEnv *env, jclass clazz)
2160 {
2161     LOGI("OcPlatform_stopPresence");
2162
2163     try
2164     {
2165         OCStackResult result = OCPlatform::stopPresence();
2166
2167         if (OC_STACK_OK != result)
2168         {
2169             ThrowOcException(result, "Failed to stop presence");
2170         }
2171     }
2172     catch (OCException& e)
2173     {
2174         LOGE("%s", e.reason().c_str());
2175         ThrowOcException(e.code(), e.reason().c_str());
2176     }
2177 }
2178
2179 /*
2180 * Class:     org_iotivity_base_OcPlatform
2181 * Method:    subscribePresence0
2182 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2183 */
2184 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
2185     JNIEnv *env,
2186     jclass clazz,
2187     jstring jHost,
2188     jint jConnectivityType,
2189     jobject jListener)
2190 {
2191     LOGD("OcPlatform_subscribePresence");
2192     std::string host;
2193     if (jHost)
2194     {
2195         host = env->GetStringUTFChars(jHost, nullptr);
2196     }
2197     if (!jListener)
2198     {
2199         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2200         return nullptr;
2201     }
2202
2203     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2204
2205     SubscribeCallback subscribeCallback =
2206         [onPresenceListener](OCStackResult result,
2207                              const unsigned int nonce,
2208                              const std::string& hostAddress)
2209         {
2210             onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2211         };
2212
2213     OCPlatform::OCPresenceHandle presenceHandle;
2214     try
2215     {
2216         OCStackResult result = OCPlatform::subscribePresence(
2217             presenceHandle,
2218             host,
2219             static_cast<OCConnectivityType>(jConnectivityType),
2220             subscribeCallback);
2221
2222         if (OC_STACK_OK != result)
2223         {
2224             ThrowOcException(result, "subscribe presence has failed");
2225         }
2226     }
2227     catch (OCException& e)
2228     {
2229         LOGE("%s", e.reason().c_str());
2230         ThrowOcException(e.code(), e.reason().c_str());
2231         return nullptr;
2232     }
2233
2234     JniOcPresenceHandle* jniPresenceHandle =
2235         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2236     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2237     jobject jPresenceHandle =
2238         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2239     if (!jPresenceHandle)
2240     {
2241         LOGE("Failed to create OcPresenceHandle");
2242         delete jniPresenceHandle;
2243     }
2244     return jPresenceHandle;
2245 }
2246
2247 /*
2248 * Class:     org_iotivity_base_OcPlatform
2249 * Method:    subscribePresence1
2250 * Signature: (Ljava/lang/String;Ljava/lang/String;I
2251 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2252 */
2253 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
2254     JNIEnv *env,
2255     jclass clazz,
2256     jstring jHost,
2257     jstring jResourceType,
2258     jint jConnectivityType,
2259     jobject jListener)
2260 {
2261     LOGD("OcPlatform_subscribePresence1");
2262     std::string host;
2263     if (jHost)
2264     {
2265         host = env->GetStringUTFChars(jHost, nullptr);
2266     }
2267     std::string resourceType;
2268     if (jResourceType)
2269     {
2270         resourceType = env->GetStringUTFChars(jResourceType, nullptr);
2271     }
2272     if (!jListener)
2273     {
2274         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2275         return nullptr;
2276     }
2277
2278     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2279
2280     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
2281         const unsigned int nonce, const std::string& hostAddress)
2282     {
2283         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2284     };
2285
2286     OCPlatform::OCPresenceHandle presenceHandle;
2287     try
2288     {
2289         OCStackResult result = OCPlatform::subscribePresence(
2290             presenceHandle,
2291             host,
2292             resourceType,
2293             static_cast<OCConnectivityType>(jConnectivityType),
2294             subscribeCallback);
2295
2296         if (OC_STACK_OK != result)
2297         {
2298             ThrowOcException(result, "subscribe presence has failed");
2299         }
2300     }
2301     catch (OCException& e)
2302     {
2303         LOGE("%s", e.reason().c_str());
2304         ThrowOcException(e.code(), e.reason().c_str());
2305         return nullptr;
2306     }
2307
2308     JniOcPresenceHandle* jniPresenceHandle =
2309         new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2310     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2311     jobject jPresenceHandle =
2312         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2313     if (!jPresenceHandle)
2314     {
2315         LOGE("Failed to create OcPresenceHandle");
2316         delete jniPresenceHandle;
2317     }
2318     return jPresenceHandle;
2319 }
2320
2321 /*
2322 * Class:     org_iotivity_base_OcPlatform
2323 * Method:    unsubscribePresence0
2324 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
2325 */
2326 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
2327     JNIEnv *env, jclass clazz, jobject jPresenceHandle)
2328 {
2329     LOGD("OcPlatform_unsubscribePresence");
2330     if (!jPresenceHandle)
2331     {
2332         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
2333         return;
2334     }
2335     JniOcPresenceHandle* jniPresenceHandle =
2336         JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
2337     if (!jniPresenceHandle)
2338     {
2339         return;
2340     }
2341
2342     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
2343
2344     try
2345     {
2346         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
2347
2348         if (OC_STACK_OK != result)
2349         {
2350             ThrowOcException(result, "unsubscribe presence has failed");
2351             return;
2352         }
2353
2354         JniOnPresenceListener* jniPresenceListener = jniPresenceHandle->getJniOnPresenceListener();
2355         if (jniPresenceListener)
2356         {
2357             jweak jwOnPresenceListener = jniPresenceListener->getJWListener();
2358             if (jwOnPresenceListener)
2359             {
2360                 RemoveOnPresenceListener(env, jwOnPresenceListener);
2361             }
2362         }
2363     }
2364     catch (OCException& e)
2365     {
2366         LOGE("%s", e.reason().c_str());
2367         ThrowOcException(e.code(), e.reason().c_str());
2368     }
2369 }
2370
2371 /*
2372 * Class:     org_iotivity_base_OcPlatform
2373 * Method:    subscribeDevicePresence0
2374 * Signature: (Ljava/lang/String;[Ljava/lang/String;I
2375 Lorg/iotivity/base/OcResource/OnObserveListener;)Lorg/iotivity/base/OcPresenceHandle;
2376 */
2377 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribeDevicePresence0(
2378     JNIEnv *env,
2379     jclass clazz,
2380     jstring jHost,
2381     jobjectArray jDiArray,
2382     jint jConnectivityType,
2383     jobject jListener)
2384 {
2385     LOGD("OcPlatform_subscribeDevicePresence0");
2386 #ifdef WITH_CLOUD
2387     std::string host;
2388     if (jHost)
2389     {
2390         host = env->GetStringUTFChars(jHost, nullptr);
2391     }
2392
2393     if (!jDiArray)
2394     {
2395         ThrowOcException(OC_STACK_INVALID_PARAM, "device id List cannot be null");
2396         return nullptr;
2397     }
2398
2399     std::vector<std::string> di;
2400     JniUtils::convertJavaStrArrToStrVector(env, jDiArray, di);
2401
2402     if (!jListener)
2403     {
2404         ThrowOcException(OC_STACK_INVALID_PARAM, "onObserveListener cannot be null");
2405         return nullptr;
2406     }
2407
2408     JniOnObserveListener *onObserveListener = AddOnObserveListener(env, jListener);
2409
2410     ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
2411         const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
2412     {
2413         onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
2414     };
2415
2416     OCPlatform::OCPresenceHandle presenceHandle;
2417     try
2418     {
2419         OCStackResult result = OCPlatform::subscribeDevicePresence(
2420             presenceHandle,
2421             host,
2422             di,
2423             static_cast<OCConnectivityType>(jConnectivityType),
2424             observeCallback);
2425
2426         if (OC_STACK_OK != result)
2427         {
2428             ThrowOcException(result, "subscribe device presence has failed");
2429         }
2430     }
2431     catch (OCException& e)
2432     {
2433         LOGE("%s", e.reason().c_str());
2434         ThrowOcException(e.code(), e.reason().c_str());
2435         return nullptr;
2436     }
2437
2438     JniOcPresenceHandle* jniPresenceHandle =
2439         new JniOcPresenceHandle(onObserveListener, presenceHandle);
2440     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2441     jobject jPresenceHandle =
2442         env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2443     if (!jPresenceHandle)
2444     {
2445         LOGE("Failed to create OcPresenceHandle");
2446         delete jniPresenceHandle;
2447     }
2448     return jPresenceHandle;
2449 #else
2450     ThrowOcException(JNI_NO_SUPPORT, "Not supported");
2451     return nullptr;
2452 #endif
2453 }
2454
2455 /*
2456 * Class:     org_iotivity_base_OcPlatform
2457 * Method:    constructResourceObject0
2458 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
2459 Lorg/iotivity/base/OcResource;
2460 */
2461 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
2462     JNIEnv *env,
2463     jclass clazz,
2464     jstring jHost,
2465     jstring jUri,
2466     jint jConnectivityType,
2467     jboolean jIsObservable,
2468     jobjectArray jResourceTypeArray,
2469     jobjectArray jInterfaceArray)
2470 {
2471     LOGD("OcPlatform_constructResourceObject");
2472     std::string host;
2473     if (jHost)
2474     {
2475         host = env->GetStringUTFChars(jHost, nullptr);
2476     }
2477     std::string uri;
2478     if (jUri)
2479     {
2480         uri = env->GetStringUTFChars(jUri, nullptr);
2481     }
2482     if (!jResourceTypeArray)
2483     {
2484         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
2485         return nullptr;
2486     }
2487     if (!jInterfaceArray)
2488     {
2489         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
2490         return nullptr;
2491     }
2492
2493     std::vector<std::string> resourceTypes;
2494     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
2495
2496     std::vector<std::string> interfaces;
2497     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
2498
2499     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
2500         host,
2501         uri,
2502         static_cast<OCConnectivityType>(jConnectivityType),
2503         static_cast<bool>(jIsObservable),
2504         resourceTypes,
2505         interfaces);
2506
2507     if (!resource)
2508     {
2509         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
2510         return nullptr;
2511     }
2512
2513     JniOcResource *jniOcResource = new JniOcResource(resource);
2514
2515     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
2516     if (!jResource)
2517     {
2518         delete jniOcResource;
2519         return nullptr;
2520     }
2521     SetHandle<JniOcResource>(env, jResource, jniOcResource);
2522     if (env->ExceptionCheck())
2523     {
2524         delete jniOcResource;
2525         return nullptr;
2526     }
2527     return jResource;
2528 }
2529
2530 /*
2531 * Class:     org_iotivity_base_OcPlatform
2532 * Method:    sendResponse0
2533 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
2534 */
2535 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
2536     JNIEnv *env, jclass clazz, jobject jResourceResponse)
2537 {
2538     LOGD("OcPlatform_sendResponse");
2539     if (!jResourceResponse)
2540     {
2541         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
2542         return;
2543     }
2544
2545     JniOcResourceResponse *jniResponse =
2546         JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
2547     if (!jniResponse)
2548     {
2549         return;
2550     }
2551
2552     try
2553     {
2554         OCStackResult result =
2555             OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
2556
2557         if (OC_STACK_OK != result)
2558         {
2559             ThrowOcException(result, "failed to send response");
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
2569 /*
2570 * Class:     org_iotivity_base_OcPlatform
2571 * Method:    constructAccountManagerObject0
2572 * Signature: (Ljava/lang/String;I)Lorg/iotivity/base/OcAccountManager;
2573 */
2574 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructAccountManagerObject0(
2575     JNIEnv *env,
2576     jclass clazz,
2577     jstring jHost,
2578     jint jConnectivityType)
2579 {
2580 #ifndef WITH_CLOUD
2581     ThrowOcException(OC_STACK_ERROR,
2582                      "OCAccountManager is not supported. (Please build with WITH_CLOUD=1 option)");
2583     return nullptr;
2584 #else
2585     LOGD("OcPlatform_constructAccountManagerObject");
2586     if (!jHost)
2587     {
2588         ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
2589         return nullptr;
2590     }
2591
2592     const char* charHost = env->GetStringUTFChars(jHost, nullptr);
2593     if (!charHost)
2594     {
2595         ThrowOcException(JNI_EXCEPTION, "charHost is null");
2596         return nullptr;
2597     }
2598     std::string host(charHost);
2599     env->ReleaseStringUTFChars(jHost, charHost);
2600
2601     std::shared_ptr<OCAccountManager> accountManager = OCPlatform::constructAccountManagerObject(
2602         host,
2603         static_cast<OCConnectivityType>(jConnectivityType));
2604
2605     if (!accountManager)
2606     {
2607         ThrowOcException(OC_STACK_ERROR, "Failed to create OCAccountManager");
2608         return nullptr;
2609     }
2610
2611     JniOcAccountManager *jniOcAccountManager = new JniOcAccountManager(accountManager);
2612
2613     jobject jAccountManager = env->NewObject(g_cls_OcAccountManager, g_mid_OcAccountManager_ctor);
2614     if (!jAccountManager)
2615     {
2616         delete jniOcAccountManager;
2617         return nullptr;
2618     }
2619     SetHandle<JniOcAccountManager>(env, jAccountManager, jniOcAccountManager);
2620     if (env->ExceptionCheck())
2621     {
2622         delete jniOcAccountManager;
2623         return nullptr;
2624     }
2625     return jAccountManager;
2626 #endif
2627 }
2628
2629 /*
2630 * Class:     org_iotivity_base_OcPlatform
2631 * Method:    getDeviceId
2632 * Signature: (I)V
2633 */
2634 JNIEXPORT jbyteArray JNICALL Java_org_iotivity_base_OcPlatform_getDeviceId
2635 (JNIEnv *env, jobject thiz)
2636 {
2637     LOGD("OcPlatform_getDeviceId");
2638     OCUUIdentity deviceId;
2639
2640     jbyteArray ret = env->NewByteArray(UUID_IDENTITY_SIZE);
2641     jbyte uuid[UUID_IDENTITY_SIZE];
2642     try
2643     {
2644
2645         OCStackResult result = OCPlatform::getDeviceId(&deviceId);
2646         LOGD("OcPlatform_getDeviceId return from CPP");
2647         if (OC_STACK_OK != result)
2648         {
2649             ThrowOcException(result, "Error while getting my device Id");
2650         }
2651         else
2652         {
2653             for(int i=0;i < UUID_IDENTITY_SIZE; i++)
2654             {
2655                 uuid[i] =(jbyte) deviceId.id[i];
2656             }
2657         }
2658
2659     }
2660     catch (OCException& e)
2661     {
2662         LOGE("%s", e.reason().c_str());
2663         ThrowOcException(e.code(), e.reason().c_str());
2664     }
2665
2666     env->SetByteArrayRegion(ret, 0, UUID_IDENTITY_SIZE, uuid);
2667
2668     return ret;
2669 }
2670
2671 /*
2672 * Class:     org_iotivity_base_OcPlatform
2673 * Method:    setDeviceId
2674 * Signature: (Ljava/lang/byte;)V
2675 */
2676 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_setDeviceId(
2677     JNIEnv *env, jobject thiz, jbyteArray data)
2678 {
2679     LOGI("OcPlatform_setDeviceId");
2680     OCUUIdentity deviceId;
2681     try
2682     {
2683         OCStackResult result;
2684         jbyte* uuid = env->GetByteArrayElements(data, 0);
2685         jsize arrayLength = env->GetArrayLength(data);
2686         if(arrayLength!=UUID_IDENTITY_SIZE)
2687         {
2688             ThrowOcException(OC_STACK_INVALID_PARAM, "Byte length not equal to UUID_IDENTITY_SIZE");
2689         }
2690         else
2691         {
2692             for(int i=0;i < UUID_IDENTITY_SIZE; i++)
2693             {
2694                 deviceId.id[i]=(jchar)uuid[i];
2695             }
2696             result = OCPlatform::setDeviceId(&deviceId);
2697             if (OC_STACK_OK != result)
2698             {
2699                 ThrowOcException(result, "Failed to set DeviceId");
2700             }
2701         }
2702     }
2703     catch (OCException& e)
2704     {
2705         LOGE("%s", e.reason().c_str());
2706         ThrowOcException(e.code(), e.reason().c_str());
2707     }
2708 }