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