service/resource-encapsulation/android/service/src/main/jni/JniRcsResourceObject.cpp

   1 /******************************************************************
   2  *
   3  * Copyright 2015 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #include "JniRcsResourceObject.h"
  22
  23 #include "JniRcsObject.h"
  24 #include "JniRcsResourceAttributes.h"
  25 #include "JavaClasses.h"
  26 #include "JavaExceptions.h"
  27 #include "JavaGlobalRef.h"
  28 #include "JniRcsValue.h"
  29 #include "Log.h"
  30 #include "ScopedEnv.h"
  31 #include "Verify.h"
  32
  33 #include "RCSResourceObject.h"
  34 #include "RCSResponse.h"
  35 #include "RequestHandler.h"
  36
  37 #define LOG_TAG "JNI-RCSResourceObject"
  38
  39 #define CLS_NAME_RCS_RESOURCE_OBJECT PACKAGE_NAME "/server/RcsResourceObject"
  40 #define CLS_NAME_RCS_REQUEST PACKAGE_NAME "/server/RcsRequest"
  41
  42 #define CLS_NAME_AUTO_NOTIFY_POLICY CLS_NAME_RCS_RESOURCE_OBJECT "$AutoNotifyPolicy"
  43 #define CLS_NAME_SET_REQUEST_HANDLER_POLICY CLS_NAME_RCS_RESOURCE_OBJECT "$SetRequestHandlerPolicy"
  44
  45 #define CLS_NAME_GET_REQUEST_HANDLER CLS_NAME_RCS_RESOURCE_OBJECT "$GetRequestHandler"
  46 #define CLS_NAME_SET_REQUEST_HANDLER CLS_NAME_RCS_RESOURCE_OBJECT "$SetRequestHandler"
  47 #define CLS_NAME_ON_ATTRIBUTE_UPDATESD_LISTENER \
  48     CLS_NAME_RCS_RESOURCE_OBJECT "$OnAttributeUpdatedListener"
  49
  50 #define CLS_NAME_RCS_RESPONSE PACKAGE_NAME "/server/RcsResponse"
  51
  52 #define CLS_NAME_RCS_GET_RESPONSE PACKAGE_NAME "/server/RcsGetResponse"
  53 #define CLS_NAME_RCS_SET_RESPONSE PACKAGE_NAME "/server/RcsSetResponse"
  54 #define CLS_NAME_RCS_SET_RESPONSE_ACCEPTANCE_METHOD CLS_NAME_RCS_SET_RESPONSE "$AcceptanceMethod"
  55
  56 using namespace OIC::Service;
  57
  58 namespace
  59 {
  60     jclass g_cls_RCSRequest;
  61     jclass g_cls_RCSResourceObject;
  62
  63     jmethodID g_ctor_RCSRequest;
  64     jmethodID g_ctor_RCSResourceObject;
  65
  66     jmethodID g_method_GetRequestHandler_onGetRequested;
  67     jmethodID g_method_SetRequestHandler_onSetRequested;
  68     jmethodID g_method_OnAttributeUpdatedListener_onAttributeUpdated;
  69
  70     jfieldID g_field_RCSResponse_mErrorCode;
  71     jfieldID g_field_RCSResponse_mAttrs;
  72     jfieldID g_field_RCSSetResponse_mAcceptanceMethod;
  73
  74     jobject g_obj_RCSSetResponse_AcceptanceMethod_DEFAULT;
  75     jobject g_obj_RCSSetResponse_AcceptanceMethod_ACCEPT;
  76     jobject g_obj_RCSSetResponse_AcceptanceMethod_IGNORE;
  77
  78     jobject g_obj_AutoNotifyPolicy_NEVER;
  79     jobject g_obj_AutoNotifyPolicy_ALWAYS;
  80     jobject g_obj_AutoNotifyPolicy_UPDATED;
  81
  82     jobject g_obj_SetRequestHandlerPolicy_NEVER;
  83     jobject g_obj_SetRequestHandlerPolicy_ACCEPT;
  84
  85     inline RCSResourceObject::Ptr& getResource(JNIEnv* env, jobject obj)
  86     {
  87         return getNativeHandleAs< RCSResourceObject::Ptr >(env, obj);
  88     }
  89
  90     inline RCSResourceObject::AutoNotifyPolicy convertAutoNotifyPolicy(JNIEnv* env, jobject obj)
  91     {
  92         if (env->IsSameObject(g_obj_AutoNotifyPolicy_NEVER, obj))
  93         {
  94             return RCSResourceObject::AutoNotifyPolicy::NEVER;
  95         }
  96
  97         if (env->IsSameObject(g_obj_AutoNotifyPolicy_ALWAYS, obj))
  98         {
  99             return RCSResourceObject::AutoNotifyPolicy::ALWAYS;
 100         }
 101
 102         if (env->IsSameObject(g_obj_AutoNotifyPolicy_UPDATED, obj))
 103         {
 104             return RCSResourceObject::AutoNotifyPolicy::UPDATED;
 105         }
 106
 107         throwRCSException(env, "Failed to convert AutoNotifyPolicy");
 108         return {};
 109     }
 110
 111     inline jobject convertAutoNotifyPolicy(JNIEnv* env, RCSResourceObject::AutoNotifyPolicy policy)
 112     {
 113         switch(policy)
 114         {
 115             case RCSResourceObject::AutoNotifyPolicy::NEVER: return g_obj_AutoNotifyPolicy_NEVER;
 116             case RCSResourceObject::AutoNotifyPolicy::ALWAYS: return g_obj_AutoNotifyPolicy_ALWAYS;
 117             case RCSResourceObject::AutoNotifyPolicy::UPDATED: return g_obj_AutoNotifyPolicy_UPDATED;
 118         }
 119
 120         throwRCSException(env, "Failed to convert AutoNotifyPolicy");
 121         return {};
 122     }
 123
 124     inline RCSResourceObject::SetRequestHandlerPolicy convertSetRequestHandlerPolicy(JNIEnv* env,
 125             jobject obj)
 126     {
 127         if (env->IsSameObject(g_obj_SetRequestHandlerPolicy_NEVER, obj))
 128         {
 129             return RCSResourceObject::SetRequestHandlerPolicy::NEVER;
 130         }
 131
 132         if (env->IsSameObject(g_obj_SetRequestHandlerPolicy_ACCEPT, obj))
 133         {
 134             return RCSResourceObject::SetRequestHandlerPolicy::ACCEPTANCE;
 135         }
 136
 137         throwRCSException(env, "Failed to convert SetRequestHandlerPolicy");
 138         return {};
 139     }
 140
 141     inline jobject convertSetRequestHandlerPolicy(JNIEnv* env,
 142             RCSResourceObject::SetRequestHandlerPolicy policy)
 143     {
 144         switch(policy)
 145         {
 146             case RCSResourceObject::SetRequestHandlerPolicy::NEVER:
 147                 return g_obj_SetRequestHandlerPolicy_NEVER;
 148             case RCSResourceObject::SetRequestHandlerPolicy::ACCEPTANCE:
 149                 return g_obj_SetRequestHandlerPolicy_ACCEPT;
 150         }
 151
 152         throwRCSException(env, "Failed to convert SetRequestHandlerPolicy");
 153         return {};
 154     }
 155
 156
 157     template< typename ENV >
 158     inline jobject getAttrsObj(ENV& env, jobject responseObj)
 159     {
 160         return env->GetObjectField(responseObj, g_field_RCSResponse_mAttrs);
 161     }
 162
 163     template< typename ENV >
 164     inline int getErrorCode(ENV& env, jobject responseObj)
 165     {
 166         return env->GetIntField(responseObj, g_field_RCSResponse_mErrorCode);
 167     }
 168
 169     template< typename ENV >
 170     inline RCSSetResponse::AcceptanceMethod getAcceptanceMethod(ENV& env, jobject responseObj)
 171     {
 172         auto methodObj = env->GetObjectField(responseObj, g_field_RCSSetResponse_mAcceptanceMethod);
 173
 174         if (env->IsSameObject(methodObj, g_obj_RCSSetResponse_AcceptanceMethod_IGNORE))
 175         {
 176             return RCSSetResponse::AcceptanceMethod::IGNORE;
 177         }
 178
 179         if (env->IsSameObject(methodObj, g_obj_RCSSetResponse_AcceptanceMethod_ACCEPT))
 180         {
 181             return RCSSetResponse::AcceptanceMethod::ACCEPT;
 182         }
 183
 184         return RCSSetResponse::AcceptanceMethod::DEFAULT;
 185     }
 186
 187     inline jobject callHandler(ScopedEnvWrapper& env, jobject listener, jmethodID methodId,
 188             const RCSRequest& request, const RCSResourceAttributes& attrs)
 189     {
 190         auto requestObj = env->NewObject(g_cls_RCSRequest, g_ctor_RCSRequest,
 191                 env->NewStringUTF(request.getResourceUri().c_str()));
 192         auto attrsObj = newAttributesObject(env.get(), attrs);
 193
 194         return env->CallObjectMethod(listener, methodId, requestObj, attrsObj);
 195     }
 196
 197     template< typename RESPONSE >
 198     inline RESPONSE createResponse(ScopedEnvWrapper& env, jobject responseObj)
 199     {
 200         auto errorCode = getErrorCode(env, responseObj);
 201         auto responseAttrsObj = getAttrsObj(env, responseObj);
 202
 203         if (responseAttrsObj)
 204         {
 205             return RESPONSE::create(toNativeAttributes(env.get(), responseAttrsObj), OC_EH_OK,
 206                     errorCode);
 207         }
 208
 209         return RESPONSE::create(OC_EH_OK, errorCode);
 210     }
 211
 212     RCSGetResponse onGetRequest(const RCSRequest& request, const RCSResourceAttributes& attrs,
 213             const JavaGlobalRef& listener)
 214     {
 215         ScopedEnvWrapper env;
 216         EXPECT_RET(env, "env is null!", RCSGetResponse::create(OC_EH_ERROR, -1));
 217
 218         try
 219         {
 220             auto responseObj = callHandler(env, listener, g_method_GetRequestHandler_onGetRequested,
 221                     request, attrs);
 222
 223             return createResponse< RCSGetResponse >(env, responseObj);
 224         }
 225         catch (const JavaException&)
 226         {
 227             env->ExceptionDescribe();
 228             env->ExceptionClear();
 229         }
 230         return RCSGetResponse::create(OC_EH_ERROR, -1);
 231     }
 232
 233     RCSSetResponse onSetRequest(const RCSRequest& request, const RCSResourceAttributes& attrs,
 234              const JavaGlobalRef& listener)
 235     {
 236         ScopedEnvWrapper env;
 237         EXPECT_RET(env, "env is null!", RCSSetResponse::create(OC_EH_ERROR, -1));
 238
 239         try
 240         {
 241             auto responseObj = callHandler(env, listener, g_method_SetRequestHandler_onSetRequested,
 242                                request, attrs);
 243
 244             auto acceptanceMethod = getAcceptanceMethod(env, responseObj);
 245
 246             return createResponse< RCSSetResponse >(env, responseObj).
 247                     setAcceptanceMethod(acceptanceMethod);
 248         }
 249         catch (const JavaException&)
 250         {
 251             env->ExceptionDescribe();
 252             env->ExceptionClear();
 253         }
 254         return RCSSetResponse::create(OC_EH_ERROR, -1);
 255     }
 256
 257
 258     void onAttributeUpdated(const RCSResourceAttributes::Value& oldVal,
 259             const RCSResourceAttributes::Value& newVal, const JavaGlobalRef& listener)
 260     {
 261         ScopedEnvWrapper env;
 262         EXPECT(env, "env is null!");
 263
 264         try
 265         {
 266             env->CallVoidMethod(listener, g_method_OnAttributeUpdatedListener_onAttributeUpdated,
 267                     newRCSValueObject(env.get(), oldVal), newRCSValueObject(env.get(), newVal));
 268         }
 269         catch (const JavaException&)
 270         {
 271             env->ExceptionDescribe();
 272             env->ExceptionClear();
 273         }
 274     }
 275
 276     void initRCSResponse(JNIEnvWrapper* env)
 277     {
 278         auto clsRCSResponse = env->FindClass(CLS_NAME_RCS_RESPONSE);
 279
 280         g_field_RCSResponse_mErrorCode = env->GetFieldID(clsRCSResponse, "mErrorCode", "I");
 281
 282         g_field_RCSResponse_mAttrs = env->GetFieldID(clsRCSResponse, "mAttrs",
 283                 AS_SIG(CLS_NAME_RESOURCEATTRIBUTES));
 284
 285         auto clsRCSSetResponse = env->FindClass(CLS_NAME_RCS_SET_RESPONSE);
 286
 287         g_field_RCSSetResponse_mAcceptanceMethod = env->GetFieldID(clsRCSSetResponse,
 288                 "mAcceptanceMethod", AS_SIG(CLS_NAME_RCS_SET_RESPONSE_ACCEPTANCE_METHOD));
 289
 290         auto clsAcceptanceMethod = env->FindClass(CLS_NAME_RCS_SET_RESPONSE_ACCEPTANCE_METHOD);
 291
 292         g_obj_RCSSetResponse_AcceptanceMethod_DEFAULT = env->NewGlobalRef(
 293                 env->GetStaticObjectField(clsAcceptanceMethod, "DEFAULT",
 294                         AS_SIG(CLS_NAME_RCS_SET_RESPONSE_ACCEPTANCE_METHOD)));
 295
 296         g_obj_RCSSetResponse_AcceptanceMethod_ACCEPT = env->NewGlobalRef(
 297                 env->GetStaticObjectField(clsAcceptanceMethod, "ACCEPT",
 298                         AS_SIG(CLS_NAME_RCS_SET_RESPONSE_ACCEPTANCE_METHOD)));
 299
 300         g_obj_RCSSetResponse_AcceptanceMethod_IGNORE = env->NewGlobalRef(
 301                 env->GetStaticObjectField(clsAcceptanceMethod, "IGNORE",
 302                         AS_SIG(CLS_NAME_RCS_SET_RESPONSE_ACCEPTANCE_METHOD)));
 303     }
 304 }
 305
 306 void initRCSResourceObject(JNIEnvWrapper* env)
 307 {
 308     g_cls_RCSResourceObject = env->FindClassAsGlobalRef(CLS_NAME_RCS_RESOURCE_OBJECT);
 309
 310     g_ctor_RCSResourceObject = env->GetMethodID(g_cls_RCSResourceObject, "<init>", "()V");
 311
 312     g_cls_RCSRequest = env->FindClassAsGlobalRef(CLS_NAME_RCS_REQUEST);
 313
 314     g_ctor_RCSRequest = env->GetMethodID(g_cls_RCSRequest, "<init>",
 315             "(" AS_SIG(CLS_NAME_STRING) ")V");
 316
 317     auto clsGetRequestHandler = env->FindClass(CLS_NAME_GET_REQUEST_HANDLER);
 318
 319     g_method_GetRequestHandler_onGetRequested = env->GetMethodID(clsGetRequestHandler,
 320             "onGetRequested",
 321             "(" AS_SIG(CLS_NAME_RCS_REQUEST) AS_SIG(CLS_NAME_RESOURCEATTRIBUTES) ")"
 322                 AS_SIG(CLS_NAME_RCS_GET_RESPONSE));
 323
 324     auto clsSetRequestHandler = env->FindClass(CLS_NAME_SET_REQUEST_HANDLER);
 325
 326     g_method_SetRequestHandler_onSetRequested = env->GetMethodID(clsSetRequestHandler,
 327             "onSetRequested",
 328             "(" AS_SIG(CLS_NAME_RCS_REQUEST) AS_SIG(CLS_NAME_RESOURCEATTRIBUTES) ")"
 329                 AS_SIG(CLS_NAME_RCS_SET_RESPONSE));
 330
 331     auto clsOnAttributeUpdatedListener = env->FindClass(CLS_NAME_ON_ATTRIBUTE_UPDATESD_LISTENER);
 332
 333     g_method_OnAttributeUpdatedListener_onAttributeUpdated = env->GetMethodID(
 334             clsOnAttributeUpdatedListener, "onAttributeUpdated",
 335             "(" AS_SIG(CLS_NAME_VALUE) AS_SIG(CLS_NAME_VALUE) ")V");
 336
 337     auto clsAutoNotifyPolicy = env->FindClass(CLS_NAME_AUTO_NOTIFY_POLICY);
 338
 339     g_obj_AutoNotifyPolicy_NEVER = env->NewGlobalRef(
 340             env->GetStaticObjectField(clsAutoNotifyPolicy, "NEVER",
 341                     AS_SIG(CLS_NAME_AUTO_NOTIFY_POLICY)));
 342
 343     g_obj_AutoNotifyPolicy_ALWAYS = env->NewGlobalRef(
 344             env->GetStaticObjectField(clsAutoNotifyPolicy, "ALWAYS",
 345                     AS_SIG(CLS_NAME_AUTO_NOTIFY_POLICY)));
 346
 347
 348     g_obj_AutoNotifyPolicy_UPDATED = env->NewGlobalRef(
 349             env->GetStaticObjectField(clsAutoNotifyPolicy, "UPDATED",
 350                     AS_SIG(CLS_NAME_AUTO_NOTIFY_POLICY)));
 351
 352     auto clsSetRequestHandlerPolicy = env->FindClass(CLS_NAME_SET_REQUEST_HANDLER_POLICY);
 353
 354     g_obj_SetRequestHandlerPolicy_NEVER = env->NewGlobalRef(
 355             env->GetStaticObjectField(clsSetRequestHandlerPolicy, "NEVER",
 356                     AS_SIG(CLS_NAME_SET_REQUEST_HANDLER_POLICY)));
 357
 358     g_obj_SetRequestHandlerPolicy_ACCEPT = env->NewGlobalRef(
 359             env->GetStaticObjectField(clsSetRequestHandlerPolicy, "ACCEPT",
 360                     AS_SIG(CLS_NAME_SET_REQUEST_HANDLER_POLICY)));
 361
 362     initRCSResponse(env);
 363 }
 364
 365 void clearRCSResourceObject(JNIEnvWrapper* env)
 366 {
 367     env->DeleteGlobalRef(g_cls_RCSRequest);
 368
 369     env->DeleteGlobalRef(g_obj_RCSSetResponse_AcceptanceMethod_DEFAULT);
 370     env->DeleteGlobalRef(g_obj_RCSSetResponse_AcceptanceMethod_ACCEPT);
 371     env->DeleteGlobalRef(g_obj_RCSSetResponse_AcceptanceMethod_IGNORE);
 372
 373     env->DeleteGlobalRef(g_obj_AutoNotifyPolicy_NEVER);
 374     env->DeleteGlobalRef(g_obj_AutoNotifyPolicy_ALWAYS);
 375     env->DeleteGlobalRef(g_obj_AutoNotifyPolicy_UPDATED);
 376
 377     env->DeleteGlobalRef(g_obj_SetRequestHandlerPolicy_NEVER);
 378     env->DeleteGlobalRef(g_obj_SetRequestHandlerPolicy_ACCEPT);
 379 }
 380
 381 JNIEXPORT jint JNICALL
 382 Java_org_iotivity_service_server_RcsResponse_nativeGetDefaultErrorCode
 383 (JNIEnv*, jclass)
 384 {
 385     return RequestHandler::DEFAULT_ERROR_CODE;
 386 }
 387
 388 JNIEXPORT jobject JNICALL
 389 Java_org_iotivity_service_server_RcsResourceObject_nativeBuild
 390 (JNIEnv* env, jclass, jstring uriObj, jstring typeObj, jstring interfaceObj, jboolean isObservable,
 391         jboolean isDiscoverable, jobject attrsObj)
 392 {
 393     LOGI("nativeBuild");
 394
 395     EXPECT_RET_DEF(uriObj, "uri is null.");
 396
 397     auto uri = toStdString(env, uriObj);
 398     auto type = toStdString(env, typeObj);
 399     auto interface = toStdString(env, interfaceObj);
 400
 401     RCSResourceAttributes attrs;
 402     if (attrsObj)
 403     {
 404         attrs = toNativeAttributes(env, attrsObj);
 405         VERIFY_NO_EXC_RET_DEF(env);
 406     }
 407
 408     try
 409     {
 410         auto resource = RCSResourceObject::Builder(uri, type,interface).
 411                 setDiscoverable(isDiscoverable). setObservable(isObservable).setAttributes(attrs).
 412                 build();
 413
 414         auto resourceObj = env->NewObject(g_cls_RCSResourceObject, g_ctor_RCSResourceObject);
 415         VERIFY_NO_EXC_RET_DEF(env);
 416
 417         setSafeNativeHandle< decltype(resource) >(env, resourceObj, resource);
 418
 419         return resourceObj;
 420     }
 421     catch (const PlatformException& e)
 422     {
 423         LOGE("%s", e.what());
 424         throwPlatformException(env, e);
 425     }
 426
 427     return nullptr;
 428 }
 429
 430
 431 JNIEXPORT void JNICALL
 432 Java_org_iotivity_service_server_RcsResourceObject_nativeSetAttribute
 433 (JNIEnv* env, jobject obj, jstring keyObj, jobject valueObj)
 434 {
 435     LOGD("nativeSetAttributeInteger");
 436
 437     EXPECT(keyObj, "key is null.");
 438     EXPECT(valueObj, "value is null.");
 439
 440     auto res = getResource(env, obj);
 441     VERIFY_NO_EXC(env);
 442
 443     res->setAttribute(toStdString(env, keyObj), toNativeAttrsValue(env, valueObj));
 444 }
 445
 446 JNIEXPORT jobject JNICALL
 447 Java_org_iotivity_service_server_RcsResourceObject_nativeGetAttributeValue
 448 (JNIEnv *env, jobject obj, jstring keyObj)
 449 {
 450     LOGD("nativeGetAttributeValue");
 451
 452     EXPECT_RET_DEF(keyObj, "key is null.");
 453
 454     auto res = getResource(env, obj);
 455     VERIFY_NO_EXC_RET_DEF(env);
 456
 457     try
 458     {
 459         auto valueObj = newRCSValueObject(env, res->getAttributeValue(toStdString(env, keyObj)));
 460         VERIFY_NO_EXC_RET_DEF(env);
 461
 462         return valueObj;
 463     }
 464     catch(const InvalidKeyException& e)
 465     {
 466         return nullptr;
 467     }
 468 }
 469
 470 JNIEXPORT jboolean JNICALL
 471 Java_org_iotivity_service_server_RcsResourceObject_nativeRemoveAttribute
 472 (JNIEnv* env, jobject obj, jstring keyObj)
 473 {
 474     LOGD("nativeRemoveAttribute");
 475
 476     EXPECT_RET_DEF(keyObj, "key is null.");
 477
 478     auto res = getResource(env, obj);
 479     VERIFY_NO_EXC_RET_DEF(env);
 480
 481     return res->removeAttribute(toStdString(env, keyObj));
 482 }
 483
 484 JNIEXPORT jboolean JNICALL
 485 Java_org_iotivity_service_server_RcsResourceObject_nativeContainsAttribute
 486 (JNIEnv* env, jobject obj, jstring keyObj)
 487 {
 488     LOGD("nativeContainsAttribute");
 489
 490     EXPECT_RET_DEF(keyObj, "key is null.");
 491
 492     auto res = getResource(env, obj);
 493     VERIFY_NO_EXC_RET_DEF(env);
 494
 495     return res->containsAttribute(toStdString(env, keyObj));
 496 }
 497
 498 JNIEXPORT jobject JNICALL
 499 Java_org_iotivity_service_server_RcsResourceObject_nativeGetAttributes
 500 (JNIEnv* env, jobject obj)
 501 {
 502     LOGD("nativeGetAttributes");
 503
 504     auto res = getResource(env, obj);
 505     VERIFY_NO_EXC_RET_DEF(env);
 506
 507     RCSResourceObject::LockGuard lock{ res };
 508     return newAttributesObject(env, res->getAttributes());
 509 }
 510
 511 JNIEXPORT jboolean JNICALL
 512 Java_org_iotivity_service_server_RcsResourceObject_nativeIsObservable
 513 (JNIEnv* env, jobject obj)
 514 {
 515     LOGD("nativeIsObservable");
 516
 517     auto res = getResource(env, obj);
 518     VERIFY_NO_EXC_RET_DEF(env);
 519
 520     return res->isObservable();
 521 }
 522
 523 JNIEXPORT jboolean JNICALL
 524 Java_org_iotivity_service_server_RcsResourceObject_nativeIsDiscoverable
 525 (JNIEnv *env, jobject obj)
 526 {
 527     LOGD("nativeIsDiscoverable");
 528
 529     auto res = getResource(env, obj);
 530     VERIFY_NO_EXC_RET_DEF(env);
 531
 532     return res->isDiscoverable();
 533 }
 534
 535 JNIEXPORT void JNICALL
 536 Java_org_iotivity_service_server_RcsResourceObject_nativeSetGetRequestHandler
 537 (JNIEnv *env, jobject obj, jobject listenerObj)
 538 {
 539     LOGD("nativeSetGetRequestHandler");
 540
 541     auto res = getResource(env, obj);
 542     VERIFY_NO_EXC(env);
 543
 544     res->setGetRequestHandler(std::bind(onGetRequest, std::placeholders::_1, std::placeholders::_2,
 545             JavaGlobalRef{ env, listenerObj }));
 546 }
 547
 548 JNIEXPORT void JNICALL
 549 Java_org_iotivity_service_server_RcsResourceObject_nativeSetSetRequestHandler
 550 (JNIEnv* env, jobject obj, jobject listenerObj)
 551 {
 552     LOGD("nativeSetSetRequestHandler");
 553
 554     auto res = getResource(env, obj);
 555     VERIFY_NO_EXC(env);
 556
 557     res->setSetRequestHandler(std::bind(onSetRequest, std::placeholders::_1, std::placeholders::_2,
 558            JavaGlobalRef{ env, listenerObj }));
 559 }
 560
 561 JNIEXPORT void JNICALL
 562 Java_org_iotivity_service_server_RcsResourceObject_nativeAddAttributeUpdatedListener
 563 (JNIEnv* env, jobject obj, jstring keyObj, jobject listenerObj)
 564 {
 565     LOGD("nativeAddAttributeUpdatedListener");
 566
 567     auto res = getResource(env, obj);
 568     VERIFY_NO_EXC(env);
 569
 570     auto key = toStdString(env, keyObj);
 571     VERIFY_NO_EXC(env);
 572
 573     res->addAttributeUpdatedListener(std::move(key), std::bind(onAttributeUpdated,
 574             std::placeholders::_1, std::placeholders::_2, JavaGlobalRef{ env, listenerObj }));
 575 }
 576
 577 JNIEXPORT jboolean JNICALL
 578 Java_org_iotivity_service_server_RcsResourceObject_nativeRemoveAttributeUpdatedListener
 579 (JNIEnv* env, jobject obj, jstring keyObj)
 580 {
 581     LOGD("nativeAddAttributeUpdatedListener");
 582
 583     EXPECT_RET_DEF(keyObj, "key is null");
 584
 585     auto res = getResource(env, obj);
 586     VERIFY_NO_EXC_RET_DEF(env);
 587
 588     auto key = toStdString(env, keyObj);
 589     VERIFY_NO_EXC_RET_DEF(env);
 590
 591     return res->removeAttributeUpdatedListener(key);
 592 }
 593
 594 JNIEXPORT void JNICALL Java_org_iotivity_service_server_RcsResourceObject_nativeNotify
 595 (JNIEnv* env, jobject obj)
 596 {
 597     LOGD("nativeNotify");
 598
 599     auto res = getResource(env, obj);
 600     VERIFY_NO_EXC(env);
 601
 602     try
 603     {
 604         res->notify();
 605     }
 606     catch (const PlatformException& e) {
 607         throwPlatformException(env, e);
 608     }
 609 }
 610
 611 JNIEXPORT void JNICALL
 612 Java_org_iotivity_service_server_RcsResourceObject_nativeSetAutoNotifyPolicy
 613 (JNIEnv* env, jobject obj, jobject policyObj)
 614 {
 615     LOGD("nativeSetAutoNotifyPolicy");
 616
 617     EXPECT(policyObj, "policyObj is null");
 618
 619     auto res = getResource(env, obj);
 620     VERIFY_NO_EXC(env);
 621
 622     auto policy = convertAutoNotifyPolicy(env, policyObj);
 623     VERIFY_NO_EXC(env);
 624
 625     res->setAutoNotifyPolicy(policy);
 626 }
 627
 628 JNIEXPORT jobject JNICALL
 629 Java_org_iotivity_service_server_RcsResourceObject_nativeGetAutoNotifyPolicy
 630 (JNIEnv* env, jobject obj)
 631 {
 632     LOGD("nativeGetAutoNotifyPolicy");
 633
 634     auto res = getResource(env, obj);
 635     VERIFY_NO_EXC_RET_DEF(env);
 636
 637     return convertAutoNotifyPolicy(env, res->getAutoNotifyPolicy());
 638 }
 639
 640 JNIEXPORT void JNICALL
 641 Java_org_iotivity_service_server_RcsResourceObject_nativeSetSetRequestHandlerPolicy
 642 (JNIEnv* env, jobject obj, jobject policyObj)
 643 {
 644     LOGD("nativeSetSetRequestHandlerPolicy");
 645
 646     EXPECT(policyObj, "policyObj is null");
 647
 648     auto res = getResource(env, obj);
 649     VERIFY_NO_EXC(env);
 650
 651     auto policy = convertSetRequestHandlerPolicy(env, policyObj);
 652     VERIFY_NO_EXC(env);
 653
 654     res->setSetRequestHandlerPolicy(policy);
 655 }
 656
 657 JNIEXPORT jobject JNICALL
 658 Java_org_iotivity_service_server_RcsResourceObject_nativeGetSetRequestHandlerPolicy
 659 (JNIEnv* env, jobject obj)
 660 {
 661     LOGD("nativeGetSetRequestHandlerPolicy");
 662
 663     auto res = getResource(env, obj);
 664     VERIFY_NO_EXC_RET_DEF(env);
 665
 666     return convertSetRequestHandlerPolicy(env, res->getSetRequestHandlerPolicy());
 667 }