android/android_api/base/jni/JniOcPlatform.cpp

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