service/simulator/java/jni/simulator_resource_jni.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 "simulator_resource_model_jni.h"
  22 #include "simulator_exceptions_jni.h"
  23 #include "simulator_utils_jni.h"
  24 #include "jni_sharedobject_holder.h"
  25 #include "jni_listener_holder.h"
  26 #include "jni_string.h"
  27 #include "jni_vector.h"
  28
  29 #include "simulator_resource.h"
  30
  31 #define VALIDATE_OBJECT(ENV, OBJECT) if (!OBJECT){throwBadObjectException(ENV, "No corresponsing native object!"); return;}
  32 #define VALIDATE_OBJECT_RET(ENV, OBJECT, RET) if (!OBJECT){throwBadObjectException(ENV, "No corresponsing native object!"); return RET;}
  33
  34 SimulatorResourceSP SimulatorResourceToCpp(JNIEnv *env, jobject object)
  35 {
  36     JniSharedObjectHolder<SimulatorResource> *jniResource =
  37         GetHandle<JniSharedObjectHolder<SimulatorResource>>(env, object);
  38     if (jniResource)
  39         return jniResource->get();
  40     return nullptr;
  41 }
  42
  43 static jobject resourceTypeToJava(JNIEnv *env, SimulatorResource::Type type)
  44 {
  45     static jfieldID single = env->GetStaticFieldID(gSimulatorClassRefs.simulatorResourceTypeCls,
  46                              "SINGLE", "Lorg/oic/simulator/server/SimulatorResource$Type;");
  47     static jfieldID collection = env->GetStaticFieldID(gSimulatorClassRefs.simulatorResourceTypeCls,
  48                                  "COLLECTION", "Lorg/oic/simulator/server/SimulatorResource$Type;");
  49
  50     switch (type)
  51     {
  52         case SimulatorResource::Type::SINGLE_RESOURCE:
  53             return env->GetStaticObjectField(gSimulatorClassRefs.simulatorResourceTypeCls, single);
  54         case SimulatorResource::Type::COLLECTION_RESOURCE:
  55             return env->GetStaticObjectField(gSimulatorClassRefs.simulatorResourceTypeCls, collection);
  56     }
  57
  58     return nullptr;
  59 }
  60
  61 static jobject createObserverInfo(JNIEnv *env, const ObserverInfo &observerInfo)
  62 {
  63     static jmethodID observerInfoCtor = env->GetMethodID(gSimulatorClassRefs.observerCls,
  64                                         "<init>", "(ILjava/lang/String;I)V");
  65
  66     jstring address = env->NewStringUTF(observerInfo.address.c_str());
  67     jobject observer = (jobject) env->NewObject(gSimulatorClassRefs.observerCls,
  68                        observerInfoCtor, observerInfo.id, address, observerInfo.port);
  69     env->DeleteLocalRef(address);
  70
  71     return observer;
  72 }
  73
  74 static jobject createObserverInfoVector(JNIEnv *env,
  75                                         const std::vector<ObserverInfo> observersList)
  76 {
  77     jobject vectorObject = JniVector(env).toJava();
  78     if (!vectorObject)
  79         return nullptr;
  80
  81     static jmethodID addMethod = env->GetMethodID(gSimulatorClassRefs.vectorCls,
  82                                  "add", "(Ljava/lang/Object;)Z");
  83
  84     for (auto &observer : observersList)
  85         env->CallBooleanMethod(vectorObject, addMethod, createObserverInfo(env, observer));
  86
  87     return vectorObject;
  88 }
  89
  90 static void onObserverChange(jobject listener, const std::string &uri,
  91                              ObservationStatus state, const ObserverInfo &observerInfo)
  92 {
  93     JNIEnv *env = getEnv();
  94     if (!env)
  95         return;
  96
  97     jclass listenerCls = env->GetObjectClass(listener);
  98     jmethodID listenerMethod = nullptr;
  99     if (ObservationStatus::REGISTER == state)
 100     {
 101         listenerMethod = env->GetMethodID(listenerCls, "onObserverAdded",
 102                                           "(Ljava/lang/String;Lorg/oic/simulator/server/Observer;)V");
 103     }
 104     else
 105     {
 106         listenerMethod = env->GetMethodID(listenerCls, "onObserverRemoved",
 107                                           "(Ljava/lang/String;Lorg/oic/simulator/server/Observer;)V");
 108     }
 109
 110     jstring jUri = env->NewStringUTF(uri.c_str());
 111     jobject jobserver = createObserverInfo(env, observerInfo);
 112
 113     env->CallVoidMethod(listener, listenerMethod, jUri, jobserver);
 114     releaseEnv();
 115 }
 116
 117 static void onResourceModelChange(jobject listener, const std::string &uri,
 118                                   SimulatorResourceModel &resModel)
 119 {
 120     JNIEnv *env = getEnv();
 121     if (!env)
 122         return;
 123
 124     jclass listenerCls = env->GetObjectClass(listener);
 125     jmethodID listenerMethod = env->GetMethodID(listenerCls, "onResourceModelChanged",
 126                                "(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;)V");
 127
 128     jobject jResModel = simulatorResourceModelToJava(env, resModel);
 129     jstring jUri = env->NewStringUTF(uri.c_str());
 130     env->CallVoidMethod(listener, listenerMethod, jUri, jResModel);
 131     releaseEnv();
 132 }
 133
 134 #ifdef __cplusplus
 135 extern "C" {
 136 #endif
 137
 138 JNIEXPORT jstring JNICALL
 139 Java_org_oic_simulator_server_SimulatorResource_getName
 140 (JNIEnv *env, jobject object)
 141 {
 142     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 143     VALIDATE_OBJECT_RET(env, resource, nullptr)
 144
 145     return env->NewStringUTF(resource->getName().c_str());
 146 }
 147
 148 JNIEXPORT jobject JNICALL
 149 Java_org_oic_simulator_server_SimulatorResource_getType
 150 (JNIEnv *env, jobject object)
 151 {
 152     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 153     VALIDATE_OBJECT_RET(env, resource, nullptr)
 154
 155     return resourceTypeToJava(env, resource->getType());
 156 }
 157
 158 JNIEXPORT jstring JNICALL
 159 Java_org_oic_simulator_server_SimulatorResource_getURI
 160 (JNIEnv *env, jobject object)
 161 {
 162     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 163     VALIDATE_OBJECT_RET(env, resource, nullptr)
 164
 165     return env->NewStringUTF(resource->getURI().c_str());
 166 }
 167
 168 JNIEXPORT jstring JNICALL
 169 Java_org_oic_simulator_server_SimulatorResource_getResourceType
 170 (JNIEnv *env, jobject object)
 171 {
 172     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 173     VALIDATE_OBJECT_RET(env, resource, nullptr)
 174
 175     return env->NewStringUTF(resource->getResourceType().c_str());
 176 }
 177
 178 JNIEXPORT jobject JNICALL
 179 Java_org_oic_simulator_server_SimulatorResource_getInterface
 180 (JNIEnv *env, jobject object)
 181 {
 182     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 183     VALIDATE_OBJECT_RET(env, resource, nullptr)
 184
 185     std::vector<std::string> interfaces = resource->getInterface();
 186     return JniVector(env).toJava(interfaces);
 187 }
 188
 189 JNIEXPORT jboolean JNICALL
 190 Java_org_oic_simulator_server_SimulatorResource_isObservable
 191 (JNIEnv *env, jobject object)
 192 {
 193     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 194     VALIDATE_OBJECT_RET(env, resource, false)
 195
 196     return resource->isObservable();
 197 }
 198
 199 JNIEXPORT jboolean JNICALL
 200 Java_org_oic_simulator_server_SimulatorResource_isStarted
 201 (JNIEnv *env, jobject object)
 202 {
 203     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 204     VALIDATE_OBJECT_RET(env, resource, false)
 205
 206     return resource->isStarted();
 207 }
 208
 209 JNIEXPORT jobject JNICALL
 210 Java_org_oic_simulator_server_SimulatorResource_getResourceModel
 211 (JNIEnv *env, jobject object)
 212 {
 213     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 214     VALIDATE_OBJECT_RET(env, resource, nullptr)
 215
 216     SimulatorResourceModel resModel = resource->getResourceModel();
 217     return simulatorResourceModelToJava(env, resModel);
 218 }
 219
 220 JNIEXPORT void JNICALL
 221 Java_org_oic_simulator_server_SimulatorResource_setName
 222 (JNIEnv *env, jobject object, jstring name)
 223 {
 224     VALIDATE_INPUT(env, !name, "Name is null!")
 225
 226     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 227     VALIDATE_OBJECT(env, resource)
 228
 229     try
 230     {
 231         JniString jniName(env, name);
 232         resource->setName(jniName.get());
 233     }
 234     catch (InvalidArgsException &e)
 235     {
 236         throwInvalidArgsException(env, e.code(), e.what());
 237     }
 238 }
 239
 240 JNIEXPORT void JNICALL
 241 Java_org_oic_simulator_server_SimulatorResource_setURI
 242 (JNIEnv *env, jobject object, jstring uri)
 243 {
 244     VALIDATE_INPUT(env, !uri, "Uri is null!")
 245
 246     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 247     VALIDATE_OBJECT(env, resource)
 248
 249     try
 250     {
 251         JniString jniUri(env, uri);
 252         resource->setURI(jniUri.get());
 253     }
 254     catch (InvalidArgsException &e)
 255     {
 256         throwInvalidArgsException(env, e.code(), e.what());
 257     }
 258     catch (SimulatorException &e)
 259     {
 260         throwSimulatorException(env, e.code(), e.what());
 261     }
 262 }
 263
 264 JNIEXPORT void JNICALL
 265 Java_org_oic_simulator_server_SimulatorResource_setResourceType
 266 (JNIEnv *env, jobject object, jstring resourceType)
 267 {
 268     VALIDATE_INPUT(env, !resourceType, "Resource type is null!")
 269
 270     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 271     VALIDATE_OBJECT(env, resource)
 272
 273     try
 274     {
 275         JniString jniType(env, resourceType);
 276         resource->setResourceType(jniType.get());
 277     }
 278     catch (InvalidArgsException &e)
 279     {
 280         throwInvalidArgsException(env, e.code(), e.what());
 281     }
 282     catch (SimulatorException &e)
 283     {
 284         throwSimulatorException(env, e.code(), e.what());
 285     }
 286 }
 287
 288 JNIEXPORT void JNICALL
 289 Java_org_oic_simulator_server_SimulatorResource_addInterface
 290 (JNIEnv *env, jobject object, jstring interfaceType)
 291 {
 292     VALIDATE_INPUT(env, !interfaceType, "Interface type is null!")
 293
 294     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 295     VALIDATE_OBJECT(env, resource)
 296
 297     try
 298     {
 299         JniString jniInterfaceType(env, interfaceType);
 300         resource->addInterface(jniInterfaceType.get());
 301     }
 302     catch (InvalidArgsException &e)
 303     {
 304         throwInvalidArgsException(env, e.code(), e.what());
 305     }
 306     catch (NoSupportException &e)
 307     {
 308         throwNoSupportException(env, e.what());
 309     }
 310     catch (SimulatorException &e)
 311     {
 312         throwSimulatorException(env, e.code(), e.what());
 313     }
 314 }
 315
 316 JNIEXPORT void JNICALL
 317 Java_org_oic_simulator_server_SimulatorResource_removeInterface
 318 (JNIEnv *env, jobject object, jstring interfaceType)
 319 {
 320     VALIDATE_INPUT(env, !interfaceType, "Interface type is null!")
 321
 322     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 323     VALIDATE_OBJECT(env, resource)
 324
 325     JniString jniInterfaceType(env, interfaceType);
 326     resource->removeInterface(jniInterfaceType.get());
 327 }
 328
 329 JNIEXPORT void JNICALL
 330 Java_org_oic_simulator_server_SimulatorResource_addInterfaces
 331 (JNIEnv *env, jobject object, jobject interfaceType)
 332 {
 333     VALIDATE_INPUT(env, !interfaceType, "Interface type is null!")
 334
 335     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 336     VALIDATE_OBJECT(env, resource)
 337
 338     std::vector<std::string> interfaceList = JniVector(env).toCpp<std::string>(interfaceType);
 339
 340     try
 341     {
 342         resource->addInterface(interfaceList);
 343     }
 344     catch (InvalidArgsException &e)
 345     {
 346         throwInvalidArgsException(env, e.code(), e.what());
 347     }
 348     catch (NoSupportException &e)
 349     {
 350         throwNoSupportException(env, e.what());
 351     }
 352     catch (SimulatorException &e)
 353     {
 354         throwSimulatorException(env, e.code(), e.what());
 355     }
 356 }
 357
 358 JNIEXPORT void JNICALL
 359 Java_org_oic_simulator_server_SimulatorResource_removeInterfaces
 360 (JNIEnv *env, jobject object, jobject interfaceType)
 361 {
 362     VALIDATE_INPUT(env, !interfaceType, "Interface type is null!")
 363
 364     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 365     VALIDATE_OBJECT(env, resource)
 366
 367     std::vector<std::string> interfaceList = JniVector(env).toCpp<std::string>(interfaceType);
 368
 369     resource->removeInterface(interfaceList);
 370 }
 371
 372 JNIEXPORT void JNICALL
 373 Java_org_oic_simulator_server_SimulatorResource_setObservable
 374 (JNIEnv *env, jobject object, jboolean state)
 375 {
 376     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 377     VALIDATE_OBJECT(env, resource)
 378
 379     try
 380     {
 381         resource->setObservable(static_cast<bool>(state));
 382     }
 383     catch (SimulatorException &e)
 384     {
 385         throwSimulatorException(env, e.code(), e.what());
 386     }
 387 }
 388
 389 JNIEXPORT void JNICALL
 390 Java_org_oic_simulator_server_SimulatorResource_setObserverListener
 391 (JNIEnv *env, jobject object, jobject listener)
 392 {
 393     VALIDATE_CALLBACK(env, listener)
 394
 395     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 396     VALIDATE_OBJECT(env, resource)
 397
 398     SimulatorResource::ObserverCallback callback =  std::bind([](const std::string & uri,
 399             ObservationStatus state, const ObserverInfo & observerInfo,
 400             const std::shared_ptr<JniListenerHolder> &listenerRef)
 401     {
 402         onObserverChange(listenerRef->get(), uri, state, observerInfo);
 403     }, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
 404     JniListenerHolder::create(env, listener));
 405
 406     try
 407     {
 408         resource->setObserverCallback(callback);
 409     }
 410     catch (InvalidArgsException &e)
 411     {
 412         throwInvalidArgsException(env, e.code(), e.what());
 413     }
 414 }
 415
 416 JNIEXPORT void JNICALL
 417 Java_org_oic_simulator_server_SimulatorResource_setResourceModelChangeListener
 418 (JNIEnv *env, jobject object, jobject listener)
 419 {
 420     VALIDATE_CALLBACK(env, listener)
 421
 422     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 423     VALIDATE_OBJECT(env, resource)
 424
 425     SimulatorResource::ResourceModelChangedCallback callback =  std::bind(
 426                 [](const std::string & uri, SimulatorResourceModel & resModel,
 427                    const std::shared_ptr<JniListenerHolder> &listenerRef)
 428     {
 429         onResourceModelChange(listenerRef->get(), uri, resModel);
 430     }, std::placeholders::_1, std::placeholders::_2, JniListenerHolder::create(env, listener));
 431
 432     try
 433     {
 434         resource->setModelChangeCallback(callback);
 435     }
 436     catch (InvalidArgsException &e)
 437     {
 438         throwInvalidArgsException(env, e.code(), e.what());
 439     }
 440 }
 441
 442 JNIEXPORT void JNICALL
 443 Java_org_oic_simulator_server_SimulatorResource_start
 444 (JNIEnv *env, jobject object)
 445 {
 446     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 447     VALIDATE_OBJECT(env, resource)
 448
 449     try
 450     {
 451         resource->start();
 452     }
 453     catch (SimulatorException &e)
 454     {
 455         throwSimulatorException(env, e.code(), e.what());
 456     }
 457 }
 458
 459 JNIEXPORT void JNICALL
 460 Java_org_oic_simulator_server_SimulatorResource_stop
 461 (JNIEnv *env, jobject object)
 462 {
 463     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 464     VALIDATE_OBJECT(env, resource)
 465
 466     try
 467     {
 468         resource->stop();
 469     }
 470     catch (SimulatorException &e)
 471     {
 472         throwSimulatorException(env, e.code(), e.what());
 473     }
 474 }
 475
 476 JNIEXPORT jobject JNICALL
 477 Java_org_oic_simulator_server_SimulatorResource_getObservers
 478 (JNIEnv *env, jobject object)
 479 {
 480     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 481     VALIDATE_OBJECT_RET(env, resource, nullptr)
 482
 483     return createObserverInfoVector(env, resource->getObserversList());
 484 }
 485
 486 JNIEXPORT void JNICALL
 487 Java_org_oic_simulator_server_SimulatorResource_notifyObserver
 488 (JNIEnv *env, jobject object, jint id)
 489 {
 490     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 491     VALIDATE_OBJECT(env, resource)
 492
 493     try
 494     {
 495         resource->notify(id);
 496     }
 497     catch (SimulatorException &e)
 498     {
 499         throwSimulatorException(env, e.code(), e.what());
 500     }
 501 }
 502
 503 JNIEXPORT void JNICALL
 504 Java_org_oic_simulator_server_SimulatorResource_notifyAllObservers
 505 (JNIEnv *env, jobject object)
 506 {
 507     SimulatorResourceSP resource = SimulatorResourceToCpp(env, object);
 508     VALIDATE_OBJECT(env, resource)
 509
 510     try
 511     {
 512         resource->notifyAll();
 513     }
 514     catch (SimulatorException &e)
 515     {
 516         throwSimulatorException(env, e.code(), e.what());
 517     }
 518 }
 519
 520 #ifdef __cplusplus
 521 }
 522 #endif