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