service/resource-encapsulation/android/service/src/main/jni/JniRcsRemoteResourceObject.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 "JniRcsRemoteResourceObject.h"
  22
  23 #include "JniRcsObject.h"
  24 #include "JniRcsResourceAttributes.h"
  25 #include "JavaClasses.h"
  26 #include "JavaExceptions.h"
  27 #include "JavaGlobalRef.h"
  28 #include "Log.h"
  29 #include "ScopedEnv.h"
  30 #include "Verify.h"
  31
  32 #include "RCSRemoteResourceObject.h"
  33
  34 using namespace OIC::Service;
  35
  36 #define LOG_TAG "JNI-RCSRemoteResourceObject"
  37
  38 #define CLS_NAME_RESOURCE_STATE CLS_NAME_REMOTERESOURCEOBJECT "$ResourceState"
  39 #define CLS_NAME_CACHE_STATE CLS_NAME_REMOTERESOURCEOBJECT "$CacheState"
  40
  41 #define CLS_NAME_ON_STATE_CHANGED_LISTENER CLS_NAME_REMOTERESOURCEOBJECT "$OnStateChangedListener"
  42 #define CLS_NAME_ON_CACHE_UPDATED_LISTENER CLS_NAME_REMOTERESOURCEOBJECT "$OnCacheUpdatedListener"
  43 #define CLS_NAME_ON_REMOTE_ATTRIBUTES_RECEIVED_LISTENER \
  44     CLS_NAME_REMOTERESOURCEOBJECT "$OnRemoteAttributesReceivedListener"
  45
  46 namespace
  47 {
  48     jclass g_cls_RCSRemoteResourceObject;
  49     jclass g_cls_ResourceState;
  50
  51     jmethodID g_ctor_RCSRemoteResourceObject;
  52
  53     jmethodID g_method_onStateChanged;
  54     jmethodID g_method_onCacheUpdated;
  55     jmethodID g_method_onAttributesReceived;
  56
  57     jobject g_obj_ResourceState_None;
  58     jobject g_obj_ResourceState_Requested;
  59     jobject g_obj_ResourceState_Alive;
  60     jobject g_obj_ResourceState_LostSignal;
  61     jobject g_obj_ResourceState_Destoryed;
  62
  63     jobject g_obj_CacheState_None;
  64     jobject g_obj_CacheState_Unready;
  65     jobject g_obj_CacheState_Ready;
  66     jobject g_obj_CacheState_LostSignal;
  67
  68
  69     inline jobjectArray toJavaStringArray(JNIEnv* env, const std::vector< std::string >& vec)
  70     {
  71         jobjectArray arrayObj = env->NewObjectArray(vec.size(), g_cls_String, nullptr);
  72         if (!arrayObj) return nullptr;
  73         for (size_t i = 0; i < vec.size(); ++i)
  74         {
  75             jstring strObj = env->NewStringUTF(vec[i].c_str());
  76             VERIFY_NO_EXC_RET_DEF(env);
  77
  78             env->SetObjectArrayElement(arrayObj, i, strObj);
  79             VERIFY_NO_EXC_RET_DEF(env);
  80
  81             env->DeleteLocalRef(strObj);
  82         }
  83         return arrayObj;
  84     }
  85
  86     template < typename ENV >
  87     inline jobject convertResourceState(ENV* env, ResourceState state)
  88     {
  89         switch (state)
  90         {
  91             case ResourceState::NONE: return g_obj_ResourceState_None;
  92             case ResourceState::REQUESTED: return g_obj_ResourceState_Requested;
  93             case ResourceState::ALIVE: return g_obj_ResourceState_Alive;
  94             case ResourceState::LOST_SIGNAL: return g_obj_ResourceState_LostSignal;
  95             case ResourceState::DESTROYED: return g_obj_ResourceState_Destoryed;
  96         }
  97
  98         throwRCSException(env, "Failed to convert ResourceState");
  99         return { };
 100     }
 101
 102     inline jobject convertCacheState(JNIEnv* env, CacheState state)
 103     {
 104         switch (state)
 105         {
 106             case CacheState::NONE: return g_obj_CacheState_None;
 107             case CacheState::UNREADY: return g_obj_CacheState_Unready;
 108             case CacheState::READY: return g_obj_CacheState_Ready;
 109             case CacheState::LOST_SIGNAL: return g_obj_CacheState_LostSignal;
 110         }
 111
 112         throwRCSException(env, "Failed to convert CacheState");
 113         return { };
 114     }
 115
 116     inline RCSRemoteResourceObject::Ptr& getResource(JNIEnv* env, jobject obj) noexcept
 117     {
 118         return getNativeHandleAs< RCSRemoteResourceObject::Ptr >(env, obj);
 119     }
 120
 121     void onStateChanged(ResourceState newState, const JavaGlobalRef& listener)
 122     {
 123         ScopedEnvWrapper env;
 124         EXPECT(env, "env is null!");
 125
 126         try
 127         {
 128             env->CallVoidMethod(listener, g_method_onStateChanged,
 129                     convertResourceState(env.get(), newState));
 130         }
 131         catch (const JavaException&)
 132         {
 133             env->ExceptionDescribe();
 134             env->ExceptionClear();
 135         }
 136     }
 137
 138     void onCacheUpdated(const RCSResourceAttributes& attrs, int eCode,
 139                         const JavaGlobalRef& listener)
 140     {
 141         LOGD("onCacheUpdated");
 142
 143         ScopedEnvWrapper env;
 144         EXPECT(env, "env is null!");
 145
 146         try
 147         {
 148             env->CallVoidMethod(listener, g_method_onCacheUpdated,
 149                     newAttributesObject(env.get(), attrs));
 150         }
 151         catch (const JavaException&)
 152         {
 153             env->ExceptionDescribe();
 154             env->ExceptionClear();
 155         }
 156     }
 157
 158     void onRemoteAttributesReceived(const RCSResourceAttributes& attrs, int errorCode,
 159             const JavaGlobalRef& listener)
 160     {
 161         ScopedEnvWrapper env;
 162         EXPECT(env, "env is null!");
 163
 164         try
 165         {
 166             env->CallVoidMethod(listener, g_method_onAttributesReceived,
 167                     newAttributesObject(env.get(), attrs), errorCode);
 168         }
 169         catch (const JavaException&)
 170         {
 171             env->ExceptionDescribe();
 172             env->ExceptionClear();
 173         }
 174     }
 175 }
 176
 177
 178 void initRCSRemoteResourceObject(JNIEnvWrapper* env)
 179 {
 180     g_cls_RCSRemoteResourceObject = env->FindClassAsGlobalRef(CLS_NAME_REMOTERESOURCEOBJECT);
 181
 182     g_ctor_RCSRemoteResourceObject = env->GetConstructorID(g_cls_RCSRemoteResourceObject, "()V");
 183
 184     auto clsOnStateChangedListener = env->FindClass(CLS_NAME_ON_STATE_CHANGED_LISTENER);
 185     g_method_onStateChanged = env->GetMethodID(clsOnStateChangedListener, "onStateChanged",
 186             "(" AS_SIG(CLS_NAME_RESOURCE_STATE) ")V");
 187
 188     auto clsOnCacheUpdatedListener = env->FindClass(CLS_NAME_ON_CACHE_UPDATED_LISTENER);
 189     g_method_onCacheUpdated = env->GetMethodID(clsOnCacheUpdatedListener, "onCacheUpdated",
 190             "(" AS_SIG(CLS_NAME_RESOURCEATTRIBUTES) "I)V");
 191
 192     auto clsOnRemoteAttributesReceivedListener =
 193             env->FindClass(CLS_NAME_ON_REMOTE_ATTRIBUTES_RECEIVED_LISTENER);
 194     g_method_onAttributesReceived = env->GetMethodID(clsOnRemoteAttributesReceivedListener,
 195             "onAttributesReceived", "(" AS_SIG(CLS_NAME_RESOURCEATTRIBUTES) "I)V");
 196
 197     auto clsResourceState = env->FindClass(CLS_NAME_RESOURCE_STATE);
 198
 199     g_obj_ResourceState_None = env->NewGlobalRef(env->GetStaticObjectField(clsResourceState,
 200             "NONE", AS_SIG(CLS_NAME_RESOURCE_STATE)));
 201
 202     g_obj_ResourceState_Requested = env->NewGlobalRef(env->GetStaticObjectField(clsResourceState,
 203             "REQUESTED", AS_SIG(CLS_NAME_RESOURCE_STATE)));
 204
 205     g_obj_ResourceState_Alive = env->NewGlobalRef(env->GetStaticObjectField(clsResourceState,
 206             "ALIVE", AS_SIG(CLS_NAME_RESOURCE_STATE)));
 207
 208     g_obj_ResourceState_LostSignal = env->NewGlobalRef(env->GetStaticObjectField(clsResourceState,
 209             "LOST_SIGNAL", AS_SIG(CLS_NAME_RESOURCE_STATE)));
 210
 211     g_obj_ResourceState_Destoryed = env->NewGlobalRef(env->GetStaticObjectField(clsResourceState,
 212             "DESTROYED", AS_SIG(CLS_NAME_RESOURCE_STATE)));
 213
 214     auto clsCacheState = env->FindClass(CLS_NAME_CACHE_STATE);
 215
 216     g_obj_CacheState_None = env->NewGlobalRef(env->GetStaticObjectField(clsCacheState,
 217             "NONE", AS_SIG(CLS_NAME_CACHE_STATE)));
 218
 219     g_obj_CacheState_Unready = env->NewGlobalRef(env->GetStaticObjectField(clsCacheState,
 220             "UNREADY", AS_SIG(CLS_NAME_CACHE_STATE)));
 221
 222     g_obj_CacheState_Ready = env->NewGlobalRef(env->GetStaticObjectField(clsCacheState,
 223             "READY", AS_SIG(CLS_NAME_CACHE_STATE)));
 224
 225     g_obj_CacheState_LostSignal = env->NewGlobalRef(env->GetStaticObjectField(clsCacheState,
 226             "LOST_SIGNAL", AS_SIG(CLS_NAME_CACHE_STATE)));
 227
 228
 229 }
 230
 231 void clearRCSRemoteResourceObject(JNIEnvWrapper* env)
 232 {
 233     env->DeleteGlobalRef(g_cls_RCSRemoteResourceObject);
 234     env->DeleteGlobalRef(g_cls_ResourceState);
 235
 236     env->DeleteGlobalRef(g_obj_ResourceState_None);
 237     env->DeleteGlobalRef(g_obj_ResourceState_Requested);
 238     env->DeleteGlobalRef(g_obj_ResourceState_Alive);
 239     env->DeleteGlobalRef(g_obj_ResourceState_LostSignal);
 240     env->DeleteGlobalRef(g_obj_ResourceState_Destoryed);
 241
 242     env->DeleteGlobalRef(g_obj_CacheState_None);
 243     env->DeleteGlobalRef(g_obj_CacheState_Unready);
 244     env->DeleteGlobalRef(g_obj_CacheState_Ready);
 245     env->DeleteGlobalRef(g_obj_CacheState_LostSignal);
 246 }
 247
 248 jobject newRemoteResourceObject(JNIEnvWrapper* env)
 249 {
 250     return env->NewObject(g_cls_RCSRemoteResourceObject, g_ctor_RCSRemoteResourceObject);
 251 }
 252
 253 JNIEXPORT jboolean JNICALL
 254 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeIsMonitoring
 255 (JNIEnv* env, jobject obj)
 256 {
 257     LOGD("nativeIsMonitoring");
 258     auto res = getResource(env, obj);
 259     VERIFY_NO_EXC_RET_DEF(env);
 260
 261     return res->isMonitoring();
 262 }
 263
 264 JNIEXPORT jboolean JNICALL
 265 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeIsCaching
 266 (JNIEnv* env, jobject obj)
 267 {
 268     LOGD("nativeIsCaching");
 269     auto res = getResource(env, obj);
 270     VERIFY_NO_EXC_RET_DEF(env);
 271
 272     return res->isCaching();
 273 }
 274
 275 JNIEXPORT jboolean JNICALL
 276 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeIsObservable
 277 (JNIEnv* env, jobject obj)
 278 {
 279     LOGD("nativeIsObservable");
 280     auto res = getResource(env, obj);
 281     VERIFY_NO_EXC_RET_DEF(env);
 282
 283     return res->isObservable();
 284 }
 285
 286 JNIEXPORT void JNICALL
 287 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeStartMonitoring
 288 (JNIEnv* env, jobject obj, jobject listener)
 289 {
 290     LOGD("nativeStartMonitoring");
 291     EXPECT(listener, "listener is null.");
 292
 293     auto res = getResource(env, obj);
 294     VERIFY_NO_EXC(env);
 295
 296     try
 297     {
 298         res->startMonitoring(
 299                 std::bind(onStateChanged, std::placeholders::_1, JavaGlobalRef{ env, listener }));
 300     }
 301     catch (const RCSBadRequestException& e)
 302     {
 303         env->ThrowNew(env->FindClass(EXC_NAME_ILLEGAL_STATE), e.what());
 304     }
 305 }
 306
 307 JNIEXPORT void JNICALL
 308 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeStopMonitoring
 309 (JNIEnv* env, jobject obj)
 310 {
 311     LOGD("nativeStopMonitoring");
 312
 313     auto res = getResource(env, obj);
 314     VERIFY_NO_EXC(env);
 315
 316     res->stopMonitoring();
 317 }
 318
 319 JNIEXPORT jobject JNICALL
 320 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetState
 321 (JNIEnv* env, jobject obj)
 322 {
 323     LOGD("nativeGetState");
 324
 325     auto res = getResource(env, obj);
 326     VERIFY_NO_EXC_RET_DEF(env);
 327
 328     return convertResourceState(env, res->getState());
 329 }
 330
 331 JNIEXPORT void JNICALL
 332 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeStartCaching
 333 (JNIEnv* env, jobject obj, jobject listener)
 334 {
 335     LOGD("nativeStartCaching");
 336
 337     auto res = getResource(env, obj);
 338     VERIFY_NO_EXC(env);
 339
 340     try
 341     {
 342         if (listener)
 343         {
 344             res->startCaching(std::bind(onCacheUpdated,
 345                     std::placeholders::_1, std::placeholders::_2,
 346                     JavaGlobalRef{ env, listener }));
 347         }
 348         else
 349         {
 350             res->startCaching();
 351         }
 352     }
 353     catch (const RCSBadRequestException& e)
 354     {
 355         env->ThrowNew(env->FindClass(EXC_NAME_ILLEGAL_STATE), e.what());
 356     }
 357 }
 358
 359 JNIEXPORT void JNICALL
 360 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeStopCaching
 361 (JNIEnv* env, jobject obj)
 362 {
 363     LOGD("nativeStopCaching");
 364
 365     auto res = getResource(env, obj);
 366     VERIFY_NO_EXC(env);
 367
 368     res->stopCaching();
 369 }
 370
 371 JNIEXPORT jobject JNICALL
 372 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetCacheState
 373 (JNIEnv* env, jobject obj)
 374 {
 375     LOGD("nativeGetCacheState");
 376
 377     auto res = getResource(env, obj);
 378     VERIFY_NO_EXC_RET_DEF(env);
 379
 380     return convertCacheState(env, res->getCacheState());
 381 }
 382
 383 JNIEXPORT jboolean JNICALL
 384 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeIsCachedAvailable
 385 (JNIEnv* env, jobject obj)
 386 {
 387     LOGD("nativeIsCachedAvailable");
 388
 389     auto res = getResource(env, obj);
 390     VERIFY_NO_EXC_RET_DEF(env);
 391
 392     try
 393     {
 394         return res->isCachedAvailable();
 395     }
 396     catch (const RCSBadRequestException& e)
 397     {
 398         env->ThrowNew(env->FindClass(EXC_NAME_ILLEGAL_STATE), e.what());
 399         return false;
 400     }
 401 }
 402
 403 JNIEXPORT jobject JNICALL
 404 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetCachedAttributes
 405 (JNIEnv* env, jobject obj)
 406 {
 407     LOGD("nativeGetCachedAttributes");
 408
 409     auto res = getResource(env, obj);
 410     VERIFY_NO_EXC_RET_DEF(env);
 411
 412     try
 413     {
 414         auto attrs = res->getCachedAttributes();
 415         VERIFY_NO_EXC_RET_DEF(env);
 416
 417         return newAttributesObject(env, attrs);
 418     }
 419     catch (const RCSBadRequestException& e)
 420     {
 421         env->ThrowNew(env->FindClass(EXC_NAME_ILLEGAL_STATE), e.what());
 422         return { };
 423     }
 424 }
 425
 426 JNIEXPORT void JNICALL
 427 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetRemoteAttributes
 428 (JNIEnv* env, jobject obj, jobject listener)
 429 {
 430     LOGD("nativeGetRemoteAttributes");
 431     EXPECT(listener, "listener is null.");
 432
 433     auto res = getResource(env, obj);
 434     VERIFY_NO_EXC(env);
 435
 436     try
 437     {
 438         res->getRemoteAttributes(std::bind(onRemoteAttributesReceived,
 439                 std::placeholders::_1, std::placeholders::_2, JavaGlobalRef{ env, listener }));
 440     }
 441     catch (const RCSPlatformException& e) {
 442         throwPlatformException(env, e);
 443     }
 444 }
 445
 446 JNIEXPORT void JNICALL
 447 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeSetRemoteAttributes
 448 (JNIEnv* env, jobject obj, jobject attrsObj, jobject listener)
 449 {
 450     LOGD("nativeSetRemoteAttributes");
 451     auto res = getResource(env, obj);
 452     VERIFY_NO_EXC(env);
 453
 454     RCSResourceAttributes attrs = toNativeAttributes(env, attrsObj);
 455     VERIFY_NO_EXC(env);
 456
 457     try
 458     {
 459         res->setRemoteAttributes(attrs, std::bind(onRemoteAttributesReceived,
 460                 std::placeholders::_1, std::placeholders::_2, JavaGlobalRef{ env, listener }));
 461     }
 462     catch (const RCSPlatformException& e) {
 463         throwPlatformException(env, e);
 464     }
 465 }
 466
 467 JNIEXPORT jstring JNICALL
 468 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetUri
 469 (JNIEnv* env, jobject obj)
 470 {
 471     LOGD("nativeGetUri");
 472
 473     auto res = getResource(env, obj);
 474     VERIFY_NO_EXC_RET_DEF(env);
 475
 476     return env->NewStringUTF(res->getUri().c_str());
 477 }
 478
 479 JNIEXPORT jstring JNICALL
 480 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetAddress
 481 (JNIEnv* env, jobject obj)
 482 {
 483     LOGD("nativeGetAddress");
 484     auto res = getResource(env, obj);
 485     VERIFY_NO_EXC_RET_DEF(env);
 486
 487     return env->NewStringUTF(res->getAddress().c_str());
 488 }
 489
 490 JNIEXPORT jobjectArray JNICALL
 491 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetTypes
 492 (JNIEnv* env, jobject obj)
 493 {
 494     LOGD("nativeGetTypes");
 495     auto res = getResource(env, obj);
 496     VERIFY_NO_EXC_RET_DEF(env);
 497
 498     return toJavaStringArray(env, res->getTypes());
 499 }
 500
 501 JNIEXPORT jobjectArray JNICALL
 502 Java_org_iotivity_service_client_RcsRemoteResourceObject_nativeGetInterfaces
 503 (JNIEnv* env, jobject obj)
 504 {
 505     LOGD("nativeGetInterfaces");
 506
 507     auto res = getResource(env, obj);
 508     VERIFY_NO_EXC_RET_DEF(env);
 509
 510     return toJavaStringArray(env, res->getInterfaces());
 511 }
 512