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             JniUtils::getConnectivityType(env, static_cast<int>(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             JniUtils::getConnectivityType(env, static_cast<int>(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             JniUtils::getConnectivityType(env, static_cast<int>(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             JniUtils::getConnectivityType(env, static_cast<int>(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             JniUtils::getConnectivityType(env, static_cast<int>(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             JniUtils::getConnectivityType(env, static_cast<int>(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     LOGD("OcPlatform_registerResource1");
 873     OCResourceHandle resourceHandle;
 874     try
 875     {
 876         LOGD("OcPlatform_registerResource2");
 877         OCStackResult result = OCPlatform::registerResource(
 878             resourceHandle,
 879             resource->getOCResource());
 880         LOGD("OcPlatform_registerResource3");
 881
 882         if (OC_STACK_OK != result)
 883         {
 884             ThrowOcException(result, "register resource");
 885         }
 886     }
 887     catch (OCException& e)
 888     {
 889         LOGE("%s", e.reason().c_str());
 890         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 891         return nullptr;
 892     }
 893     LOGD("OcPlatform_registerResource4");
 894     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
 895     jlong handle = reinterpret_cast<jlong>(jniHandle);
 896     jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
 897     LOGD("OcPlatform_registerResource5");
 898     if (!jResourceHandle)
 899     {
 900         LOGE("Failed to create OcResourceHandle");
 901         delete jniHandle;
 902     }
 903     return jResourceHandle;
 904 }
 905
 906 /*
 907 * Class:     org_iotivity_base_OcPlatform
 908 * Method:    registerResource1
 909 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
 910 */
 911 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1
 912 (JNIEnv *env, jclass clazz, jstring jResourceUri, jstring jResourceTypeName, jstring jResourceInterface,
 913 jobject jListener, jint jResourceProperty)
 914 {
 915     LOGI("OcPlatform_registerResource1");
 916     std::string resourceUri;
 917     if (jResourceUri)
 918     {
 919         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
 920     }
 921     std::string resourceTypeName;
 922     if (jResourceTypeName)
 923     {
 924         resourceTypeName = env->GetStringUTFChars(jResourceTypeName, NULL);
 925     }
 926     std::string resourceInterface;
 927     if (jResourceInterface)
 928     {
 929         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
 930     }
 931     if (!jListener)
 932     {
 933         ThrowOcException(OC_STACK_INVALID_PARAM, "entityHandler cannot be null");
 934         return nullptr;
 935     }
 936     JniEntityHandler* entityHandler = new JniEntityHandler(env, jListener);
 937     EntityHandler handleEntityCallback = [entityHandler](const std::shared_ptr<OCResourceRequest> request) ->
 938         OCEntityHandlerResult{
 939         return entityHandler->handleEntity(request);
 940     };
 941
 942     OCResourceHandle resourceHandle;
 943     try
 944     {
 945         OCStackResult result = OCPlatform::registerResource(
 946             resourceHandle,
 947             resourceUri,
 948             resourceTypeName,
 949             resourceInterface,
 950             handleEntityCallback,
 951             static_cast<int>(jResourceProperty));
 952
 953         if (OC_STACK_OK != result)
 954         {
 955             delete entityHandler;
 956             ThrowOcException(result, "register resource");
 957             return nullptr;
 958         }
 959     }
 960     catch (OCException& e)
 961     {
 962         LOGE("%s", e.reason().c_str());
 963         delete entityHandler;
 964         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 965         return nullptr;
 966     }
 967
 968     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
 969     jlong handle = reinterpret_cast<jlong>(jniHandle);
 970     jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
 971     if (!jResourceHandle)
 972     {
 973         LOGE("Failed to create OcResourceHandle");
 974         delete jniHandle;
 975     }
 976
 977     return jResourceHandle;
 978 }
 979
 980 /*
 981 * Class:     org_iotivity_base_OcPlatform
 982 * Method:    registerDeviceInfo0
 983 * 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
 984 */
 985 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0
 986 (JNIEnv *env,
 987 jclass clazz,
 988 jstring jDeviceName)
 989 {
 990     LOGI("OcPlatform_registerDeviceInfo");
 991
 992     std::string deviceName;
 993     if (jDeviceName)
 994     {
 995         deviceName = env->GetStringUTFChars(jDeviceName, NULL);
 996     }
 997
 998     OCDeviceInfo deviceInfo;
 999     try
1000     {
1001         DuplicateString(&deviceInfo.deviceName, deviceName);
1002     }
1003     catch (std::exception &e)
1004     {
1005         ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1006         return;
1007     }
1008
1009     try
1010     {
1011         OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1012
1013         delete deviceInfo.deviceName;
1014
1015         if (OC_STACK_OK != result)
1016         {
1017             ThrowOcException(result, "Failed to register device info");
1018             return;
1019         }
1020     }
1021     catch (OCException& e)
1022     {
1023         LOGE("%s", e.reason().c_str());
1024         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1025     }
1026 }
1027
1028 /*
1029 * Class:     org_iotivity_base_OcPlatform
1030 * Method:    registerPlatformInfo0
1031 * 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
1032 */
1033 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0
1034 (JNIEnv *env,
1035 jclass clazz,
1036 jstring jPlatformID,
1037 jstring jManufacturerName,
1038 jstring jManufacturerUrl,
1039 jstring jModelNumber,
1040 jstring jDateOfManufacture,
1041 jstring jPlatformVersion,
1042 jstring jOperatingSystemVersion,
1043 jstring jHardwareVersion,
1044 jstring jFirmwareVersion,
1045 jstring jSupportUrl,
1046 jstring jSystemTime)
1047 {
1048     LOGI("OcPlatform_registerPlatformInfo");
1049
1050
1051     std::string platformID;
1052         std::string manufacturerName;
1053         std::string manufacturerUrl;
1054         std::string modelNumber;
1055         std::string dateOfManufacture;
1056         std::string platformVersion;
1057         std::string operatingSystemVersion;
1058         std::string hardwareVersion;
1059         std::string firmwareVersion;
1060         std::string supportUrl;
1061         std::string systemTime;
1062
1063         if (jPlatformID)
1064         {
1065             platformID = env->GetStringUTFChars(jPlatformID, NULL);
1066         }
1067         if (jManufacturerName)
1068         {
1069             manufacturerName = env->GetStringUTFChars(jManufacturerName, NULL);
1070         }
1071         if (jManufacturerUrl)
1072         {
1073             manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, NULL);
1074         }
1075         if (jModelNumber)
1076         {
1077             modelNumber = env->GetStringUTFChars(jModelNumber, NULL);
1078         }
1079         if (jDateOfManufacture)
1080         {
1081             dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, NULL);
1082         }
1083         if (jPlatformVersion)
1084         {
1085             platformVersion = env->GetStringUTFChars(jPlatformVersion, NULL);
1086         }
1087         if (jOperatingSystemVersion)
1088         {
1089             operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, NULL);
1090         }
1091         if (jHardwareVersion)
1092         {
1093             hardwareVersion = env->GetStringUTFChars(jHardwareVersion, NULL);
1094         }
1095         if (jFirmwareVersion)
1096         {
1097             firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, NULL);
1098         }
1099         if (jSupportUrl)
1100         {
1101             supportUrl = env->GetStringUTFChars(jSupportUrl, NULL);
1102         }
1103         if (jSystemTime)
1104         {
1105             systemTime = env->GetStringUTFChars(jSystemTime, NULL);
1106         }
1107
1108         OCPlatformInfo platformInfo;
1109         try
1110         {
1111             DuplicateString(&platformInfo.platformID, platformID);
1112             DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1113             DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1114             DuplicateString(&platformInfo.modelNumber, modelNumber);
1115             DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1116             DuplicateString(&platformInfo.platformVersion, platformVersion);
1117             DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1118             DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1119             DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1120             DuplicateString(&platformInfo.supportUrl, supportUrl);
1121             DuplicateString(&platformInfo.systemTime, systemTime);
1122         }
1123         catch (std::exception &e)
1124         {
1125             ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1126             return;
1127         }
1128
1129        // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID  = %s", platformID);
1130         try
1131         {
1132             OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1133
1134             delete platformInfo.platformID;
1135             delete platformInfo.manufacturerName;
1136             delete platformInfo.manufacturerUrl;
1137             delete platformInfo.modelNumber;
1138             delete platformInfo.dateOfManufacture;
1139             delete platformInfo.platformVersion;
1140             delete platformInfo.operatingSystemVersion;
1141             delete platformInfo.hardwareVersion;
1142             delete platformInfo.firmwareVersion;
1143             delete platformInfo.supportUrl;
1144             delete platformInfo.systemTime;
1145
1146             if (OC_STACK_OK != result)
1147             {
1148                 ThrowOcException(result, "Failed to register platform info");
1149                 return;
1150             }
1151         }
1152         catch (OCException& e)
1153         {
1154             LOGE("Error is due to %s", e.reason().c_str());
1155             ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1156         }
1157
1158
1159
1160 }
1161
1162 /*
1163 * Class:     org_iotivity_base_OcPlatform
1164 * Method:    unregisterResource0
1165 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1166 */
1167 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0
1168 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
1169 {
1170     LOGI("OcPlatform_unregisterResource");
1171     if (!jResourceHandle)
1172     {
1173         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1174         return;
1175     }
1176     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1177         env, jResourceHandle);
1178     if (!jniOcResourceHandle) return;
1179
1180     try
1181     {
1182         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1183         OCStackResult result = OCPlatform::unregisterResource(resHandle);
1184         if (OC_STACK_OK != result)
1185         {
1186             ThrowOcException(result, "Failed to unregister resource");
1187         }
1188     }
1189     catch (OCException& e)
1190     {
1191         LOGE("%s", e.reason().c_str());
1192         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1193     }
1194 }
1195
1196 /*
1197 * Class:     org_iotivity_base_OcPlatform
1198 * Method:    bindResource0
1199 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1200 */
1201 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1202 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1203 {
1204     LOGI("OcPlatform_bindResource");
1205     if (!jResourceCollectionHandle)
1206     {
1207         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1208         return;
1209     }
1210     if (!jResourceHandle)
1211     {
1212         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1213         return;
1214     }
1215     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1216         env, jResourceCollectionHandle);
1217     if (!jniOcResourceCollectionHandle) return;
1218
1219     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1220         env, jResourceHandle);
1221     if (!jniOcResourceHandle) return;
1222
1223     try
1224     {
1225         OCStackResult result = OCPlatform::bindResource(
1226             jniOcResourceCollectionHandle->getOCResourceHandle(),
1227             jniOcResourceHandle->getOCResourceHandle()
1228             );
1229
1230         if (OC_STACK_OK != result)
1231         {
1232             ThrowOcException(result, "Failed to bind resource");
1233         }
1234     }
1235     catch (OCException& e)
1236     {
1237         LOGE("%s", e.reason().c_str());
1238         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1239     }
1240 }
1241
1242 /*
1243 * Class:     org_iotivity_base_OcPlatform
1244 * Method:    bindResources0
1245 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1246 */
1247 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0
1248 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
1249 {
1250     LOGI("OcPlatform_bindResources");
1251
1252     if (!jResourceCollectionHandle)
1253     {
1254         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1255         return;
1256     }
1257     if (!jResourceHandleArray)
1258     {
1259         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1260         return;
1261     }
1262
1263     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1264         env, jResourceCollectionHandle);
1265     if (!jniOcResourceCollectionHandle) return;
1266
1267     std::vector<OCResourceHandle> resourceHandleList;
1268     int len = env->GetArrayLength(jResourceHandleArray);
1269     for (int i = 0; i < len; ++i)
1270     {
1271         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1272         if (!jResourceHandle)
1273         {
1274             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1275             return;
1276         }
1277
1278         JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1279             env, jResourceHandle);
1280         if (!jniOcResourceHandle) return;
1281
1282         resourceHandleList.push_back(
1283             jniOcResourceHandle->getOCResourceHandle());
1284     }
1285
1286     try
1287     {
1288         OCStackResult result = OCPlatform::bindResources(
1289             jniOcResourceCollectionHandle->getOCResourceHandle(),
1290             resourceHandleList
1291             );
1292
1293         if (OC_STACK_OK != result)
1294         {
1295             ThrowOcException(result, "Failed to bind resources");
1296         }
1297     }
1298     catch (OCException& e)
1299     {
1300         LOGE("%s", e.reason().c_str());
1301         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1302     }
1303 }
1304
1305 /*
1306 * Class:     org_iotivity_base_OcPlatform
1307 * Method:    unbindResource0
1308 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1309 */
1310 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0
1311 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1312 {
1313     LOGI("OcPlatform_unbindResource");
1314     if (!jResourceCollectionHandle)
1315     {
1316         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1317         return;
1318     }
1319     if (!jResourceHandle)
1320     {
1321         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1322         return;
1323     }
1324
1325     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1326         env, jResourceCollectionHandle);
1327     if (!jniOcResourceCollectionHandle) return;
1328
1329     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1330         env, jResourceHandle);
1331     if (!jniOcResourceHandle) return;
1332
1333     try
1334     {
1335         OCStackResult result = OCPlatform::unbindResource(
1336             jniOcResourceCollectionHandle->getOCResourceHandle(),
1337             jniOcResourceHandle->getOCResourceHandle()
1338             );
1339
1340         if (OC_STACK_OK != result)
1341         {
1342             ThrowOcException(result, "Failed to unbind resource");
1343         }
1344     }
1345     catch (OCException& e)
1346     {
1347         LOGE("%s", e.reason().c_str());
1348         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1349     }
1350 }
1351
1352 /*
1353 * Class:     org_iotivity_base_OcPlatform
1354 * Method:    unbindResources0
1355 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1356 */
1357 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0
1358 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
1359 {
1360     LOGI("OcPlatform_unbindResources");
1361     if (!jResourceCollectionHandle)
1362     {
1363         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1364         return;
1365     }
1366     if (!jResourceHandleArray)
1367     {
1368         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1369         return;
1370     }
1371
1372     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1373         env, jResourceCollectionHandle);
1374     if (!jniOcResourceCollectionHandle) return;
1375
1376     std::vector<OCResourceHandle> resourceHandleList;
1377     int len = env->GetArrayLength(jResourceHandleArray);
1378     for (int i = 0; i < len; ++i)
1379     {
1380         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1381         if (!jResourceHandle)
1382         {
1383             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1384             return;
1385         }
1386
1387         JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1388             env, jResourceHandle);
1389         if (!jniOcResourceHandle) return;
1390
1391         resourceHandleList.push_back(
1392             jniOcResourceHandle->getOCResourceHandle());
1393     }
1394
1395     try
1396     {
1397         OCStackResult result = OCPlatform::unbindResources(
1398             jniOcResourceCollectionHandle->getOCResourceHandle(),
1399             resourceHandleList
1400             );
1401
1402         if (OC_STACK_OK != result)
1403         {
1404             ThrowOcException(result, "Failed to unbind resources");
1405         }
1406     }
1407     catch (OCException& e)
1408     {
1409         LOGE("%s", e.reason().c_str());
1410         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1411     }
1412 }
1413
1414 /*
1415 * Class:     org_iotivity_base_OcPlatform
1416 * Method:    bindTypeToResource0
1417 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1418 */
1419 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0
1420 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceTypeName)
1421 {
1422     LOGI("OcPlatform_bindTypeToResource");
1423     if (!jResourceHandle)
1424     {
1425         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1426         return;
1427     }
1428     std::string typeName;
1429     if (jResourceTypeName)
1430     {
1431         typeName = env->GetStringUTFChars(jResourceTypeName, NULL);
1432     }
1433
1434     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1435         env, jResourceHandle);
1436     if (!jniOcResourceHandle) return;
1437
1438     try
1439     {
1440         OCStackResult result = OCPlatform::bindTypeToResource(
1441             jniOcResourceHandle->getOCResourceHandle(),
1442             typeName
1443             );
1444
1445         if (OC_STACK_OK != result)
1446         {
1447             ThrowOcException(result, "Failed to bind type to resource");
1448         }
1449     }
1450     catch (OCException& e)
1451     {
1452         LOGE("%s", e.reason().c_str());
1453         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1454     }
1455 }
1456
1457 /*
1458 * Class:     org_iotivity_base_OcPlatform
1459 * Method:    bindInterfaceToResource0
1460 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1461 */
1462 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
1463 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
1464 {
1465     LOGI("OcPlatform_bindInterfaceToResource");
1466     if (!jResourceHandle)
1467     {
1468         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1469         return;
1470     }
1471     std::string interfaceName;
1472     if (jResourceInterfaceName)
1473     {
1474         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, NULL);
1475     }
1476
1477     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1478         env, jResourceHandle);
1479     if (!jniOcResourceHandle) return;
1480
1481     try
1482     {
1483         OCStackResult result = OCPlatform::bindInterfaceToResource(
1484             jniOcResourceHandle->getOCResourceHandle(),
1485             interfaceName
1486             );
1487
1488         if (OC_STACK_OK != result)
1489         {
1490             ThrowOcException(result, "Failed to bind interface to resource");
1491         }
1492     }
1493     catch (OCException& e)
1494     {
1495         LOGE("%s", e.reason().c_str());
1496         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1497     }
1498 }
1499
1500 /*
1501 * Class:     org_iotivity_base_OcPlatform
1502 * Method:    startPresence0
1503 * Signature: (I)V
1504 */
1505 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0
1506 (JNIEnv *env, jclass clazz, jint ttl)
1507 {
1508     LOGI("OcPlatform_startPresence");
1509
1510     try
1511     {
1512         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
1513
1514         if (OC_STACK_OK != result)
1515         {
1516             ThrowOcException(result, "Failed to start presence");
1517         }
1518     }
1519     catch (OCException& e)
1520     {
1521         LOGE("%s", e.reason().c_str());
1522         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1523     }
1524 }
1525
1526 /*
1527 * Class:     org_iotivity_base_OcPlatform
1528 * Method:    stopPresence0
1529 * Signature: ()V
1530 */
1531 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0
1532 (JNIEnv *env, jclass clazz)
1533 {
1534     LOGI("OcPlatform_stopPresence");
1535
1536     try
1537     {
1538         OCStackResult result = OCPlatform::stopPresence();
1539
1540         if (OC_STACK_OK != result)
1541         {
1542             ThrowOcException(result, "Failed to stop presence");
1543         }
1544     }
1545     catch (OCException& e)
1546     {
1547         LOGE("%s", e.reason().c_str());
1548         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1549     }
1550 }
1551
1552 /*
1553 * Class:     org_iotivity_base_OcPlatform
1554 * Method:    subscribePresence0
1555 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
1556 */
1557 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0
1558 (JNIEnv *env, jclass clazz, jstring jHost, jint jConnectivityType, jobject jListener)
1559 {
1560     LOGD("OcPlatform_subscribePresence");
1561     std::string host;
1562     if (jHost)
1563     {
1564         host = env->GetStringUTFChars(jHost, NULL);
1565     }
1566     if (!jListener)
1567     {
1568         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
1569         return nullptr;
1570     }
1571
1572     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
1573
1574     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result, const unsigned int nonce,
1575         const std::string& hostAddress)
1576     {
1577         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
1578     };
1579
1580     OCPlatform::OCPresenceHandle presenceHandle;
1581     try
1582     {
1583         OCStackResult result = OCPlatform::subscribePresence(
1584             presenceHandle,
1585             host,
1586             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
1587             subscribeCallback);
1588
1589         if (OC_STACK_OK != result)
1590         {
1591             ThrowOcException(result, "subscribe presence has failed");
1592         }
1593     }
1594     catch (OCException& e)
1595     {
1596         LOGE("%s", e.reason().c_str());
1597         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1598         return nullptr;
1599     }
1600
1601     JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
1602     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
1603     jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
1604     if (!jPresenceHandle)
1605     {
1606         LOGE("Failed to create OcPresenceHandle");
1607         delete jniPresenceHandle;
1608     }
1609     return jPresenceHandle;
1610 }
1611
1612 /*
1613 * Class:     org_iotivity_base_OcPlatform
1614 * Method:    subscribePresence1
1615 * Signature: (Ljava/lang/String;Ljava/lang/String;I
1616 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
1617 */
1618 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1
1619 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceType, jint jConnectivityType, jobject jListener)
1620 {
1621     LOGD("OcPlatform_subscribePresence1");
1622     std::string host;
1623     if (jHost)
1624     {
1625         host = env->GetStringUTFChars(jHost, NULL);
1626     }
1627     std::string resourceType;
1628     if (jResourceType)
1629     {
1630         resourceType = env->GetStringUTFChars(jResourceType, NULL);
1631     }
1632     if (!jListener)
1633     {
1634         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
1635         return nullptr;
1636     }
1637
1638     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
1639
1640     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
1641         const unsigned int nonce, const std::string& hostAddress)
1642     {
1643         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
1644     };
1645
1646     OCPlatform::OCPresenceHandle presenceHandle;
1647     try
1648     {
1649         OCStackResult result = OCPlatform::subscribePresence(
1650             presenceHandle,
1651             host,
1652             resourceType,
1653             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
1654             subscribeCallback);
1655
1656         if (OC_STACK_OK != result)
1657         {
1658             ThrowOcException(result, "subscribe presence has failed");
1659         }
1660     }
1661     catch (OCException& e)
1662     {
1663         LOGE("%s", e.reason().c_str());
1664         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1665         return nullptr;
1666     }
1667
1668     JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
1669     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
1670     jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
1671     if (!jPresenceHandle)
1672     {
1673         LOGE("Failed to create OcPresenceHandle");
1674         delete jniPresenceHandle;
1675     }
1676     return jPresenceHandle;
1677 }
1678
1679 /*
1680 * Class:     org_iotivity_base_OcPlatform
1681 * Method:    unsubscribePresence0
1682 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
1683 */
1684 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0
1685 (JNIEnv *env, jclass clazz, jobject jPresenceHandle)
1686 {
1687     LOGD("OcPlatform_unsubscribePresence");
1688     if (!jPresenceHandle)
1689     {
1690         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
1691         return;
1692     }
1693     JniOcPresenceHandle* jniPresenceHandle = JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
1694     if (!jniPresenceHandle) return;
1695
1696     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
1697
1698     try
1699     {
1700         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
1701
1702         if (OC_STACK_OK != result)
1703         {
1704             ThrowOcException(result, "unsubscribe presence has failed");
1705             return;
1706         }
1707         jweak jwOnPresenceListener = jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
1708         if (jwOnPresenceListener)
1709         {
1710             RemoveOnPresenceListener(env, jwOnPresenceListener);
1711         }
1712     }
1713     catch (OCException& e)
1714     {
1715         LOGE("%s", e.reason().c_str());
1716         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1717     }
1718 }
1719
1720 /*
1721 * Class:     org_iotivity_base_OcPlatform
1722 * Method:    constructResourceObject0
1723 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
1724 Lorg/iotivity/base/OcResource;
1725 */
1726 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0
1727 (JNIEnv *env, jclass clazz, jstring jHost, jstring jUri, jint jConnectivityType,
1728 jboolean jIsObservable, jobjectArray jResourceTypeArray, jobjectArray jInterfaceArray)
1729 {
1730     LOGD("OcPlatform_constructResourceObject");
1731     std::string host;
1732     if (jHost)
1733     {
1734         host = env->GetStringUTFChars(jHost, NULL);
1735     }
1736     std::string uri;
1737     if (jUri)
1738     {
1739         uri = env->GetStringUTFChars(jUri, NULL);
1740     }
1741     if (!jResourceTypeArray)
1742     {
1743         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
1744         return nullptr;
1745     }
1746     if (!jInterfaceArray)
1747     {
1748         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
1749         return nullptr;
1750     }
1751
1752     std::vector<std::string> resourceTypes;
1753     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
1754
1755     std::vector<std::string> interfaces;
1756     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
1757
1758     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
1759         host,
1760         uri,
1761         JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
1762         static_cast<bool>(jIsObservable),
1763         resourceTypes,
1764         interfaces);
1765
1766     if (!resource)
1767     {
1768         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
1769         return nullptr;
1770     }
1771
1772     JniOcResource *jniOcResource = new JniOcResource(resource);
1773     jlong handle = reinterpret_cast<jlong>(jniOcResource);
1774
1775     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
1776     if (!jResource)
1777     {
1778         delete jniOcResource;
1779         return nullptr;
1780     }
1781     SetHandle<JniOcResource>(env, jResource, jniOcResource);
1782     if (env->ExceptionCheck())
1783     {
1784         delete jniOcResource;
1785         return nullptr;
1786     }
1787     return jResource;
1788 }
1789
1790 /*
1791 * Class:     org_iotivity_base_OcPlatform
1792 * Method:    sendResponse0
1793 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
1794 */
1795 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0
1796 (JNIEnv *env, jclass clazz, jobject jResourceResponse)
1797 {
1798     LOGD("OcPlatform_sendResponse");
1799     if (!jResourceResponse)
1800     {
1801         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
1802         return;
1803     }
1804
1805     JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
1806         env, jResourceResponse);
1807     if (!jniResponse) return;
1808
1809     try
1810     {
1811         OCStackResult result = OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
1812
1813         if (OC_STACK_OK != result)
1814         {
1815             ThrowOcException(result, "failed to send response");
1816         }
1817     }
1818     catch (OCException& e)
1819     {
1820         LOGE("%s", e.reason().c_str());
1821         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1822     }
1823 }