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