android/android_api/base/jni/JniOcResource.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
  23 #include "JniOcResource.h"
  24 #include "JniOcRepresentation.h"
  25 #include "JniUtils.h"
  26
  27 JniOcResource::JniOcResource(std::shared_ptr<OCResource> resource)
  28     : m_sharedResource(resource)
  29 {}
  30
  31 JniOcResource::~JniOcResource()
  32 {
  33     LOGD("~JniOcResource()");
  34
  35     m_sharedResource->cancelObserve();
  36     m_sharedResource = NULL;
  37
  38     jint envRet;
  39     JNIEnv *env = GetJNIEnv(envRet);
  40     if (NULL == env) return;
  41
  42     m_onGetManager.removeAllListeners(env);
  43     m_onPutManager.removeAllListeners(env);
  44     m_onPostManager.removeAllListeners(env);
  45     m_onDeleteManager.removeAllListeners(env);
  46     m_onObserveManager.removeAllListeners(env);
  47
  48     if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
  49 }
  50
  51 OCStackResult JniOcResource::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener)
  52 {
  53     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
  54
  55     GetCallback getCallback = [onGetListener](
  56         const HeaderOptions& opts,
  57         const OCRepresentation& rep,
  58         const int eCode)
  59     {
  60         onGetListener->onGetCallback(opts, rep, eCode);
  61     };
  62
  63     return m_sharedResource->get(queryParametersMap, getCallback);
  64 }
  65
  66 OCStackResult JniOcResource::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener,
  67     QualityOfService QoS)
  68 {
  69     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
  70
  71     GetCallback getCallback = [onGetListener](const HeaderOptions& opts, const OCRepresentation& rep,
  72         const int eCode)
  73     {
  74         onGetListener->onGetCallback(opts, rep, eCode);
  75     };
  76
  77     return m_sharedResource->get(queryParametersMap, getCallback, QoS);
  78 }
  79
  80 OCStackResult JniOcResource::get(
  81     JNIEnv* env,
  82     const std::string &resourceType,
  83     const std::string &resourceInterface,
  84     const QueryParamsMap &queryParametersMap,
  85     jobject jListener)
  86 {
  87     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
  88
  89     GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
  90         const OCRepresentation& rep, const int eCode)
  91     {
  92         onGetListener->onGetCallback(opts, rep, eCode);
  93     };
  94
  95     return m_sharedResource->get(resourceType, resourceInterface, queryParametersMap,
  96         getCallback);
  97 }
  98
  99 OCStackResult JniOcResource::get(JNIEnv* env, const std::string &resourceType,
 100     const std::string &resourceInterface, const QueryParamsMap &queryParametersMap,
 101     jobject jListener, QualityOfService QoS)
 102 {
 103     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 104
 105     GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
 106         const OCRepresentation& rep, const int eCode)
 107     {
 108         onGetListener->onGetCallback(opts, rep, eCode);
 109     };
 110
 111     return m_sharedResource->get(resourceType, resourceInterface, queryParametersMap,
 112         getCallback, QoS);
 113 }
 114
 115 OCStackResult JniOcResource::put(JNIEnv* env, const OCRepresentation &representation,
 116     const QueryParamsMap &queryParametersMap, jobject jListener)
 117 {
 118     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 119
 120     PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
 121         const OCRepresentation& rep, const int eCode)
 122     {
 123         onPutListener->onPutCallback(opts, rep, eCode);
 124     };
 125
 126     return m_sharedResource->put(representation, queryParametersMap, putCallback);
 127 }
 128
 129 OCStackResult JniOcResource::put(JNIEnv* env, const OCRepresentation &representation,
 130     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 131 {
 132     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 133
 134     PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
 135         const OCRepresentation& rep, const int eCode)
 136     {
 137         onPutListener->onPutCallback(opts, rep, eCode);
 138     };
 139
 140     return m_sharedResource->put(representation, queryParametersMap, putCallback, QoS);
 141 }
 142
 143 OCStackResult JniOcResource::put(JNIEnv* env, const std::string &resourceType,
 144     const std::string &resourceInterface, const OCRepresentation &representation,
 145     const QueryParamsMap &queryParametersMap, jobject jListener)
 146 {
 147     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 148
 149     PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
 150         const OCRepresentation& rep, const int eCode)
 151     {
 152         onPutListener->onPutCallback(opts, rep, eCode);
 153     };
 154
 155     return m_sharedResource->put(resourceType, resourceInterface, representation,
 156         queryParametersMap, putCallback);
 157 }
 158
 159 OCStackResult JniOcResource::put(JNIEnv* env, const std::string &resourceType,
 160     const std::string &resourceInterface, const OCRepresentation &representation,
 161     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 162 {
 163     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 164
 165     PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
 166         const OCRepresentation& rep, const int eCode)
 167     {
 168         onPutListener->onPutCallback(opts, rep, eCode);
 169     };
 170
 171     return m_sharedResource->put(resourceType, resourceInterface, representation,
 172         queryParametersMap, putCallback, QoS);
 173 }
 174
 175 OCStackResult JniOcResource::post(JNIEnv* env, const OCRepresentation &representation,
 176     const QueryParamsMap &queryParametersMap, jobject jListener)
 177 {
 178     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 179
 180     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 181         const OCRepresentation& rep, const int eCode)
 182     {
 183         onPostListener->onPostCallback(opts, rep, eCode);
 184     };
 185
 186     return m_sharedResource->post(representation, queryParametersMap, postCallback);
 187 }
 188
 189 OCStackResult JniOcResource::post(JNIEnv* env, const OCRepresentation &representation,
 190     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 191 {
 192     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 193
 194     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 195         const OCRepresentation& rep, const int eCode)
 196     {
 197         onPostListener->onPostCallback(opts, rep, eCode);
 198     };
 199
 200     return m_sharedResource->post(representation, queryParametersMap, postCallback, QoS);
 201 }
 202
 203 OCStackResult JniOcResource::post(JNIEnv* env, const std::string &resourceType,
 204     const std::string &resourceInterface, const OCRepresentation &representation,
 205     const QueryParamsMap &queryParametersMap, jobject jListener)
 206 {
 207     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 208
 209     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 210         const OCRepresentation& rep, const int eCode)
 211     {
 212         onPostListener->onPostCallback(opts, rep, eCode);
 213     };
 214
 215     return m_sharedResource->post(resourceType, resourceInterface, representation,
 216         queryParametersMap, postCallback);
 217 }
 218
 219 OCStackResult JniOcResource::post(JNIEnv* env, const std::string &resourceType,
 220     const std::string &resourceInterface, const OCRepresentation &representation,
 221     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 222 {
 223     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 224
 225     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 226         const OCRepresentation& rep, const int eCode)
 227     {
 228         onPostListener->onPostCallback(opts, rep, eCode);
 229     };
 230
 231     return m_sharedResource->post(resourceType, resourceInterface, representation,
 232         queryParametersMap, postCallback, QoS);
 233 }
 234
 235 OCStackResult JniOcResource::deleteResource(JNIEnv* env, jobject jListener)
 236 {
 237     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 238
 239     DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
 240         const int eCode)
 241     {
 242         onDeleteListener->onDeleteCallback(opts, eCode);
 243     };
 244
 245     return m_sharedResource->deleteResource(deleteCallback);
 246 }
 247
 248 OCStackResult JniOcResource::deleteResource(JNIEnv* env, jobject jListener, QualityOfService QoS)
 249 {
 250     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 251
 252     DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts, const int eCode)
 253     {
 254         onDeleteListener->onDeleteCallback(opts, eCode);
 255     };
 256
 257     return m_sharedResource->deleteResource(deleteCallback, QoS);
 258 }
 259
 260 OCStackResult JniOcResource::observe(JNIEnv* env, ObserveType observeType,
 261     const QueryParamsMap &queryParametersMap, jobject jListener)
 262 {
 263     JniOnObserveListener *onObserveListener = addOnObserveListener(env, jListener);
 264
 265     ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
 266         const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
 267     {
 268         onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
 269     };
 270
 271     return m_sharedResource->observe(observeType, queryParametersMap, observeCallback);
 272 }
 273
 274 OCStackResult JniOcResource::observe(JNIEnv* env, ObserveType observeType,
 275     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 276 {
 277     JniOnObserveListener *onObserveListener = addOnObserveListener(env, jListener);
 278
 279     ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
 280         const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
 281     {
 282         onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
 283     };
 284
 285     return m_sharedResource->observe(observeType, queryParametersMap, observeCallback, QoS);
 286 }
 287
 288 OCStackResult JniOcResource::cancelObserve(JNIEnv* env)
 289 {
 290     this->m_onObserveManager.removeAllListeners(env);
 291     return m_sharedResource->cancelObserve();
 292 }
 293
 294 OCStackResult JniOcResource::cancelObserve(JNIEnv* env, QualityOfService qos)
 295 {
 296     //TODO confirm behavior
 297     //add removal of java listeners by qos
 298     this->m_onObserveManager.removeAllListeners(env);
 299     return m_sharedResource->cancelObserve(qos);
 300 }
 301
 302 void JniOcResource::setHeaderOptions(const HeaderOptions &headerOptions)
 303 {
 304     m_sharedResource->setHeaderOptions(headerOptions);
 305 }
 306
 307 void JniOcResource::unsetHeaderOptions()
 308 {
 309     m_sharedResource->unsetHeaderOptions();
 310 }
 311
 312 std::string JniOcResource::host()
 313 {
 314     return m_sharedResource->host();
 315 }
 316
 317 std::string JniOcResource::uri()
 318 {
 319     return m_sharedResource->uri();
 320 }
 321
 322 OCConnectivityType JniOcResource::connectivityType() const
 323 {
 324     return m_sharedResource->connectivityType();
 325 }
 326
 327 bool JniOcResource::isObservable()
 328 {
 329     return m_sharedResource->isObservable();
 330 }
 331
 332 std::vector< std::string > JniOcResource::getResourceTypes() const
 333 {
 334     return m_sharedResource->getResourceTypes();
 335 }
 336
 337 std::vector< std::string > JniOcResource::getResourceInterfaces(void) const
 338 {
 339     return m_sharedResource->getResourceInterfaces();
 340 }
 341
 342 OCResourceIdentifier JniOcResource::uniqueIdentifier() const
 343 {
 344     return m_sharedResource->uniqueIdentifier();
 345 }
 346
 347 std::string JniOcResource::sid() const
 348 {
 349     return m_sharedResource->sid();
 350 }
 351
 352 JniOnGetListener* JniOcResource::addOnGetListener(JNIEnv* env, jobject jListener)
 353 {
 354     return this->m_onGetManager.addListener(env, jListener, this);
 355 }
 356
 357 JniOnPutListener* JniOcResource::addOnPutListener(JNIEnv* env, jobject jListener)
 358 {
 359     return this->m_onPutManager.addListener(env, jListener, this);
 360 }
 361
 362 JniOnPostListener* JniOcResource::addOnPostListener(JNIEnv* env, jobject jListener)
 363 {
 364     return this->m_onPostManager.addListener(env, jListener, this);
 365 }
 366
 367 JniOnDeleteListener* JniOcResource::addOnDeleteListener(JNIEnv* env, jobject jListener)
 368 {
 369     return this->m_onDeleteManager.addListener(env, jListener, this);
 370 }
 371
 372 JniOnObserveListener* JniOcResource::addOnObserveListener(JNIEnv* env, jobject jListener)
 373 {
 374     return this->m_onObserveManager.addListener(env, jListener, this);
 375 }
 376
 377 void JniOcResource::removeOnGetListener(JNIEnv* env, jobject jListener)
 378 {
 379     this->m_onGetManager.removeListener(env, jListener);
 380 }
 381
 382 void JniOcResource::removeOnPutListener(JNIEnv* env, jobject jListener)
 383 {
 384     this->m_onPutManager.removeListener(env, jListener);
 385 }
 386
 387 void JniOcResource::removeOnPostListener(JNIEnv* env, jobject jListener)
 388 {
 389     this->m_onPostManager.removeListener(env, jListener);
 390 }
 391
 392 void JniOcResource::removeOnDeleteListener(JNIEnv* env, jobject jListener)
 393 {
 394     this->m_onDeleteManager.removeListener(env, jListener);
 395 }
 396
 397 void JniOcResource::removeOnObserveListener(JNIEnv* env, jobject jListener)
 398 {
 399     this->m_onObserveManager.removeListener(env, jListener);
 400 }
 401
 402 std::shared_ptr<OCResource> JniOcResource::getOCResource()
 403 {
 404     return this->m_sharedResource;
 405 }
 406
 407 JniOcResource* JniOcResource::getJniOcResourcePtr(JNIEnv *env, jobject thiz)
 408 {
 409     JniOcResource *resource = GetHandle<JniOcResource>(env, thiz);
 410     if (env->ExceptionCheck())
 411     {
 412         LOGE("Failed to get native handle from OcResource");
 413     }
 414     if (!resource)
 415     {
 416         ThrowOcException(JNI_NO_NATIVE_POINTER, "");
 417     }
 418     return resource;
 419 }
 420
 421 /*
 422 * Class:     org_iotivity_base_OcResource
 423 * Method:    get
 424 * Signature: (Ljava/util/Map;Lorg/iotivity/base/OcResource/OnGetListener;)V
 425 */
 426 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_get
 427 (JNIEnv *env, jobject thiz, jobject jQueryParamsMap, jobject jListener)
 428 {
 429     LOGD("OcResource_get");
 430     if (!jQueryParamsMap)
 431     {
 432         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 433         return;
 434     }
 435     if (!jListener)
 436     {
 437         ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
 438         return;
 439     }
 440     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 441     if (!resource) return;
 442
 443     QueryParamsMap qpm;
 444     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 445
 446     try
 447     {
 448         OCStackResult result = resource->get(
 449             env,
 450             qpm,
 451             jListener);
 452
 453         if (OC_STACK_OK != result)
 454         {
 455             ThrowOcException(result, "OcResource_get");
 456         }
 457     }
 458     catch (OCException& e)
 459     {
 460         LOGE("%s", e.reason().c_str());
 461         ThrowOcException(e.code(), e.reason().c_str());
 462     }
 463 }
 464
 465 /*
 466 * Class:     org_iotivity_base_OcResource
 467 * Method:    get1
 468 * Signature: (Ljava/util/Map;Lorg/iotivity/base/OcResource/OnGetListener;I)V
 469 */
 470 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_get1
 471 (JNIEnv *env, jobject thiz, jobject jQueryParamsMap, jobject jListener, jint jQoS)
 472 {
 473     LOGD("OcResource_get");
 474     if (!jQueryParamsMap)
 475     {
 476         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 477         return;
 478     }
 479     if (!jListener)
 480     {
 481         ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
 482         return;
 483     }
 484     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 485     if (!resource) return;
 486
 487     QueryParamsMap qpm;
 488     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 489
 490     try
 491     {
 492         OCStackResult result = resource->get(
 493             env,
 494             qpm,
 495             jListener,
 496             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 497
 498         if (OC_STACK_OK != result)
 499         {
 500             ThrowOcException(result, "OcResource_get");
 501         }
 502     }
 503     catch (OCException& e)
 504     {
 505         LOGE("%s", e.reason().c_str());
 506         ThrowOcException(e.code(), e.reason().c_str());
 507     }
 508 }
 509
 510 /*
 511 * Class:     org_iotivity_base_OcResource
 512 * Method:    get2
 513 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;
 514 Lorg/iotivity/base/OcResource/OnGetListener;)V
 515 */
 516 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_get2
 517 (JNIEnv *env, jobject thiz, jstring jResourceType, jstring jResourceInterface,
 518 jobject jQueryParamsMap, jobject jListener)
 519 {
 520     LOGD("OcResource_get");
 521     std::string resourceType;
 522     if (jResourceType)
 523     {
 524         resourceType = env->GetStringUTFChars(jResourceType, NULL);
 525     }
 526     std::string resourceInterface;
 527     if (jResourceInterface)
 528     {
 529         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
 530     }
 531     if (!jQueryParamsMap)
 532     {
 533         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 534         return;
 535     }
 536     if (!jListener)
 537     {
 538         ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
 539         return;
 540     }
 541     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 542     if (!resource) return;
 543
 544     QueryParamsMap qpm;
 545     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 546     try
 547     {
 548         OCStackResult result = resource->get(
 549             env,
 550             resourceType,
 551             resourceInterface,
 552             qpm,
 553             jListener);
 554
 555         if (OC_STACK_OK != result)
 556         {
 557             ThrowOcException(result, "OcResource_get");
 558         }
 559     }
 560     catch (OCException& e)
 561     {
 562         LOGE("%s", e.reason().c_str());
 563         ThrowOcException(e.code(), e.reason().c_str());
 564     }
 565 }
 566
 567 /*
 568 * Class:     org_iotivity_base_OcResource
 569 * Method:    get3
 570 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;
 571 Lorg/iotivity/base/OcResource/OnGetListener;I)V
 572 */
 573 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_get3
 574 (JNIEnv *env, jobject thiz, jstring jResourceType, jstring jResourceInterface,
 575 jobject jQueryParamsMap, jobject jListener, jint jQoS)
 576 {
 577     LOGD("OcResource_get");
 578     if (!jQueryParamsMap)
 579     {
 580         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 581         return;
 582     }
 583     if (!jListener)
 584     {
 585         ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
 586         return;
 587     }
 588     std::string resourceType;
 589     if (jResourceType)
 590     {
 591         resourceType = env->GetStringUTFChars(jResourceType, NULL);
 592     }
 593     std::string resourceInterface;
 594     if (jResourceInterface)
 595     {
 596         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
 597     }
 598     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 599     if (!resource) return;
 600
 601     QueryParamsMap qpm;
 602     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 603
 604     try
 605     {
 606         OCStackResult result = resource->get(
 607             env,
 608             resourceType,
 609             resourceInterface,
 610             qpm,
 611             jListener,
 612             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 613
 614         if (OC_STACK_OK != result)
 615         {
 616             ThrowOcException(result, "OcResource_get");
 617         }
 618     }
 619     catch (OCException& e)
 620     {
 621         LOGE("%s", e.reason().c_str());
 622         ThrowOcException(e.code(), e.reason().c_str());
 623     }
 624 }
 625
 626 /*
 627 * Class:     org_iotivity_base_OcResource
 628 * Method:    put
 629 * Signature: (Lorg/iotivity/base/OcRepresentation;Ljava/util/Map;
 630 Lorg/iotivity/base/OcResource/OnPutListener;)V
 631 */
 632 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_put
 633 (JNIEnv *env, jobject thiz, jobject jRepresentation, jobject jQueryParamsMap, jobject jListener)
 634 {
 635     LOGD("OcResource_put");
 636     if (!jRepresentation)
 637     {
 638         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 639         return;
 640     }
 641     if (!jQueryParamsMap)
 642     {
 643         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 644         return;
 645     }
 646     if (!jListener)
 647     {
 648         ThrowOcException(OC_STACK_INVALID_PARAM, "onPutListener cannot be null");
 649         return;
 650     }
 651     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 652     if (!resource) return;
 653
 654     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
 655     if (!representation) return;
 656
 657     QueryParamsMap qpm;
 658     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 659
 660     try
 661     {
 662         OCStackResult result = resource->put(
 663             env,
 664             *representation,
 665             qpm,
 666             jListener);
 667
 668         if (OC_STACK_OK != result)
 669         {
 670             ThrowOcException(result, "OcResource_put");
 671         }
 672     }
 673     catch (OCException& e)
 674     {
 675         LOGE("%s", e.reason().c_str());
 676         ThrowOcException(e.code(), e.reason().c_str());
 677     }
 678 }
 679
 680 /*
 681 * Class:     org_iotivity_base_OcResource
 682 * Method:    put1
 683 * Signature: (Lorg/iotivity/base/OcRepresentation;Ljava/util/Map;
 684 Lorg/iotivity/base/OcResource/OnPutListener;I)V
 685 */
 686 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_put1
 687 (JNIEnv *env, jobject thiz, jobject jRepresentation, jobject jQueryParamsMap,
 688 jobject jListener, jint jQoS)
 689 {
 690     LOGD("OcResource_put");
 691     if (!jRepresentation)
 692     {
 693         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 694         return;
 695     }
 696     if (!jQueryParamsMap)
 697     {
 698         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 699         return;
 700     }
 701     if (!jListener)
 702     {
 703         ThrowOcException(OC_STACK_INVALID_PARAM, "onPutListener cannot be null");
 704         return;
 705     }
 706     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 707     if (!resource) return;
 708
 709     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
 710     if (!representation) return;
 711
 712     QueryParamsMap qpm;
 713     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 714
 715     try
 716     {
 717         OCStackResult result = resource->put(
 718             env,
 719             *representation,
 720             qpm,
 721             jListener,
 722             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 723
 724         if (OC_STACK_OK != result)
 725         {
 726             ThrowOcException(result, "OcResource_put");
 727         }
 728     }
 729     catch (OCException& e)
 730     {
 731         LOGE("%s", e.reason().c_str());
 732         ThrowOcException(e.code(), e.reason().c_str());
 733     }
 734 }
 735
 736 /*
 737 * Class:     org_iotivity_base_OcResource
 738 * Method:    put2
 739 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;
 740 Ljava/util/Map;Lorg/iotivity/base/OcResource/OnPutListener;)V
 741 */
 742 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_put2
 743 (JNIEnv *env, jobject thiz, jstring jResourceType, jstring jResourceInterface,
 744 jobject jRepresentation, jobject jQueryParamsMap, jobject jListener)
 745 {
 746     LOGD("OcResource_put");
 747     std::string resourceType;
 748     if (jResourceType)
 749     {
 750         resourceType = env->GetStringUTFChars(jResourceType, NULL);
 751     }
 752     std::string resourceInterface;
 753     if (jResourceInterface)
 754     {
 755         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
 756     }
 757     if (!jRepresentation)
 758     {
 759         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 760         return;
 761     }
 762     if (!jQueryParamsMap)
 763     {
 764         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 765         return;
 766     }
 767     if (!jListener)
 768     {
 769         ThrowOcException(OC_STACK_INVALID_PARAM, "onPutListener cannot be null");
 770         return;
 771     }
 772     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 773     if (!resource) return;
 774
 775     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
 776     if (!representation) return;
 777
 778     QueryParamsMap qpm;
 779     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 780
 781     try
 782     {
 783         OCStackResult result = resource->put(
 784             env,
 785             resourceType,
 786             resourceInterface,
 787             *representation,
 788             qpm,
 789             jListener);
 790
 791         if (OC_STACK_OK != result)
 792         {
 793             ThrowOcException(result, "OcResource_put");
 794         }
 795     }
 796     catch (OCException& e)
 797     {
 798         LOGE("%s", e.reason().c_str());
 799         ThrowOcException(e.code(), e.reason().c_str());
 800     }
 801 }
 802
 803 /*
 804 * Class:     org_iotivity_base_OcResource
 805 * Method:    put3
 806 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;
 807 Ljava/util/Map;Lorg/iotivity/base/OcResource/OnPutListener;I)V
 808 */
 809 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_put3
 810 (JNIEnv *env, jobject thiz, jstring jResourceType, jstring jResourceInterface, jobject jRepresentation,
 811 jobject jQueryParamsMap, jobject jListener, jint jQoS)
 812 {
 813     LOGD("OcResource_put");
 814     if (!jRepresentation)
 815     {
 816         ThrowOcException(OC_STACK_INVALID_PARAM, "representation cannot be null");
 817         return;
 818     }
 819     if (!jQueryParamsMap)
 820     {
 821         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 822         return;
 823     }
 824     if (!jListener)
 825     {
 826         ThrowOcException(OC_STACK_INVALID_PARAM, "onPutListener cannot be null");
 827         return;
 828     }
 829     std::string resourceType;
 830     if (jResourceType)
 831     {
 832         resourceType = env->GetStringUTFChars(jResourceType, NULL);
 833     }
 834     std::string resourceInterface;
 835     if (jResourceInterface)
 836     {
 837         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
 838     }
 839
 840     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 841     if (!resource) return;
 842
 843     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
 844     if (!representation) return;
 845
 846     QueryParamsMap qpm;
 847     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 848
 849     try
 850     {
 851         OCStackResult result = resource->put(
 852             env,
 853             resourceType,
 854             resourceInterface,
 855             *representation,
 856             qpm,
 857             jListener,
 858             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 859
 860         if (OC_STACK_OK != result)
 861         {
 862             ThrowOcException(result, "OcResource_put");
 863         }
 864     }
 865     catch (OCException& e)
 866     {
 867         LOGE("%s", e.reason().c_str());
 868         ThrowOcException(e.code(), e.reason().c_str());
 869     }
 870 }
 871
 872 /*
 873 * Class:     org_iotivity_base_OcResource
 874 * Method:    post
 875 * Signature: (Lorg/iotivity/base/OcRepresentation;Ljava/util/Map;Lorg/iotivity/base/OcResource/OnPostListener;)V
 876 */
 877 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_post
 878 (JNIEnv *env, jobject thiz, jobject jRepresentation, jobject jQueryParamsMap, jobject jListener)
 879 {
 880     LOGD("OcResource_post");
 881     if (!jRepresentation)
 882     {
 883         ThrowOcException(OC_STACK_INVALID_PARAM, "representation cannot be null");
 884         return;
 885     }
 886     if (!jQueryParamsMap)
 887     {
 888         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 889         return;
 890     }
 891     if (!jListener)
 892     {
 893         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
 894         return;
 895     }
 896     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 897     if (!resource) return;
 898
 899     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
 900     if (!representation) return;
 901
 902     QueryParamsMap qpm;
 903     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 904
 905     try
 906     {
 907         OCStackResult result = resource->post(
 908             env,
 909             *representation,
 910             qpm,
 911             jListener);
 912
 913         if (OC_STACK_OK != result)
 914         {
 915             ThrowOcException(result, "OcResource_post");
 916         }
 917     }
 918     catch (OCException& e)
 919     {
 920         LOGE("%s", e.reason().c_str());
 921         ThrowOcException(e.code(), e.reason().c_str());
 922     }
 923 }
 924
 925 /*
 926 * Class:     org_iotivity_base_OcResource
 927 * Method:    post1
 928 * Signature: (Lorg/iotivity/base/OcRepresentation;Ljava/util/Map;Lorg/iotivity/base/OcResource/OnPostListener;I)V
 929 */
 930 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_post1
 931 (JNIEnv *env, jobject thiz, jobject jRepresentation, jobject jQueryParamsMap, jobject jListener, jint jQoS)
 932 {
 933     LOGD("OcResource_post");
 934     if (!jRepresentation)
 935     {
 936         ThrowOcException(OC_STACK_INVALID_PARAM, "representation cannot be null");
 937         return;
 938     }
 939     if (!jQueryParamsMap)
 940     {
 941         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 942         return;
 943     }
 944     if (!jListener)
 945     {
 946         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
 947         return;
 948     }
 949     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
 950     if (!resource) return;
 951
 952     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
 953     if (!representation) return;
 954
 955     QueryParamsMap qpm;
 956     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
 957
 958     try
 959     {
 960         OCStackResult result = resource->post(
 961             env,
 962             *representation,
 963             qpm,
 964             jListener,
 965             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 966
 967         if (OC_STACK_OK != result)
 968         {
 969             ThrowOcException(result, "OcResource_post");
 970         }
 971     }
 972     catch (OCException& e)
 973     {
 974         LOGE("%s", e.reason().c_str());
 975         ThrowOcException(e.code(), e.reason().c_str());
 976     }
 977 }
 978
 979 /*
 980 * Class:     org_iotivity_base_OcResource
 981 * Method:    post2
 982 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;
 983 Ljava/util/Map;Lorg/iotivity/base/OcResource/OnPostListener;)V
 984 */
 985 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_post2
 986 (JNIEnv *env, jobject thiz, jstring jResourceType, jstring jResourceInterface,
 987 jobject jRepresentation, jobject jQueryParamsMap, jobject jListener)
 988 {
 989     LOGD("OcResource_post");
 990     if (!jRepresentation)
 991     {
 992         ThrowOcException(OC_STACK_INVALID_PARAM, "representation cannot be null");
 993         return;
 994     }
 995     if (!jQueryParamsMap)
 996     {
 997         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
 998         return;
 999     }
1000     if (!jListener)
1001     {
1002         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
1003         return;
1004     }
1005     std::string resourceType;
1006     if (jResourceType)
1007     {
1008         resourceType = env->GetStringUTFChars(jResourceType, NULL);
1009     }
1010     std::string resourceInterface;
1011     if (jResourceInterface)
1012     {
1013         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
1014     }
1015
1016     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1017     if (!resource) return;
1018
1019     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
1020     if (!representation) return;
1021
1022     QueryParamsMap qpm;
1023     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
1024
1025     try
1026     {
1027         OCStackResult result = resource->post(
1028             env,
1029             resourceType,
1030             resourceInterface,
1031             *representation,
1032             qpm,
1033             jListener);
1034
1035         if (OC_STACK_OK != result)
1036         {
1037             ThrowOcException(result, "OcResource_post");
1038         }
1039     }
1040     catch (OCException& e)
1041     {
1042         LOGE("%s", e.reason().c_str());
1043         ThrowOcException(e.code(), e.reason().c_str());
1044     }
1045 }
1046
1047 /*
1048 * Class:     org_iotivity_base_OcResource
1049 * Method:    post3
1050 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;
1051 Ljava/util/Map;Lorg/iotivity/base/OcResource/OnPostListener;I)V
1052 */
1053 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_post3
1054 (JNIEnv *env, jobject thiz, jstring jResourceType, jstring jResourceInterface,
1055 jobject jRepresentation, jobject jQueryParamsMap, jobject jListener, jint jQoS)
1056 {
1057     LOGD("OcResource_post");
1058     if (!jRepresentation)
1059     {
1060         ThrowOcException(OC_STACK_INVALID_PARAM, "representation cannot be null");
1061         return;
1062     }
1063     if (!jQueryParamsMap)
1064     {
1065         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
1066         return;
1067     }
1068     if (!jListener)
1069     {
1070         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
1071         return;
1072     }
1073     std::string resourceType;
1074     if (jResourceType)
1075     {
1076         resourceType = env->GetStringUTFChars(jResourceType, NULL);
1077     }
1078     std::string resourceInterface;
1079     if (jResourceInterface)
1080     {
1081         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
1082     }
1083
1084     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1085     if (!resource) return;
1086
1087     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env, jRepresentation);
1088     if (!representation) return;
1089
1090     QueryParamsMap qpm;
1091     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
1092
1093     try
1094     {
1095         OCStackResult result = resource->post(
1096             env,
1097             resourceType,
1098             resourceInterface,
1099             *representation,
1100             qpm,
1101             jListener,
1102             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1103
1104         if (OC_STACK_OK != result)
1105         {
1106             ThrowOcException(result, "OcResource_post");
1107         }
1108     }
1109     catch (OCException& e)
1110     {
1111         LOGE("%s", e.reason().c_str());
1112         ThrowOcException(e.code(), e.reason().c_str());
1113     }
1114 }
1115
1116 /*
1117 * Class:     org_iotivity_base_OcResource
1118 * Method:    deleteResource
1119 * Signature: (Lorg/iotivity/base/OcResource/OnDeleteListener;)V
1120 */
1121 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_deleteResource
1122 (JNIEnv *env, jobject thiz, jobject jListener)
1123 {
1124     LOGD("OcResource_deleteResource");
1125     if (!jListener)
1126     {
1127         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteListener cannot be null");
1128         return;
1129     }
1130     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1131     if (!resource) return;
1132
1133     try
1134     {
1135         OCStackResult result = resource->deleteResource(
1136             env,
1137             jListener);
1138
1139         if (OC_STACK_OK != result)
1140         {
1141             ThrowOcException(result, "OcResource_deleteResource");
1142         }
1143     }
1144     catch (OCException& e)
1145     {
1146         LOGE("%s", e.reason().c_str());
1147         ThrowOcException(e.code(), e.reason().c_str());
1148     }
1149 }
1150
1151 /*
1152 * Class:     org_iotivity_base_OcResource
1153 * Method:    deleteResource1
1154 * Signature: (Lorg/iotivity/base/OcResource/OnDeleteListener;I)V
1155 */
1156 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_deleteResource1
1157 (JNIEnv *env, jobject thiz, jobject jListener, jint jQoS)
1158 {
1159     LOGD("OcResource_deleteResource");
1160     if (!jListener)
1161     {
1162         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteListener cannot be null");
1163         return;
1164     }
1165     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1166     if (!resource) return;
1167
1168     try
1169     {
1170         OCStackResult result = resource->deleteResource(
1171             env,
1172             jListener,
1173             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1174
1175         if (OC_STACK_OK != result)
1176         {
1177             ThrowOcException(result, "OcResource_deleteResource");
1178         }
1179     }
1180     catch (OCException& e)
1181     {
1182         LOGE("%s", e.reason().c_str());
1183         ThrowOcException(e.code(), e.reason().c_str());
1184     }
1185 }
1186
1187 /*
1188 * Class:     org_iotivity_base_OcResource
1189 * Method:    observe
1190 * Signature: (Lorg/iotivity/base/ObserveType;Ljava/util/Map;
1191 Lorg/iotivity/base/OcResource/OnObserveListener;)V
1192 */
1193 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_observe
1194 (JNIEnv *env, jobject thiz, jint observeType, jobject jQueryParamsMap, jobject jListener)
1195 {
1196     LOGD("OcResource_observe");
1197     if (!jQueryParamsMap)
1198     {
1199         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
1200         return;
1201     }
1202     if (!jListener)
1203     {
1204         ThrowOcException(OC_STACK_INVALID_PARAM, "onObserveListener cannot be null");
1205         return;
1206     }
1207     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1208     if (!resource) return;
1209
1210     QueryParamsMap qpm;
1211     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
1212
1213     try
1214     {
1215         OCStackResult result = resource->observe(
1216             env,
1217             JniUtils::getObserveType(env, static_cast<int>(observeType)),
1218             qpm,
1219             jListener);
1220
1221         if (OC_STACK_OK != result)
1222         {
1223             ThrowOcException(result, "OcResource_observe");
1224         }
1225     }
1226     catch (OCException& e)
1227     {
1228         LOGE("%s", e.reason().c_str());
1229         ThrowOcException(e.code(), e.reason().c_str());
1230     }
1231 }
1232
1233 /*
1234 * Class:     org_iotivity_base_OcResource
1235 * Method:    observe1
1236 * Signature: (Lorg/iotivity/base/ObserveType;Ljava/util/Map;
1237 Lorg/iotivity/base/OcResource/OnObserveListener;I)V
1238 */
1239 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_observe1
1240 (JNIEnv *env, jobject thiz, jint observeType, jobject jQueryParamsMap,
1241 jobject jListener, jint jQoS)
1242 {
1243     LOGD("OcResource_observe");
1244     if (!jQueryParamsMap)
1245     {
1246         ThrowOcException(OC_STACK_INVALID_PARAM, "queryParamsMap cannot be null");
1247         return;
1248     }
1249     if (!jListener)
1250     {
1251         ThrowOcException(OC_STACK_INVALID_PARAM, "onObserveListener cannot be null");
1252         return;
1253     }
1254     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1255     if (!resource) return;
1256
1257     QueryParamsMap qpm;
1258     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryParamsMap, qpm);
1259
1260     try
1261     {
1262         OCStackResult result = resource->observe(
1263             env,
1264             JniUtils::getObserveType(env, static_cast<int>(observeType)),
1265             qpm,
1266             jListener,
1267             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1268
1269         if (OC_STACK_OK != result)
1270         {
1271             ThrowOcException(result, "OcResource_observe");
1272         }
1273     }
1274     catch (OCException& e)
1275     {
1276         LOGE("%s", e.reason().c_str());
1277         ThrowOcException(e.code(), e.reason().c_str());
1278     }
1279 }
1280
1281 /*
1282 * Class:     org_iotivity_base_OcResource
1283 * Method:    cancelObserve
1284 * Signature: ()V
1285 */
1286 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_cancelObserve
1287 (JNIEnv *env, jobject thiz)
1288 {
1289     LOGD("OcResource_cancelObserve");
1290     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1291     if (!resource) return;
1292
1293     try
1294     {
1295         OCStackResult result = resource->cancelObserve(env);
1296
1297         if (OC_STACK_OK != result)
1298         {
1299             ThrowOcException(result, "OcResource_cancelObserve");
1300         }
1301     }
1302     catch (OCException& e)
1303     {
1304         LOGE("%s", e.reason().c_str());
1305         ThrowOcException(e.code(), e.reason().c_str());
1306     }
1307 }
1308
1309 /*
1310 * Class:     org_iotivity_base_OcResource
1311 * Method:    cancelObserve1
1312 * Signature: I)V
1313 */
1314 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_cancelObserve1
1315 (JNIEnv *env, jobject thiz, jint jQoS)
1316 {
1317     LOGD("OcResource_cancelObserve1");
1318     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1319     if (!resource) return;
1320
1321     try
1322     {
1323         OCStackResult result = resource->cancelObserve(
1324             env,
1325             JniUtils::getQOS(env, static_cast<int>(jQoS)));
1326
1327         if (OC_STACK_OK != result)
1328         {
1329             ThrowOcException(result, "OcResource_cancelObserve");
1330         }
1331     }
1332     catch (OCException& e)
1333     {
1334         LOGE("%s", e.reason().c_str());
1335         ThrowOcException(e.code(), e.reason().c_str());
1336     }
1337 }
1338
1339 /*
1340 * Class:     org_iotivity_base_OcResource
1341 * Method:    setHeaderOptions
1342 * Signature: ([Lorg/iotivity/OcHeaderOption;)V
1343 */
1344 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_setHeaderOptions
1345 (JNIEnv *env, jobject thiz, jobjectArray jheaderOptionArr)
1346 {
1347     LOGD("OcResource_setHeaderOptions");
1348     if (!jheaderOptionArr)
1349     {
1350         ThrowOcException(OC_STACK_INVALID_PARAM, "headerOptionList cannot be null");
1351         return;
1352     }
1353     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1354     if (!resource) return;
1355
1356     HeaderOptions headerOptions;
1357     JniUtils::convertJavaHeaderOptionsArrToVector(env, jheaderOptionArr, headerOptions);
1358
1359     resource->setHeaderOptions(headerOptions);
1360 }
1361
1362 /*
1363 * Class:     org_iotivity_base_OcResource
1364 * Method:    unsetHeaderOptions
1365 * Signature: ()V
1366 */
1367 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_unsetHeaderOptions
1368 (JNIEnv *env, jobject thiz)
1369 {
1370     LOGD("OcResource_unsetHeaderOptions");
1371     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1372     if (!resource) return;
1373
1374     resource->unsetHeaderOptions();
1375 }
1376
1377 /*
1378 * Class:     org_iotivity_base_OcResource
1379 * Method:    getHost
1380 * Signature: ()Ljava/lang/String;
1381 */
1382 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcResource_getHost
1383 (JNIEnv *env, jobject thiz)
1384 {
1385     LOGD("OcResource_getHost");
1386     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1387     if (!resource) return nullptr;
1388
1389     return env->NewStringUTF(resource->host().c_str());
1390 }
1391
1392 /*
1393 * Class:     org_iotivity_base_OcResource
1394 * Method:    getUri
1395 * Signature: ()Ljava/lang/String;
1396 */
1397 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcResource_getUri
1398 (JNIEnv *env, jobject thiz)
1399 {
1400     LOGD("OcResource_getUri");
1401     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1402     if (!resource) return nullptr;
1403
1404     return env->NewStringUTF(resource->uri().c_str());
1405 }
1406
1407 /*
1408 * Class:     org_iotivity_base_OcResource
1409 * Method:    getConnectivityTypeN
1410 * Signature: ()I
1411 */
1412 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcResource_getConnectivityTypeN
1413 (JNIEnv *env, jobject thiz)
1414 {
1415     LOGD("OcResource_getConnectivityType");
1416     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1417     if (!resource) return -1;
1418
1419     OCConnectivityType connectivityType = resource->connectivityType();
1420     return static_cast<jint>(connectivityType);
1421 }
1422
1423 /*
1424 * Class:     org_iotivity_base_OcResource
1425 * Method:    isObservable
1426 * Signature: ()Z
1427 */
1428 JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcResource_isObservable
1429 (JNIEnv *env, jobject thiz)
1430 {
1431     LOGD("OcResource_isObservable");
1432     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1433     return (jboolean)resource->isObservable();
1434 }
1435
1436 /*
1437 * Class:     org_iotivity_base_OcResource
1438 * Method:    getResourceTypes
1439 * Signature: ()Ljava/util/List;
1440 */
1441 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResource_getResourceTypes
1442 (JNIEnv *env, jobject thiz)
1443 {
1444     LOGD("OcResource_getResourceTypes");
1445     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1446     if (!resource) return nullptr;
1447
1448     std::vector<std::string> resourceTypes = resource->getResourceTypes();
1449
1450     return JniUtils::convertStrVectorToJavaStrList(env, resourceTypes);
1451 }
1452
1453 /*
1454 * Class:     org_iotivity_base_OcResource
1455 * Method:    getResourceInterfaces
1456 * Signature: ()Ljava/util/List;
1457 */
1458 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResource_getResourceInterfaces
1459 (JNIEnv *env, jobject thiz)
1460 {
1461     LOGD("OcResource_getResourceInterfaces");
1462     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1463     if (!resource) return nullptr;
1464
1465     std::vector<std::string> resourceInterfaces = resource->getResourceInterfaces();
1466
1467     return JniUtils::convertStrVectorToJavaStrList(env, resourceInterfaces);
1468 }
1469
1470 /*
1471 * Class:     org_iotivity_base_OcResource
1472 * Method:    getUniqueIdentifier
1473 * Signature: ()Lorg/iotivity/base/OcResourceIdentifier;
1474 */
1475 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResource_getUniqueIdentifier
1476 (JNIEnv *env, jobject thiz)
1477 {
1478     LOGD("OcResource_getUniqueIdentifier");
1479     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1480     if (!resource) return nullptr;
1481
1482     JniOcResourceIdentifier *jniResourceIdentifier =
1483         new JniOcResourceIdentifier(resource->uniqueIdentifier());
1484     if (!jniResourceIdentifier) return nullptr;
1485
1486     jlong handle = reinterpret_cast<jlong>(jniResourceIdentifier);
1487     jobject jResourceIdentifier = env->NewObject(g_cls_OcResourceIdentifier,
1488         g_mid_OcResourceIdentifier_N_ctor, handle);
1489     if (!jResourceIdentifier)
1490     {
1491         delete jniResourceIdentifier;
1492     }
1493     return jResourceIdentifier;
1494 }
1495
1496 /*
1497 * Class:     org_iotivity_base_OcResource
1498 * Method:    getServerId
1499 * Signature: ()Ljava/lang/String;
1500 */
1501 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcResource_getServerId
1502 (JNIEnv *env, jobject thiz)
1503 {
1504     LOGD("OcResource_getServerId");
1505     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1506     if (!resource) return nullptr;
1507
1508     return env->NewStringUTF(resource->sid().c_str());
1509 }
1510
1511 /*
1512 * Class:     org_iotivity_base_OcResource
1513 * Method:    dispose
1514 * Signature: ()V
1515 */
1516 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResource_dispose
1517 (JNIEnv *env, jobject thiz)
1518 {
1519     LOGD("OcResource_dispose");
1520     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, thiz);
1521     delete resource;
1522 }