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