service/notification/android/notification-service/src/main/jni/consumer/JniNotificationConsumer.cpp

   1 //******************************************************************\r
   2 //\r
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.\r
   4 //\r
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
   6 //\r
   7 // Licensed under the Apache License, Version 2.0 (the "License");\r
   8 // you may not use this file except in compliance with the License.\r
   9 // You may obtain a copy of the License at\r
  10 //\r
  11 //      http://www.apache.org/licenses/LICENSE-2.0\r
  12 //\r
  13 // Unless required by applicable law or agreed to in writing, software\r
  14 // distributed under the License is distributed on an "AS IS" BASIS,\r
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16 // See the License for the specific language governing permissions and\r
  17 // limitations under the License.\r
  18 //\r
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
  20 \r
  21 #include "JniNotificationConsumer.h"\r
  22 #include "NSConsumerService.h"\r
  23 #include "JniOcRepresentation.h"\r
  24 \r
  25 static JavaVM *g_jvm_consumer = NULL;\r
  26 \r
  27 static jobject g_obj_postListener = NULL;\r
  28 static jobject g_obj_syncListener = NULL;\r
  29 static jobject g_obj_discoverListener = NULL;\r
  30 static jobject g_obj_acceptListener = NULL;\r
  31 \r
  32 jclass g_cls_Message;\r
  33 jclass g_cls_Provider;\r
  34 jclass g_cls_SyncInfo;\r
  35 jclass g_cls_SyncType;\r
  36 jclass g_cls_MediaContents;\r
  37 jclass g_cls_TopicState;\r
  38 jclass g_cls_Message_Type;\r
  39 jclass g_cls_ProviderState;\r
  40 jclass g_cls_Topic;\r
  41 jclass g_cls_TopicsList;\r
  42 jclass g_cls_OcRepresentation;\r
  43 jmethodID g_mid_OcRepresentation_N_ctor_bool = NULL;\r
  44 \r
  45 static JNIEnv *GetJNIEnv(jint *ret)\r
  46 {\r
  47     JNIEnv *env = NULL;\r
  48 \r
  49     *ret = g_jvm_consumer->GetEnv((void **) &env, JNI_CURRENT_VERSION);\r
  50     switch (*ret)\r
  51     {\r
  52         case JNI_OK:\r
  53             return env;\r
  54         case JNI_EDETACHED:\r
  55             if (g_jvm_consumer->AttachCurrentThread(&env, NULL) != JNI_OK)\r
  56             {\r
  57                 NS_LOGE ("Failed to get the environment");\r
  58                 return NULL;\r
  59             }\r
  60             else\r
  61             {\r
  62                 return env;\r
  63             }\r
  64         case JNI_EVERSION:\r
  65             NS_LOGE ("JNI version is not supported");\r
  66             return NULL;\r
  67         default:\r
  68             NS_LOGE ("Failed to get the environment");\r
  69             return NULL;\r
  70     }\r
  71 }\r
  72 \r
  73 jobject getJavaProviderState(JNIEnv *env, OIC::Service::NSProviderState state)\r
  74 {\r
  75     NS_LOGD ("ConsumerService_getJavaProviderState - IN");\r
  76     jobject providerState = NULL;\r
  77     switch (state)\r
  78     {\r
  79         case OIC::Service::NSProviderState::ALLOW:\r
  80             {\r
  81                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState,\r
  82                                           "ALLOW", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;");\r
  83                 providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID);\r
  84                 break;\r
  85             }\r
  86         case OIC::Service::NSProviderState::DENY:\r
  87             {\r
  88                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState,\r
  89                                           "DENY", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;");\r
  90                 providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID);\r
  91                 break;\r
  92             }\r
  93         case OIC::Service::NSProviderState::TOPIC:\r
  94             {\r
  95                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState,\r
  96                                           "TOPIC", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;");\r
  97                 providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID);\r
  98                 break;\r
  99             }\r
 100         case OIC::Service::NSProviderState::STOPPED:\r
 101             {\r
 102                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState,\r
 103                                           "STOPPED", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;");\r
 104                 providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID);\r
 105                 break;\r
 106             }\r
 107         default:\r
 108             {\r
 109                 providerState = NULL;\r
 110                 break;\r
 111             }\r
 112     }\r
 113     NS_LOGD ("ConsumerService_getJavaProviderState - OUT");\r
 114     return providerState;\r
 115 }\r
 116 \r
 117 jobject getJavaSyncType(JNIEnv *env, OIC::Service::NSSyncInfo::NSSyncType nsType)\r
 118 {\r
 119     NS_LOGD ("ConsumerService_getJavaSyncType - IN");\r
 120 \r
 121     // SyncType\r
 122     jclass cls_SyncType = (jclass) (env->NewLocalRef(g_cls_SyncType));\r
 123     if (!cls_SyncType)\r
 124     {\r
 125         NS_LOGE ("Failed to Get ObjectClass for SyncType");\r
 126         return NULL;\r
 127     }\r
 128     jobject syncType = NULL;\r
 129     switch (nsType)\r
 130     {\r
 131         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_UNREAD:\r
 132             {\r
 133                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,\r
 134                                           "UNREAD", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");\r
 135                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);\r
 136                 break;\r
 137             }\r
 138         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ :\r
 139             {\r
 140                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,\r
 141                                           "READ", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");\r
 142                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);\r
 143                 break;\r
 144             }\r
 145         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED :\r
 146             {\r
 147                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,\r
 148                                           "DELETED", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");\r
 149                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);\r
 150                 break;\r
 151             }\r
 152         default:\r
 153             {\r
 154                 syncType = NULL;\r
 155                 break;\r
 156             }\r
 157     }\r
 158 \r
 159     NS_LOGD ("ConsumerService_getJavaSyncType - OUT");\r
 160     return syncType;\r
 161 }\r
 162 \r
 163 jobject getJavaTopicState(JNIEnv *env, OIC::Service::NSTopic::NSTopicState nsState)\r
 164 {\r
 165     NS_LOGD ("ConsumerService_getJavaTopicState - IN");\r
 166 \r
 167     // TopicState\r
 168     jclass cls_topicState = (jclass) (env->NewLocalRef(g_cls_TopicState));\r
 169     if (!cls_topicState)\r
 170     {\r
 171         NS_LOGE ("Failed to Get ObjectClass for TopicState Type");\r
 172         return NULL;\r
 173     }\r
 174     jobject topicState = NULL;\r
 175 \r
 176     switch (nsState)\r
 177     {\r
 178         case OIC::Service::NSTopic::NSTopicState::UNSUBSCRIBED:\r
 179             {\r
 180                 static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,\r
 181                                           "UNSUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");\r
 182                 topicState = env->GetStaticObjectField(cls_topicState, fieldID);\r
 183                 break;\r
 184             }\r
 185         case OIC::Service::NSTopic::NSTopicState::SUBSCRIBED:\r
 186             {\r
 187                 static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,\r
 188                                           "SUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");\r
 189                 topicState = env->GetStaticObjectField(cls_topicState, fieldID);\r
 190                 break;\r
 191             }\r
 192         default:\r
 193             {\r
 194                 topicState = NULL;\r
 195                 break;\r
 196             }\r
 197     }\r
 198 \r
 199     NS_LOGD ("ConsumerService_getJavaTopicState - OUT");\r
 200     return topicState;\r
 201 }\r
 202 \r
 203 jobject getJavaTopicsList(JNIEnv *env, std::shared_ptr<OIC::Service::NSTopicsList> topicList)\r
 204 {\r
 205     NS_LOGD ("ConsumerService_getJavaTopicsList - IN");\r
 206     jclass cls_topicList = (jclass) (env->NewLocalRef(g_cls_TopicsList));\r
 207     if (!cls_topicList)\r
 208     {\r
 209         NS_LOGE ("Failed to Get ObjectClass for TopicsList");\r
 210         return NULL;\r
 211     }\r
 212     jmethodID mid_topicList = env->GetMethodID(cls_topicList, "<init>", "()V");\r
 213     if (!mid_topicList)\r
 214     {\r
 215         NS_LOGE ("Failed to Get MethodID for TopicsList<init>");\r
 216         return NULL;\r
 217     }\r
 218     jobject obj_topicList = env->NewObject(cls_topicList, mid_topicList);\r
 219     if (!obj_topicList)\r
 220     {\r
 221         NS_LOGE ("Failed to Get object for TopicsList");\r
 222         return NULL;\r
 223     }\r
 224     jmethodID mid_addTopic = env->GetMethodID(cls_topicList, "addTopic",\r
 225                              "(Ljava/lang/String;Lorg/iotivity/service/ns/common/Topic$TopicState;)V");\r
 226     if (!mid_addTopic)\r
 227     {\r
 228         NS_LOGE ("Failed to Get MethodID for addTopic");\r
 229         return NULL;\r
 230     }\r
 231     for (auto it : topicList->getTopicsList())\r
 232     {\r
 233         jobject jState = getJavaTopicState(env, it.getState());\r
 234         std::string topicName = it.getTopicName();\r
 235         jstring jTopicName = env->NewStringUTF(topicName.c_str());\r
 236         env->CallVoidMethod(obj_topicList, mid_addTopic, jTopicName, jState);\r
 237     }\r
 238     env->DeleteLocalRef(cls_topicList);\r
 239     NS_LOGD ("ConsumerService_getJavaTopicsList - OUT");\r
 240     return obj_topicList;\r
 241 }\r
 242 \r
 243 bool getNativeTopicState(JNIEnv *env,  jobject jTopic , OIC::Service::NSTopic::NSTopicState &state )\r
 244 {\r
 245     NS_LOGD ("ConsumerService_getNativeTopicState - IN");\r
 246 \r
 247     jclass cls_topic = env->GetObjectClass( jTopic);\r
 248     // TopicState\r
 249     jclass cls_TopicState = (jclass) (env->NewLocalRef(g_cls_TopicState));\r
 250     if (!cls_TopicState)\r
 251     {\r
 252         NS_LOGE ("Failed to Get ObjectClass for cls_TopicState Type");\r
 253         return false;\r
 254     }\r
 255     jmethodID mid = env->GetMethodID(cls_TopicState, "ordinal", "()I");\r
 256     jfieldID fid_state = env->GetFieldID( cls_topic, "mState",\r
 257                                           "Lorg/iotivity/service/ns/common/Topic$TopicState;");\r
 258     if (fid_state == NULL)\r
 259     {\r
 260         NS_LOGE ("Error: jfieldID for state type  is null");\r
 261         return false;\r
 262     }\r
 263     jobject jobj = env->GetObjectField( jTopic, fid_state);\r
 264     if (jobj == NULL)\r
 265     {\r
 266         NS_LOGE ("Error: object of field  state Type is null");\r
 267         return false;\r
 268     }\r
 269     jint jState = env->CallIntMethod(jobj, mid);\r
 270     state = (OIC::Service::NSTopic::NSTopicState) jState;\r
 271     NS_LOGD ("ConsumerService_getNativeTopicState - OUT");\r
 272     return true;\r
 273 \r
 274 }\r
 275 \r
 276 const char *getNativeTopicName(JNIEnv *env,  jobject jTopic)\r
 277 {\r
 278     NS_LOGD ("ConsumerService_getNativeTopicName - IN");\r
 279     jclass cls_topic = env->GetObjectClass( jTopic);\r
 280     if (cls_topic == NULL)\r
 281     {\r
 282         NS_LOGE ("Error: Class for Topic is null");\r
 283         return nullptr;\r
 284     }\r
 285     jfieldID fid_name = env->GetFieldID( cls_topic, "mTopicName", "Ljava/lang/String;");\r
 286     if (fid_name == NULL)\r
 287     {\r
 288         NS_LOGE ("Error: jfieldID for Topic Name  is null");\r
 289         return nullptr;\r
 290     }\r
 291     jstring jTopicName = (jstring) env->GetObjectField( jTopic, fid_name);\r
 292     const char *topicName = NULL;\r
 293     if (jTopicName)\r
 294     {\r
 295         topicName = env->GetStringUTFChars( jTopicName, NULL);\r
 296     }\r
 297     else\r
 298     {\r
 299         NS_LOGI (TAG, "Info: topicName is null");\r
 300     }\r
 301     NS_LOGD ("ConsumerService_getNativeTopicName - OUT");\r
 302     return topicName;\r
 303 \r
 304 }\r
 305 \r
 306 std::shared_ptr<OIC::Service::NSTopicsList> getNativeTopicsList(JNIEnv *env, jobject jTopicList)\r
 307 {\r
 308     NS_LOGD ("ConsumerService_getNativeTopicsList - IN");\r
 309 \r
 310     jclass cls_topicList = env->GetObjectClass( jTopicList);\r
 311     if (cls_topicList == NULL)\r
 312     {\r
 313         NS_LOGE ("Error: Class for Topic List  is null");\r
 314         return nullptr;\r
 315     }\r
 316     jfieldID fid_list = env->GetFieldID( cls_topicList, "mTopicsList", "Ljava/util/Vector;");\r
 317     if (fid_list == NULL)\r
 318     {\r
 319         NS_LOGE ("Error: jfieldID for Topic List  is null");\r
 320         return nullptr;\r
 321     }\r
 322     jobject jobj = env->GetObjectField( jTopicList, fid_list);\r
 323     if (jobj == NULL)\r
 324     {\r
 325         NS_LOGE ("Error: object of field  Topic List is null");\r
 326         return nullptr;\r
 327     }\r
 328     jclass cls_vec = env->FindClass("java/util/Vector");\r
 329     if (cls_vec == NULL)\r
 330     {\r
 331         NS_LOGE ("Error: Class for Vector not found");\r
 332         return nullptr;\r
 333     }\r
 334     jmethodID sizeMethod = env->GetMethodID(cls_vec,  "size", "()I");\r
 335     if (sizeMethod == NULL)\r
 336     {\r
 337         NS_LOGE ("Error: MethodId for Vector Size  not found");\r
 338         return nullptr;\r
 339     }\r
 340     int size = env->CallIntMethod(jobj, sizeMethod);\r
 341     jmethodID getMethod = env->GetMethodID(cls_vec,  "get", "(I)Ljava/lang/Object;");\r
 342     if (getMethod == NULL)\r
 343     {\r
 344         NS_LOGE ("Error: MethodId for Vector get  not found");\r
 345         return nullptr;\r
 346     }\r
 347     std::shared_ptr<OIC::Service::NSTopicsList> nsTopicList = std::make_shared<OIC::Service::NSTopicsList>();\r
 348     for (int index = 0; index < size; index++)\r
 349     {\r
 350         jobject topicObj = env->CallObjectMethod(jobj, getMethod, index);\r
 351         if (topicObj == NULL)\r
 352         {\r
 353             NS_LOGE ("Error: object of field  Topic  is null");\r
 354             return nullptr;\r
 355         }\r
 356         const char *name =  getNativeTopicName(env, topicObj);\r
 357         if (name == nullptr)\r
 358         {\r
 359             NS_LOGE ("Error: Couldn't find topic Name");\r
 360             return nullptr;\r
 361         }\r
 362         std::string topicName(name);\r
 363         OIC::Service::NSTopic::NSTopicState state = OIC::Service::NSTopic::NSTopicState::UNSUBSCRIBED;\r
 364         if (!getNativeTopicState(env, topicObj, state))\r
 365         {\r
 366             return nullptr;\r
 367         }\r
 368         nsTopicList->addTopic(topicName, state);\r
 369     }\r
 370 \r
 371     env->DeleteLocalRef(cls_vec);\r
 372     env->DeleteLocalRef(cls_topicList);\r
 373     NS_LOGD ("ConsumerService_getNativeTopicsList - OUT");\r
 374     return nsTopicList;\r
 375 }\r
 376 \r
 377 std::shared_ptr<OIC::Service::NSProvider> getNativeProvider(JNIEnv *env, jobject jObj)\r
 378 {\r
 379     NS_LOGD ("ConsumerService_getNativeProvider - IN");\r
 380     jclass providerClass = env->GetObjectClass(jObj);\r
 381     if (!providerClass)\r
 382     {\r
 383         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
 384         return NULL;\r
 385     }\r
 386     jfieldID jproviderId = env->GetFieldID(providerClass, "mProviderId", "Ljava/lang/String;");\r
 387     if (!jproviderId)\r
 388     {\r
 389         ThrowNSException(JNI_INVALID_VALUE, "Failed to get providerId for Provider");\r
 390         return NULL;\r
 391     }\r
 392     jstring jprovider_id = (jstring) env->GetObjectField(jObj, jproviderId);\r
 393     if (!jprovider_id)\r
 394     {\r
 395         ThrowNSException(JNI_INVALID_VALUE, "ProviderId cannot be null");\r
 396         return NULL;\r
 397     }\r
 398 \r
 399     const char *providerId = env->GetStringUTFChars(jprovider_id, 0);\r
 400     NS_LOGD ("ProviderId : %s\n", providerId);\r
 401 \r
 402     std::shared_ptr<OIC::Service::NSProvider> provider =\r
 403         OIC::Service::NSConsumerService::getInstance()->getProvider(std::string(\r
 404                     providerId));\r
 405     if (provider == nullptr)\r
 406     {\r
 407         ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
 408         return NULL;\r
 409     }\r
 410     env->ReleaseStringUTFChars(jprovider_id, providerId);\r
 411     NS_LOGD ("ConsumerService_getNativeProvider - OUT");\r
 412     return provider;\r
 413 }\r
 414 \r
 415 jobject getJavaProvider(JNIEnv *env, std::shared_ptr<OIC::Service::NSProvider> provider)\r
 416 {\r
 417     NS_LOGD ("ConsumerService_getJavaProvider - IN");\r
 418     NS_LOGD ("ProviderId : %s\n", provider->getProviderId().c_str());\r
 419 \r
 420     jstring jProviderId = env->NewStringUTF(provider->getProviderId().c_str());\r
 421     auto *objectHolder = JniSharedObjectHolder<OIC::Service::NSProvider>::create(provider);\r
 422     if (!objectHolder)\r
 423     {\r
 424         NS_LOGE ("Failed to create new Object Holder for Provider");\r
 425         return NULL;\r
 426     }\r
 427     jlong pProvider = (long)objectHolder;\r
 428 \r
 429     jclass cls_provider = (jclass) (env->NewLocalRef(g_cls_Provider));\r
 430     if (!cls_provider)\r
 431     {\r
 432         NS_LOGE ("Failed to Get ObjectClass for Provider");\r
 433         return NULL;\r
 434     }\r
 435     jmethodID mid_provider = env->GetMethodID(\r
 436                                  cls_provider, "<init>", "(Ljava/lang/String;)V");\r
 437     if (!mid_provider)\r
 438     {\r
 439         NS_LOGE ("Failed to Get MethodID for Provider<init>");\r
 440         return NULL;\r
 441     }\r
 442     jobject obj_provider = env->NewObject(cls_provider, mid_provider, jProviderId);\r
 443     if (!obj_provider)\r
 444     {\r
 445         NS_LOGE ("Failed to create new Object for Provider");\r
 446         return NULL;\r
 447     }\r
 448 \r
 449     jfieldID nativeHandle = env->GetFieldID(cls_provider, "mNativeHandle", "J");\r
 450     if (!nativeHandle)\r
 451     {\r
 452         NS_LOGE ("Failed to get nativeHandle for Provider");\r
 453         return NULL;\r
 454     }\r
 455     env->SetLongField(obj_provider, nativeHandle, pProvider);\r
 456 \r
 457     env->DeleteLocalRef(cls_provider);\r
 458     NS_LOGD ("ConsumerService_getJavaProvider - OUT");\r
 459     return obj_provider;\r
 460 }\r
 461 \r
 462 jobject getJavaMessageType(JNIEnv *env, OIC::Service::NSMessage::NSMessageType type)\r
 463 {\r
 464     NS_LOGD ("ConsumerService_getJavaMessageType - IN");\r
 465     jobject messageType = NULL;\r
 466     switch (type)\r
 467     {\r
 468         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_ALERT:\r
 469             {\r
 470                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,\r
 471                                           "ALERT", "Lorg/iotivity/service/ns/common/Message$MessageType;");\r
 472                 messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);\r
 473                 break;\r
 474             }\r
 475         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_NOTICE:\r
 476             {\r
 477                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,\r
 478                                           "NOTICE", "Lorg/iotivity/service/ns/common/Message$MessageType;");\r
 479                 messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);\r
 480                 break;\r
 481             }\r
 482         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_EVENT:\r
 483             {\r
 484                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,\r
 485                                           "EVENT", "Lorg/iotivity/service/ns/common/Message$MessageType;");\r
 486                 messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);\r
 487                 break;\r
 488             }\r
 489         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_INFO:\r
 490             {\r
 491                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,\r
 492                                           "INFO", "Lorg/iotivity/service/ns/common/Message$MessageType;");\r
 493                 messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);\r
 494                 break;\r
 495             }\r
 496         default:\r
 497             {\r
 498                 messageType = NULL;\r
 499                 break;\r
 500             }\r
 501     }\r
 502     NS_LOGD ("ConsumerService_getJavaMessageType - OUT");\r
 503     return messageType;\r
 504 }\r
 505 \r
 506 jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage message)\r
 507 {\r
 508     NS_LOGD ("ConsumerService_getJavaMessage - IN");\r
 509 \r
 510     NS_LOGD ("id : %llu\n", message.getMessageId());\r
 511     NS_LOGD ("title : %s\n", message.getTitle().c_str());\r
 512     NS_LOGD ("content : %s\n", message.getContentText().c_str());\r
 513     NS_LOGD ("source : %s\n", message.getSourceName().c_str());\r
 514 \r
 515     jlong jMessageId = (jlong) message.getMessageId();\r
 516     jstring jProviderId = env->NewStringUTF(message.getProviderId().c_str());\r
 517     jstring jTitle = env->NewStringUTF(message.getTitle().c_str());\r
 518     jstring jContentText = env->NewStringUTF(message.getContentText().c_str());\r
 519     jstring jSourceName = env->NewStringUTF(message.getSourceName().c_str());\r
 520     jstring jTopic = env->NewStringUTF(message.getTopic().c_str());\r
 521 \r
 522     jstring jTime = env->NewStringUTF(message.getTime().c_str());\r
 523     jlong jTTL = (jlong) message.getTTL();\r
 524 \r
 525     jclass cls_message = (jclass) (env->NewLocalRef(g_cls_Message));\r
 526     if (!cls_message)\r
 527     {\r
 528         NS_LOGE ("Failed to Get ObjectClass for Message");\r
 529         return NULL ;\r
 530     }\r
 531     jmethodID mid_message = env->GetMethodID(\r
 532                                 cls_message, "<init>",\r
 533                                 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");\r
 534     if (!mid_message)\r
 535     {\r
 536         NS_LOGE ("Failed to Get MethodID for Message<init>");\r
 537         return NULL;\r
 538     }\r
 539     jobject obj_message = env->NewObject(cls_message, mid_message,\r
 540                                          jTitle, jContentText, jSourceName);\r
 541     if (!obj_message)\r
 542     {\r
 543         NS_LOGE ("Failed to Get Java Object for Message");\r
 544         return NULL;\r
 545     }\r
 546 \r
 547     jfieldID fid_messageId = env->GetFieldID(cls_message, "mMessageId", "J");\r
 548     if (!fid_messageId)\r
 549     {\r
 550         NS_LOGE ("Failed to get field MessageID for Message");\r
 551         return NULL;\r
 552     }\r
 553     env->SetLongField(obj_message, fid_messageId, jMessageId);\r
 554 \r
 555     jfieldID fid_providerId = env->GetFieldID(cls_message, "mProviderId", "Ljava/lang/String;");\r
 556     if (!fid_providerId)\r
 557     {\r
 558         NS_LOGE ("Failed to get field ProviderID for Message");\r
 559         return NULL;\r
 560     }\r
 561     env->SetObjectField(obj_message, fid_providerId, jProviderId);\r
 562 \r
 563     jfieldID fid_time = env->GetFieldID(cls_message, "mTime", "Ljava/lang/String;");\r
 564     if (!fid_time)\r
 565     {\r
 566         NS_LOGE ("Failed to get field Time for Message");\r
 567         return NULL;\r
 568     }\r
 569     env->SetObjectField(obj_message, fid_time, jTime);\r
 570 \r
 571     jfieldID fid_ttl = env->GetFieldID(cls_message, "mTTL", "J");\r
 572     if (!fid_ttl)\r
 573     {\r
 574         NS_LOGE ("Failed to get field TTL for Message");\r
 575         return NULL;\r
 576     }\r
 577     env->SetLongField(obj_message, fid_ttl, jTTL);\r
 578 \r
 579     jfieldID fid_topic = env->GetFieldID(cls_message, "mTopic", "Ljava/lang/String;");\r
 580     if (!fid_topic)\r
 581     {\r
 582         NS_LOGE ("Failed to get mTopic for Message");\r
 583         return NULL;\r
 584     }\r
 585     env->SetObjectField(obj_message, fid_topic, jTopic);\r
 586 \r
 587     OIC::Service::NSMediaContents *mediaCont = message.getMediaContents();\r
 588     if (mediaCont != nullptr)\r
 589     {\r
 590         jstring jIconImage = env->NewStringUTF(mediaCont->getIconImage().c_str());\r
 591         jclass cls_mediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));\r
 592         if (!cls_mediaContents)\r
 593         {\r
 594             NS_LOGE ("Failed to Get ObjectClass for MediaContents");\r
 595             return NULL;\r
 596         }\r
 597         jmethodID mid_mediaContents = env->GetMethodID(\r
 598                                           cls_mediaContents, "<init>", "(Ljava/lang/String;)V");\r
 599         if (!mid_mediaContents)\r
 600         {\r
 601             NS_LOGE ("Failed to Get MethodID for MediaContents<init>");\r
 602             return NULL;\r
 603         }\r
 604         jobject obj_mediaContents = env->NewObject(cls_mediaContents, mid_mediaContents,\r
 605                                     jIconImage);\r
 606 \r
 607         jfieldID fid_mediaContents = env->GetFieldID(cls_message, "mMediaContents",\r
 608                                      "Lorg/iotivity/service/ns/common/MediaContents;");\r
 609         if (!fid_mediaContents)\r
 610         {\r
 611             NS_LOGE ("Failed to get field mediaContents for Message");\r
 612             return NULL;\r
 613         }\r
 614         env->SetObjectField(obj_message, fid_mediaContents, obj_mediaContents);\r
 615 \r
 616     }\r
 617 \r
 618     jobject jType = getJavaMessageType(env, message.getType());\r
 619     if (jType)\r
 620     {\r
 621         jfieldID fid_type = env->GetFieldID(cls_message, "mType",\r
 622                                             "Lorg/iotivity/service/ns/common/Message$MessageType;");\r
 623         if (!fid_type)\r
 624         {\r
 625             NS_LOGE ("Failed to get field Type for Message");\r
 626             return NULL;\r
 627         }\r
 628         env->SetObjectField(obj_message, fid_type, jType);\r
 629     }\r
 630 \r
 631     NS_LOGD ("Reading OCRepresentation Object from Native");\r
 632 \r
 633     OC::OCRepresentation *ocRepresentation = new OC::OCRepresentation(message.getExtraInfo());\r
 634     jlong handle = reinterpret_cast<jlong>(ocRepresentation);\r
 635     jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,\r
 636                               handle, true);\r
 637     if (!jRepresentation)\r
 638     {\r
 639         NS_LOGE ("Failed to create OcRepresentation");\r
 640         delete ocRepresentation;\r
 641     }\r
 642     else\r
 643     {\r
 644         NS_LOGD ("Created OCRepresentation Object from Native");\r
 645     }\r
 646     jfieldID fid_extraInfo = env->GetFieldID(cls_message, "mExtraInfo",\r
 647                              "Lorg/iotivity/base/OcRepresentation;");\r
 648     if (!fid_extraInfo)\r
 649     {\r
 650         NS_LOGE ("Failed to get mExtraInfo for Message");\r
 651         delete ocRepresentation;\r
 652         return NULL;\r
 653     }\r
 654     NS_LOGD ("setting extraInfo field");\r
 655     env->SetObjectField(obj_message, fid_extraInfo, jRepresentation);\r
 656 \r
 657     env->DeleteLocalRef(cls_message);\r
 658     NS_LOGD ("ConsumerService_getJavaMessage - OUT");\r
 659     return obj_message;\r
 660 }\r
 661 \r
 662 void onDiscoverProvider(std::shared_ptr<OIC::Service::NSProvider> provider)\r
 663 {\r
 664     NS_LOGD ("ConsumerService_onDiscoverProvider - IN");\r
 665 \r
 666     jint envRet = 0;;\r
 667     JNIEnv *env = GetJNIEnv(&envRet);\r
 668     if (NULL == env)\r
 669     {\r
 670         return ;\r
 671     }\r
 672 \r
 673     jobject jDiscoverListener = (jobject) env->NewLocalRef(g_obj_discoverListener);\r
 674     if (!jDiscoverListener)\r
 675     {\r
 676         NS_LOGE ("Failed to Get jDiscoverListener");\r
 677         if (JNI_EDETACHED == envRet)\r
 678         {\r
 679             g_jvm_consumer->DetachCurrentThread();\r
 680         }\r
 681         return ;\r
 682     }\r
 683 \r
 684     jobject obj_provider = getJavaProvider(env, provider);\r
 685     if (!obj_provider)\r
 686     {\r
 687         NS_LOGE ("Failed to Get Provider Object");\r
 688         if (JNI_EDETACHED == envRet)\r
 689         {\r
 690             g_jvm_consumer->DetachCurrentThread();\r
 691         }\r
 692         return ;\r
 693     }\r
 694 \r
 695     jclass cls = env->GetObjectClass(jDiscoverListener);\r
 696     if (!cls)\r
 697     {\r
 698         NS_LOGE ("Failed to Get ObjectClass for jDiscoverListener");\r
 699         if (JNI_EDETACHED == envRet)\r
 700         {\r
 701             g_jvm_consumer->DetachCurrentThread();\r
 702         }\r
 703         return ;\r
 704     }\r
 705     jmethodID mid = env->GetMethodID(\r
 706                         cls,\r
 707                         "onProviderDiscovered",\r
 708                         "(Lorg/iotivity/service/ns/consumer/Provider;)V");\r
 709     if (!mid)\r
 710     {\r
 711         NS_LOGE ("Failed to Get MethodID for onProviderDiscovered");\r
 712         if (JNI_EDETACHED == envRet)\r
 713         {\r
 714             g_jvm_consumer->DetachCurrentThread();\r
 715         }\r
 716         return ;\r
 717     }\r
 718 \r
 719     env->CallVoidMethod(jDiscoverListener, mid, obj_provider);\r
 720 \r
 721     env->DeleteLocalRef(jDiscoverListener);\r
 722     if (JNI_EDETACHED == envRet)\r
 723     {\r
 724         g_jvm_consumer->DetachCurrentThread();\r
 725     }\r
 726     NS_LOGD ("ConsumerService_onDiscoverProvider - OUT");\r
 727     return ;\r
 728 }\r
 729 \r
 730 void onProviderState( OIC::Service::NSProviderState state)\r
 731 {\r
 732     NS_LOGD ("ConsumerService_onProviderState -IN");\r
 733 \r
 734     jint envRet = 0;;\r
 735     JNIEnv *env = GetJNIEnv(&envRet);\r
 736     if (NULL == env)\r
 737     {\r
 738         return ;\r
 739     }\r
 740 \r
 741     jobject jAcceptListener = (jobject) env->NewLocalRef(g_obj_acceptListener);\r
 742     if (!jAcceptListener)\r
 743     {\r
 744         NS_LOGE ("Failed to Get jAcceptListener");\r
 745         if (JNI_EDETACHED == envRet)\r
 746         {\r
 747             g_jvm_consumer->DetachCurrentThread();\r
 748         }\r
 749         return ;\r
 750     }\r
 751     jobject obj_state = getJavaProviderState(env, state);\r
 752     if (!obj_state)\r
 753     {\r
 754         NS_LOGE ("Failed to Get ProviderState Object");\r
 755         if (JNI_EDETACHED == envRet)\r
 756         {\r
 757             g_jvm_consumer->DetachCurrentThread();\r
 758         }\r
 759         return ;\r
 760     }\r
 761 \r
 762     jclass cls = env->GetObjectClass(jAcceptListener);\r
 763     if (!cls)\r
 764     {\r
 765         NS_LOGE ("Failed to Get ObjectClass for jAcceptListener");\r
 766         if (JNI_EDETACHED == envRet)\r
 767         {\r
 768             g_jvm_consumer->DetachCurrentThread();\r
 769         }\r
 770         return ;\r
 771     }\r
 772     jmethodID mid = env->GetMethodID(\r
 773                         cls,\r
 774                         "onProviderStateReceived",\r
 775                         "(Lorg/iotivity/service/ns/consumer/Provider$ProviderState;)V");\r
 776     if (!mid)\r
 777     {\r
 778         NS_LOGE ("Failed to Get MethodID for onProviderState");\r
 779         if (JNI_EDETACHED == envRet)\r
 780         {\r
 781             g_jvm_consumer->DetachCurrentThread();\r
 782         }\r
 783         return ;\r
 784     }\r
 785     env->CallVoidMethod(jAcceptListener, mid, obj_state);\r
 786 \r
 787     env->DeleteLocalRef(jAcceptListener);\r
 788     if (JNI_EDETACHED == envRet)\r
 789     {\r
 790         g_jvm_consumer->DetachCurrentThread();\r
 791     }\r
 792     NS_LOGD ("ConsumerService_onProviderState -OUT");\r
 793     return ;\r
 794 \r
 795 }\r
 796 \r
 797 void onMessagePosted(OIC::Service::NSMessage message)\r
 798 {\r
 799     NS_LOGD ("ConsumerService_onMessagePosted -IN");\r
 800 \r
 801     jint envRet = 0;;\r
 802     JNIEnv *env = GetJNIEnv(&envRet);\r
 803     if (NULL == env)\r
 804     {\r
 805         return ;\r
 806     }\r
 807 \r
 808     jobject jPostListener = (jobject) env->NewLocalRef(g_obj_postListener);\r
 809     if (!jPostListener)\r
 810     {\r
 811         NS_LOGE ("Failed to Get jPostListener");\r
 812         if (JNI_EDETACHED == envRet)\r
 813         {\r
 814             g_jvm_consumer->DetachCurrentThread();\r
 815         }\r
 816         return ;\r
 817     }\r
 818 \r
 819     jobject obj_message = getJavaMessage( env, message);\r
 820     if (!obj_message)\r
 821     {\r
 822         NS_LOGE ("Failed to Get Message Object");\r
 823         if (JNI_EDETACHED == envRet)\r
 824         {\r
 825             g_jvm_consumer->DetachCurrentThread();\r
 826         }\r
 827         return ;\r
 828     }\r
 829     jclass cls = env->GetObjectClass(jPostListener);\r
 830     if (!cls)\r
 831     {\r
 832         NS_LOGE ("Failed to Get ObjectClass for jPostListener");\r
 833         if (JNI_EDETACHED == envRet)\r
 834         {\r
 835             g_jvm_consumer->DetachCurrentThread();\r
 836         }\r
 837         return ;\r
 838     }\r
 839     jmethodID mid = env->GetMethodID(\r
 840                         cls,\r
 841                         "onMessageReceived",\r
 842                         "(Lorg/iotivity/service/ns/common/Message;)V");\r
 843     if (!mid)\r
 844     {\r
 845         NS_LOGE ("Failed to Get MethodID for onMessageReceived");\r
 846         if (JNI_EDETACHED == envRet)\r
 847         {\r
 848             g_jvm_consumer->DetachCurrentThread();\r
 849         }\r
 850         return ;\r
 851     }\r
 852 \r
 853     env->CallVoidMethod(jPostListener, mid, obj_message);\r
 854 \r
 855     env->DeleteLocalRef(jPostListener);\r
 856     if (JNI_EDETACHED == envRet)\r
 857     {\r
 858         g_jvm_consumer->DetachCurrentThread();\r
 859     }\r
 860     NS_LOGD ("ConsumerService_onMessagePosted -OUT");\r
 861     return ;\r
 862 }\r
 863 \r
 864 void onSyncInfoReceived(OIC::Service::NSSyncInfo sync)\r
 865 {\r
 866     NS_LOGD ("ConsumerService_onSyncInfoReceived - IN");\r
 867 \r
 868     jint envRet = 0;\r
 869     JNIEnv *env = GetJNIEnv(&envRet);\r
 870     if (NULL == env)\r
 871     {\r
 872         return ;\r
 873     }\r
 874 \r
 875     jobject jSyncListener = (jobject) env->NewLocalRef(g_obj_syncListener);\r
 876     if (!jSyncListener)\r
 877     {\r
 878         NS_LOGE ("Failed to Get jSyncListener");\r
 879         if (JNI_EDETACHED == envRet)\r
 880         {\r
 881             g_jvm_consumer->DetachCurrentThread();\r
 882         }\r
 883         return ;\r
 884     }\r
 885 \r
 886     NS_LOGD ("Sync ID : %llu\n", sync.getMessageId());\r
 887     NS_LOGD ("Sync ProviderId : %s\n", sync.getProviderId().c_str());\r
 888     NS_LOGD ("Sync STATE : %d\n", (int) sync.getState());\r
 889 \r
 890     jlong jMessageId = (jlong) sync.getMessageId();\r
 891     jstring jProviderId = env->NewStringUTF(sync.getProviderId().c_str());\r
 892     jobject syncType = getJavaSyncType(env, sync.getState());\r
 893     if (!syncType)\r
 894     {\r
 895         NS_LOGE ("Failed to Get syncType for SyncInfo");\r
 896         if (JNI_EDETACHED == envRet)\r
 897         {\r
 898             g_jvm_consumer->DetachCurrentThread();\r
 899         }\r
 900         return ;\r
 901     }\r
 902     jclass cls_SyncInfo = (jclass) (env->NewLocalRef(g_cls_SyncInfo));\r
 903     if (!cls_SyncInfo)\r
 904     {\r
 905         NS_LOGE ("Failed to Get ObjectClass for SyncInfo");\r
 906         if (JNI_EDETACHED == envRet)\r
 907         {\r
 908             g_jvm_consumer->DetachCurrentThread();\r
 909         }\r
 910         return ;\r
 911     }\r
 912     jmethodID mid_syncInfo = env->GetMethodID(\r
 913                                  cls_SyncInfo,\r
 914                                  "<init>",\r
 915                                  "(JLjava/lang/String;Lorg/iotivity/service/ns/common/SyncInfo$SyncType;)V");\r
 916     if (!mid_syncInfo)\r
 917     {\r
 918         NS_LOGE ("Failed to Get MethodID for SyncInfo");\r
 919         if (JNI_EDETACHED == envRet)\r
 920         {\r
 921             g_jvm_consumer->DetachCurrentThread();\r
 922         }\r
 923         return ;\r
 924     }\r
 925 \r
 926     jobject obj_syncInfo = env->NewObject( cls_SyncInfo, mid_syncInfo,\r
 927                                            jMessageId, jProviderId, syncType);\r
 928     if (!obj_syncInfo)\r
 929     {\r
 930         NS_LOGE ("Failed to Get Object for SyncInfo");\r
 931         if (JNI_EDETACHED == envRet)\r
 932         {\r
 933             g_jvm_consumer->DetachCurrentThread();\r
 934         }\r
 935         return ;\r
 936     }\r
 937 \r
 938     jclass cls = env->GetObjectClass(jSyncListener);\r
 939     if (!cls)\r
 940     {\r
 941         NS_LOGE ("Failed to Get ObjectClass for jSyncListener");\r
 942         if (JNI_EDETACHED == envRet)\r
 943         {\r
 944             g_jvm_consumer->DetachCurrentThread();\r
 945         }\r
 946         return ;\r
 947     }\r
 948     jmethodID mid = env->GetMethodID(\r
 949                         cls,\r
 950                         "onSyncInfoReceived",\r
 951                         "(Lorg/iotivity/service/ns/common/SyncInfo;)V");\r
 952     if (!mid)\r
 953     {\r
 954         NS_LOGE ("Failed to Get MethodID for onSyncInfoReceived");\r
 955         if (JNI_EDETACHED == envRet)\r
 956         {\r
 957             g_jvm_consumer->DetachCurrentThread();\r
 958         }\r
 959         return ;\r
 960     }\r
 961 \r
 962     env->CallVoidMethod(jSyncListener, mid, obj_syncInfo);\r
 963 \r
 964     env->DeleteLocalRef(jSyncListener);\r
 965     env->DeleteLocalRef(cls_SyncInfo);\r
 966     if (JNI_EDETACHED == envRet)\r
 967     {\r
 968         g_jvm_consumer->DetachCurrentThread();\r
 969     }\r
 970     NS_LOGD ("ConsumerService_onSyncInfoReceived - OUT");\r
 971     return ;\r
 972 }\r
 973 \r
 974 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nativeStart\r
 975 (JNIEnv *env, jobject jObj, jobject jDiscoverListener)\r
 976 {\r
 977     NS_LOGD ("ConsumerService_StartConsumer - IN");\r
 978     if (!jDiscoverListener)\r
 979     {\r
 980         ThrowNSException(JNI_INVALID_VALUE, "Listener cannot be null");\r
 981         return;\r
 982     }\r
 983     if (g_obj_discoverListener != NULL)\r
 984     {\r
 985         env->DeleteGlobalRef(g_obj_discoverListener);\r
 986     }\r
 987     g_obj_discoverListener = (jobject) env->NewGlobalRef(jDiscoverListener);\r
 988 \r
 989     OIC::Service::NSResult result  = OIC::Service::NSConsumerService::getInstance()->start(\r
 990                                          onDiscoverProvider);\r
 991 \r
 992     if (result !=  OIC::Service::NSResult::OK)\r
 993     {\r
 994         ThrowNSException((int) result, "Fail to start ConsumerService");\r
 995         return;\r
 996     }\r
 997     NS_LOGD ("ConsumerService_StartConsumer - OUT");\r
 998     return;\r
 999 \r
1000 }\r
1001 \r
1002 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nativeStop\r
1003 (JNIEnv *env, jobject jObj)\r
1004 {\r
1005     NS_LOGD ("ConsumerService_StopConsumer - IN");\r
1006 \r
1007     env->DeleteGlobalRef(g_obj_postListener);\r
1008     env->DeleteGlobalRef(g_obj_syncListener);\r
1009     env->DeleteGlobalRef(g_obj_discoverListener);\r
1010     env->DeleteGlobalRef(g_obj_acceptListener);\r
1011     g_obj_postListener = NULL;\r
1012     g_obj_syncListener = NULL;\r
1013     g_obj_discoverListener = NULL;\r
1014     g_obj_acceptListener = NULL;\r
1015     OIC::Service::NSResult result  = OIC::Service::NSConsumerService::getInstance()->stop();\r
1016 \r
1017     if (result !=  OIC::Service::NSResult::OK)\r
1018     {\r
1019         ThrowNSException((int) result, "Fail to Stop ConsumerService");\r
1020         return;\r
1021     }\r
1022     NS_LOGD ("ConsumerService_StopConsumer - OUT");\r
1023     return;\r
1024 }\r
1025 \r
1026 JNIEXPORT void JNICALL\r
1027 Java_org_iotivity_service_ns_consumer_ConsumerService_nativeEnableRemoteService\r
1028 (JNIEnv *env, jobject jObj, jstring jServerAddress)\r
1029 {\r
1030     NS_LOGD ("ConsumerService_EnableRemoteService - IN");\r
1031     if (!jServerAddress)\r
1032     {\r
1033         ThrowNSException(JNI_INVALID_VALUE, "EnableRemoteService server address NULL");\r
1034         return;\r
1035     }\r
1036     const char *serverAddress = env->GetStringUTFChars(jServerAddress, 0);\r
1037     OIC::Service::NSResult result =\r
1038         OIC::Service::NSConsumerService::getInstance()->enableRemoteService(std::string(serverAddress));\r
1039 \r
1040     if (result !=  OIC::Service::NSResult::OK)\r
1041     {\r
1042         ThrowNSException((int) result, "Fail to EnableRemoteService");\r
1043         return;\r
1044     }\r
1045     env->ReleaseStringUTFChars(jServerAddress, serverAddress);\r
1046     NS_LOGD ("ConsumerService_EnableRemoteService - OUT");\r
1047     return;\r
1048 }\r
1049 \r
1050 JNIEXPORT void JNICALL\r
1051 Java_org_iotivity_service_ns_consumer_ConsumerService_nativeSubscribeMQService\r
1052 (JNIEnv *env, jobject jObj, jstring jserverAddress, jstring jTopicName)\r
1053 {\r
1054     NS_LOGD ("ConsumerService: nativeSubscribeMQService - IN");\r
1055     if (!jserverAddress)\r
1056     {\r
1057         ThrowNSException(JNI_INVALID_VALUE, "Server Address Can't be NULL");\r
1058         return;\r
1059     }\r
1060     if (!jTopicName)\r
1061     {\r
1062         ThrowNSException(JNI_INVALID_VALUE, "TopicName Can't be NULL");\r
1063         return;\r
1064     }\r
1065 \r
1066     const char *address = env->GetStringUTFChars( jserverAddress, NULL);\r
1067     std::string servAddress(address);\r
1068     const char *topic = env->GetStringUTFChars( jTopicName, NULL);\r
1069     std::string topicName(topic);\r
1070 \r
1071     OIC::Service::NSResult result  =\r
1072         OIC::Service::NSConsumerService::getInstance()->subscribeMQService(\r
1073             servAddress, topicName);\r
1074     if (result !=  OIC::Service::NSResult::OK)\r
1075     {\r
1076         ThrowNSException((int) result, "Fail to Subscribe to MQ Service");\r
1077         return;\r
1078     }\r
1079     env->ReleaseStringUTFChars(jserverAddress, address);\r
1080     env->ReleaseStringUTFChars(jTopicName, topic);\r
1081     NS_LOGD ("ConsumerService: nativeSubscribeMQService - OUT");\r
1082     return;\r
1083 }\r
1084 \r
1085 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nativeRescanProvider\r
1086 (JNIEnv *env, jobject jObj)\r
1087 {\r
1088     NS_LOGD ("ConsumerService_RescanProvider - IN");\r
1089     OIC::Service::NSResult result  = OIC::Service::NSConsumerService::getInstance()->rescanProvider();\r
1090     if (result !=  OIC::Service::NSResult::OK)\r
1091     {\r
1092         ThrowNSException((int) result, "Fail to RescanProvider");\r
1093         return;\r
1094     }\r
1095     NS_LOGD ("ConsumerService_RescanProvider - OUT");\r
1096     return;\r
1097 \r
1098 }\r
1099 \r
1100 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSubscribe\r
1101 (JNIEnv *env, jobject jObj)\r
1102 {\r
1103     NS_LOGD ("Provider_Subscribe -IN");\r
1104     OIC::Service::NSResult result  = OIC::Service::NSResult::ERROR;\r
1105     jclass providerClass = env->GetObjectClass(jObj);\r
1106     if (!providerClass)\r
1107     {\r
1108         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1109         return ;\r
1110     }\r
1111 \r
1112     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1113     if (!nativeHandle)\r
1114     {\r
1115         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1116         return ;\r
1117     }\r
1118     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1119     if (jProvider)\r
1120     {\r
1121         NS_LOGD ("calling subscribe on mNativeHandle");\r
1122         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1123             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1124         result  = objectHolder->get()->subscribe();\r
1125     }\r
1126     else\r
1127     {\r
1128         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1129         if (provider == nullptr)\r
1130         {\r
1131             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1132             return;\r
1133         }\r
1134         NS_LOGD ("calling subscribe on ProviderID");\r
1135         result  = provider->subscribe();\r
1136     }\r
1137     if (result !=  OIC::Service::NSResult::OK)\r
1138     {\r
1139         ThrowNSException((int) result, "Fail to Subscribe Provider");\r
1140         return;\r
1141     }\r
1142     NS_LOGD ("Provider_Subscribe -OUT");\r
1143     return;\r
1144 }\r
1145 \r
1146 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeUnsubscribe\r
1147 (JNIEnv *env, jobject jObj)\r
1148 {\r
1149     NS_LOGD ("Provider_UnSubscribe -IN");\r
1150     OIC::Service::NSResult result  = OIC::Service::NSResult::ERROR;\r
1151     jclass providerClass = env->GetObjectClass(jObj);\r
1152     if (!providerClass)\r
1153     {\r
1154         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1155         return ;\r
1156     }\r
1157 \r
1158     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1159     if (!nativeHandle)\r
1160     {\r
1161         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1162         return ;\r
1163     }\r
1164     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1165     if (jProvider)\r
1166     {\r
1167         NS_LOGD ("calling subscribe on mNativeHandle");\r
1168         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1169             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1170         result  = objectHolder->get()->unsubscribe();\r
1171     }\r
1172     else\r
1173     {\r
1174         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1175         if (provider == nullptr)\r
1176         {\r
1177             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1178             return;\r
1179         }\r
1180         NS_LOGD ("calling subscribe on ProviderID");\r
1181         result  = provider->unsubscribe();\r
1182     }\r
1183     if (result !=  OIC::Service::NSResult::OK)\r
1184     {\r
1185         ThrowNSException((int) result, "Fail to UnSubscribe Provider");\r
1186         return;\r
1187     }\r
1188     NS_LOGD ("Provider_UnSubscribe -OUT");\r
1189     return;\r
1190 }\r
1191 \r
1192 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSendSyncInfo\r
1193 (JNIEnv *env, jobject jObj, jlong jMessageId, jint jSyncType)\r
1194 {\r
1195     NS_LOGD ("Provider_SendSyncInfo - IN");\r
1196     OIC::Service::NSResult result  = OIC::Service::NSResult::ERROR;\r
1197     if (!jMessageId)\r
1198     {\r
1199         ThrowNSException(JNI_INVALID_VALUE, "MessageId cannot be 0");\r
1200         return ;\r
1201     }\r
1202 \r
1203     jclass providerClass = env->GetObjectClass(jObj);\r
1204     if (!providerClass)\r
1205     {\r
1206         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1207         return ;\r
1208     }\r
1209 \r
1210     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1211     if (!nativeHandle)\r
1212     {\r
1213         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1214         return ;\r
1215     }\r
1216     uint64_t messageId = (uint64_t) jMessageId;\r
1217 \r
1218     NS_LOGD ("!!!!!!jMessageId: %lld", jMessageId);\r
1219     NS_LOGD ("!!!!!!messageId: %lld", messageId);\r
1220 \r
1221     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1222     if (jProvider)\r
1223     {\r
1224         NS_LOGD ("calling SendSyncInfo on mNativeHandle");\r
1225         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1226             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1227         result  = objectHolder->get()->sendSyncInfo(messageId,\r
1228                   (OIC::Service::NSSyncInfo::NSSyncType)jSyncType);\r
1229     }\r
1230     else\r
1231     {\r
1232         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1233         if (provider == nullptr)\r
1234         {\r
1235             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1236             return;\r
1237         }\r
1238         NS_LOGD ("calling SendSyncInfo on ProviderID");\r
1239         result  = provider->sendSyncInfo(messageId, (OIC::Service::NSSyncInfo::NSSyncType)jSyncType);\r
1240     }\r
1241     if (result !=  OIC::Service::NSResult::OK)\r
1242     {\r
1243         ThrowNSException((int) result, "Fail to Send sync info");\r
1244         return;\r
1245     }\r
1246     NS_LOGD ("Provider_SendSyncInfo - OUT");\r
1247     return;\r
1248 }\r
1249 \r
1250 \r
1251 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSetListener\r
1252 (JNIEnv *env, jobject jObj, jobject jAcceptListener, jobject jPostListener, jobject jSyncListener)\r
1253 {\r
1254     NS_LOGD ("Provider_SetListener - IN");\r
1255     if (!jPostListener || !jSyncListener || !jAcceptListener)\r
1256     {\r
1257         ThrowNSException(JNI_INVALID_VALUE, "Listener cannot be null");\r
1258         return ;\r
1259     }\r
1260 \r
1261     jclass providerClass = env->GetObjectClass(jObj);\r
1262     if (!providerClass)\r
1263     {\r
1264         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1265         return ;\r
1266     }\r
1267 \r
1268     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1269     if (!nativeHandle)\r
1270     {\r
1271         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1272         return ;\r
1273     }\r
1274     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1275     if (jProvider)\r
1276     {\r
1277         NS_LOGD ("calling SetListener on mNativeHandle");\r
1278         if (g_obj_acceptListener != NULL)\r
1279         {\r
1280             env->DeleteGlobalRef(g_obj_acceptListener);\r
1281         }\r
1282         if (g_obj_postListener != NULL)\r
1283         {\r
1284             env->DeleteGlobalRef(g_obj_postListener);\r
1285         }\r
1286         if (g_obj_syncListener != NULL)\r
1287         {\r
1288             env->DeleteGlobalRef(g_obj_syncListener);\r
1289         }\r
1290         g_obj_acceptListener = (jobject) env->NewGlobalRef(jAcceptListener);\r
1291         g_obj_postListener = (jobject) env->NewGlobalRef(jPostListener);\r
1292         g_obj_syncListener = (jobject) env->NewGlobalRef(jSyncListener);\r
1293 \r
1294         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1295             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1296         objectHolder->get()->setListener(onProviderState, onMessagePosted, onSyncInfoReceived);\r
1297     }\r
1298     else\r
1299     {\r
1300         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1301         if (provider == nullptr)\r
1302         {\r
1303             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1304             return;\r
1305         }\r
1306         NS_LOGD ("calling SetListener on ProviderID");\r
1307         if (g_obj_acceptListener != NULL)\r
1308         {\r
1309             env->DeleteGlobalRef(g_obj_acceptListener);\r
1310         }\r
1311         if (g_obj_postListener != NULL)\r
1312         {\r
1313             env->DeleteGlobalRef(g_obj_postListener);\r
1314         }\r
1315         if (g_obj_syncListener != NULL)\r
1316         {\r
1317             env->DeleteGlobalRef(g_obj_syncListener);\r
1318         }\r
1319         g_obj_acceptListener = (jobject) env->NewGlobalRef(jAcceptListener);\r
1320         g_obj_postListener = (jobject) env->NewGlobalRef(jPostListener);\r
1321         g_obj_syncListener = (jobject) env->NewGlobalRef(jSyncListener);\r
1322 \r
1323         provider->setListener(onProviderState, onMessagePosted, onSyncInfoReceived);\r
1324     }\r
1325     NS_LOGD ("Provider_SetListener - OUT");\r
1326     return;\r
1327 }\r
1328 \r
1329 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeGetTopicList\r
1330 (JNIEnv *env, jobject jObj)\r
1331 {\r
1332     NS_LOGD ("Provider_nativeGetTopicList - IN");\r
1333     jclass providerClass = env->GetObjectClass(jObj);\r
1334     if (!providerClass)\r
1335     {\r
1336         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1337         return NULL;\r
1338     }\r
1339 \r
1340     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1341     if (!nativeHandle)\r
1342     {\r
1343         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1344         return NULL;\r
1345     }\r
1346     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1347     std::shared_ptr<OIC::Service::NSTopicsList> topicList = nullptr;\r
1348     if (jProvider)\r
1349     {\r
1350         NS_LOGD ("calling subscribe on mNativeHandle");\r
1351         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1352             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1353         topicList = objectHolder->get()->getTopicList();\r
1354     }\r
1355     else\r
1356     {\r
1357         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1358         if (provider == nullptr)\r
1359         {\r
1360             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1361             return NULL;\r
1362         }\r
1363         NS_LOGD ("calling subscribe on ProviderID");\r
1364         topicList = provider->getTopicList();\r
1365     }\r
1366     if (topicList == nullptr)\r
1367     {\r
1368         ThrowNSException(JNI_INVALID_VALUE, "Topic List doesn't exist");\r
1369         return NULL;\r
1370     }\r
1371 \r
1372     jobject obj_topicList = getJavaTopicsList(env, topicList);\r
1373 \r
1374     NS_LOGD ("Provider_nativeGetTopicList - OUT");\r
1375     return obj_topicList;\r
1376 }\r
1377 \r
1378 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeUpdateTopicList\r
1379 (JNIEnv *env, jobject jObj, jobject jTopicsList)\r
1380 {\r
1381     NS_LOGD ("Provider_nativeUpdateTopicList -IN");\r
1382     if (!jTopicsList)\r
1383     {\r
1384         ThrowNSException(JNI_INVALID_VALUE, "TopicList cannot be null");\r
1385         return;\r
1386     }\r
1387     std::shared_ptr<OIC::Service::NSTopicsList> nsTopicsList = getNativeTopicsList(env, jTopicsList);\r
1388     if (nsTopicsList == nullptr)\r
1389     {\r
1390         ThrowNSException(JNI_INVALID_VALUE, "NSTopicList cannot be created ");\r
1391         return;\r
1392     }\r
1393 \r
1394     jclass providerClass = env->GetObjectClass(jObj);\r
1395     if (!providerClass)\r
1396     {\r
1397         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1398         return;\r
1399     }\r
1400 \r
1401     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1402     if (!nativeHandle)\r
1403     {\r
1404         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1405         return;\r
1406     }\r
1407     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1408     OIC::Service::NSResult result = OIC::Service::NSResult::ERROR;\r
1409     if (jProvider)\r
1410     {\r
1411         NS_LOGD ("calling subscribe on mNativeHandle");\r
1412         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1413             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1414         result = objectHolder->get()->updateTopicList(nsTopicsList);\r
1415     }\r
1416     else\r
1417     {\r
1418         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1419         if (provider == nullptr)\r
1420         {\r
1421             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1422             return;\r
1423         }\r
1424         NS_LOGD ("calling subscribe on ProviderID");\r
1425         result = provider->updateTopicList(nsTopicsList);\r
1426     }\r
1427     if (result !=  OIC::Service::NSResult::OK)\r
1428     {\r
1429         ThrowNSException((int) result, "Fail to Update Interest Topics");\r
1430         return;\r
1431     }\r
1432     NS_LOGD ("Provider_nativeUpdateTopicList -OUT");\r
1433     return;\r
1434 }\r
1435 \r
1436 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeGetProviderState\r
1437 (JNIEnv *env, jobject jObj)\r
1438 {\r
1439     NS_LOGD ("Provider_nativeGetProviderState - IN");\r
1440     jclass providerClass = env->GetObjectClass(jObj);\r
1441     if (!providerClass)\r
1442     {\r
1443         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1444         return NULL;\r
1445     }\r
1446 \r
1447     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1448     if (!nativeHandle)\r
1449     {\r
1450         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1451         return NULL;\r
1452     }\r
1453     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1454     OIC::Service::NSProviderState state = OIC::Service::NSProviderState::DENY;\r
1455     if (jProvider)\r
1456     {\r
1457         NS_LOGD ("calling getProviderState on mNativeHandle");\r
1458         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1459             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1460         state = objectHolder->get()->getProviderState();\r
1461     }\r
1462     else\r
1463     {\r
1464         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1465         if (provider == nullptr)\r
1466         {\r
1467             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1468             return NULL;\r
1469         }\r
1470         NS_LOGD ("calling getProviderState on ProviderID");\r
1471         state = provider->getProviderState();\r
1472     }\r
1473     jobject obj_state = getJavaProviderState(env, state);\r
1474 \r
1475     NS_LOGD ("Provider_nativeGetProviderState - OUT");\r
1476     return obj_state;\r
1477 }\r
1478 \r
1479 JNIEXPORT jboolean JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeIsSubscribed\r
1480 (JNIEnv *env, jobject jObj)\r
1481 {\r
1482     NS_LOGD ("nativeIsSubscribed - IN");\r
1483     jclass providerClass = env->GetObjectClass(jObj);\r
1484     if (!providerClass)\r
1485     {\r
1486         ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider");\r
1487         return (jboolean)false;\r
1488     }\r
1489 \r
1490     jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J");\r
1491     if (!nativeHandle)\r
1492     {\r
1493         ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider");\r
1494         return (jboolean)false;\r
1495     }\r
1496     jlong jProvider = env->GetLongField(jObj, nativeHandle);\r
1497     if (jProvider)\r
1498     {\r
1499         NS_LOGD ("calling isSubscribe on mNativeHandle");\r
1500         JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1501             reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(jProvider);\r
1502         return (jboolean) objectHolder->get()->isSubscribed();\r
1503     }\r
1504     else\r
1505     {\r
1506         std::shared_ptr<OIC::Service::NSProvider> provider = getNativeProvider(env, jObj);\r
1507         if (provider == nullptr)\r
1508         {\r
1509             ThrowNSException(JNI_INVALID_VALUE, "Provider with Given Id doesn't exist");\r
1510             return (jboolean)false;\r
1511         }\r
1512         NS_LOGD ("calling isSubscribe on ProviderID");\r
1513         return (jboolean) provider->isSubscribed();\r
1514     }\r
1515 }\r
1516 \r
1517 JNIEXPORT void JNICALL\r
1518 Java_org_iotivity_service_ns_consumer_Provider_nativeDispose\r
1519 (JNIEnv *env, jobject object)\r
1520 {\r
1521     jclass cls_provider = (jclass) (env->NewLocalRef(g_cls_Provider));\r
1522     if (!cls_provider)\r
1523     {\r
1524         NS_LOGE ("Failed to Get ObjectClass for Provider");\r
1525         return;\r
1526     }\r
1527     jfieldID nativeHandle = env->GetFieldID(cls_provider, "mNativeHandle", "J");\r
1528     if (!nativeHandle)\r
1529     {\r
1530         NS_LOGE ("Failed to get nativeHandle for Provider");\r
1531         return;\r
1532     }\r
1533     jlong handle = env->GetLongField(object, nativeHandle);\r
1534     JniSharedObjectHolder<OIC::Service::NSProvider> *objectHolder =\r
1535         reinterpret_cast<JniSharedObjectHolder<OIC::Service::NSProvider> *>(handle);\r
1536     delete objectHolder;\r
1537     return;\r
1538 }\r
1539 \r
1540 // JNI OnLoad\r
1541 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)\r
1542 {\r
1543     NS_LOGD ("ConsumerService_JNI_OnLoad");\r
1544     g_jvm_consumer = jvm;\r
1545 \r
1546     JNIEnv *env = NULL;\r
1547     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)\r
1548     {\r
1549         NS_LOGE ("Failed to get the environment using GetEnv()");\r
1550         return JNI_ERR;\r
1551     }\r
1552 \r
1553     jclass localMessage = env->FindClass(\r
1554                               "org/iotivity/service/ns/common/Message");\r
1555     if (!localMessage)\r
1556     {\r
1557         NS_LOGE ("Failed to get local Message class");\r
1558         return JNI_ERR;\r
1559     }\r
1560     g_cls_Message = (jclass) (env->NewGlobalRef(localMessage));\r
1561     if (!g_cls_Message)\r
1562     {\r
1563         NS_LOGE ("Failed to set Global Message reference");\r
1564         return JNI_ERR;\r
1565     }\r
1566 \r
1567     jclass localProvider = env->FindClass(\r
1568                                "org/iotivity/service/ns/consumer/Provider");\r
1569     if (!localProvider)\r
1570     {\r
1571         NS_LOGE ("Failed to get local Provider class");\r
1572         return JNI_ERR;\r
1573     }\r
1574     g_cls_Provider = (jclass) (env->NewGlobalRef(localProvider));\r
1575     if (!g_cls_Provider)\r
1576     {\r
1577         NS_LOGE ("Failed to set Global Provider reference");\r
1578         return JNI_ERR;\r
1579     }\r
1580 \r
1581     jclass localSyncInfo = env->FindClass(\r
1582                                "org/iotivity/service/ns/common/SyncInfo");\r
1583     if (!localSyncInfo)\r
1584     {\r
1585         NS_LOGE ("Failed to get local SyncInfo class");\r
1586         return JNI_ERR;\r
1587     }\r
1588     g_cls_SyncInfo = (jclass) (env->NewGlobalRef(localSyncInfo));\r
1589     if (!g_cls_SyncInfo)\r
1590     {\r
1591         NS_LOGE ("Failed to set Global NSSyncInfo reference");\r
1592         return JNI_ERR;\r
1593     }\r
1594 \r
1595     jclass localSyncType = env->FindClass(\r
1596                                "org/iotivity/service/ns/common/SyncInfo$SyncType");\r
1597     if (!localSyncType)\r
1598     {\r
1599         NS_LOGE ("Failed to get local SyncType enum");\r
1600         return JNI_ERR;\r
1601     }\r
1602     g_cls_SyncType = (jclass) (env->NewGlobalRef(localSyncType));\r
1603     if (!g_cls_SyncType)\r
1604     {\r
1605         NS_LOGE ("Failed to set Global SyncType reference");\r
1606         return JNI_ERR;\r
1607     }\r
1608 \r
1609     jclass localMediaContents = env->FindClass(\r
1610                                     "org/iotivity/service/ns/common/MediaContents");\r
1611     if (!localMediaContents)\r
1612     {\r
1613         NS_LOGE ("Failed to get local MediaContents class");\r
1614         return JNI_ERR;\r
1615     }\r
1616     g_cls_MediaContents = (jclass) (env->NewGlobalRef(localMediaContents));\r
1617     if (!g_cls_MediaContents)\r
1618     {\r
1619         NS_LOGE ("Failed to set Global MediaContents reference");\r
1620         return JNI_ERR;\r
1621     }\r
1622     jclass localTopicState = env->FindClass(\r
1623                                  "org/iotivity/service/ns/common/Topic$TopicState");\r
1624     if (!localTopicState)\r
1625     {\r
1626         NS_LOGE ("Failed to get local TopicState enum");\r
1627         return JNI_ERR;\r
1628     }\r
1629     g_cls_TopicState = (jclass) (env->NewGlobalRef(localTopicState));\r
1630     if (!g_cls_TopicState)\r
1631     {\r
1632         NS_LOGE ("Failed to set Global TopicState reference");\r
1633         return JNI_ERR;\r
1634     }\r
1635 \r
1636     jclass localTopic = env->FindClass(\r
1637                             "org/iotivity/service/ns/common/Topic");\r
1638     if (!localTopic)\r
1639     {\r
1640         NS_LOGE ("Failed to get local TopicState enum");\r
1641         return JNI_ERR;\r
1642     }\r
1643     g_cls_Topic = (jclass) (env->NewGlobalRef(localTopic));\r
1644     if (!g_cls_Topic)\r
1645     {\r
1646         NS_LOGE ("Failed to set Global Topic reference");\r
1647         return JNI_ERR;\r
1648     }\r
1649 \r
1650     jclass localMessageType = env->FindClass(\r
1651                                   "org/iotivity/service/ns/common/Message$MessageType");\r
1652     if (!localMessageType)\r
1653     {\r
1654         NS_LOGE ("Failed to get local Message Type class");\r
1655         return JNI_ERR;\r
1656     }\r
1657     g_cls_Message_Type = (jclass) (env->NewGlobalRef(localMessageType));\r
1658     if (!g_cls_Message_Type)\r
1659     {\r
1660         NS_LOGE ("Failed to set Global Message Type reference");\r
1661         return JNI_ERR;\r
1662     }\r
1663 \r
1664     jclass localProviderState = env->FindClass(\r
1665                                     "org/iotivity/service/ns/consumer/Provider$ProviderState");\r
1666     if (!localProviderState)\r
1667     {\r
1668         NS_LOGE ("Failed to get localProviderState  Type class");\r
1669         return JNI_ERR;\r
1670     }\r
1671     g_cls_ProviderState = (jclass) (env->NewGlobalRef(localProviderState));\r
1672     if (!g_cls_ProviderState)\r
1673     {\r
1674         NS_LOGE ("Failed to set Global ProviderState Type reference");\r
1675         return JNI_ERR;\r
1676     }\r
1677 \r
1678     jclass localTopicsList = env->FindClass(\r
1679                                  "org/iotivity/service/ns/common/TopicsList");\r
1680     if (!localTopicsList)\r
1681     {\r
1682         NS_LOGE ("Failed to get local Topic class");\r
1683         return JNI_ERR;\r
1684     }\r
1685     g_cls_TopicsList = (jclass) (env->NewGlobalRef(localTopicsList));\r
1686     if (!g_cls_TopicsList)\r
1687     {\r
1688         NS_LOGE ("Failed to set Global TopicsList reference");\r
1689         return JNI_ERR;\r
1690     }\r
1691     //OcRepresentation\r
1692     jclass localOcRepresentation = env->FindClass("org/iotivity/base/OcRepresentation");\r
1693     if (!localOcRepresentation)\r
1694     {\r
1695         NS_LOGE ("Failed to get local OcRepresentation class");\r
1696         return JNI_ERR;\r
1697     }\r
1698     g_cls_OcRepresentation = (jclass) env->NewGlobalRef(localOcRepresentation);\r
1699     if (!g_cls_OcRepresentation)\r
1700     {\r
1701         NS_LOGE ("Failed to set Global OcRepresentation reference");\r
1702         return JNI_ERR;\r
1703     }\r
1704 \r
1705     g_mid_OcRepresentation_N_ctor_bool = env->GetMethodID(g_cls_OcRepresentation, "<init>", "(JZ)V");\r
1706     if (!g_mid_OcRepresentation_N_ctor_bool)\r
1707     {\r
1708         NS_LOGE ("Failed to get Global OcRepresentation Constructor reference");\r
1709         return JNI_ERR;\r
1710     }\r
1711 \r
1712     env->DeleteLocalRef(localMessage);\r
1713     env->DeleteLocalRef(localProvider);\r
1714     env->DeleteLocalRef(localSyncInfo);\r
1715     env->DeleteLocalRef(localSyncType);\r
1716     env->DeleteLocalRef(localMediaContents);\r
1717     env->DeleteLocalRef(localTopicState);\r
1718     env->DeleteLocalRef(localMessageType);\r
1719     env->DeleteLocalRef(localProviderState);\r
1720     env->DeleteLocalRef(localTopic);\r
1721     env->DeleteLocalRef(localTopicsList);\r
1722     env->DeleteLocalRef(localOcRepresentation);\r
1723 \r
1724     return NSExceptionInit(env);\r
1725 }\r
1726 \r
1727 JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)\r
1728 {\r
1729     NS_LOGI ("ConsumerService_JNI_OnUnload");\r
1730     JNIEnv *env = NULL;\r
1731 \r
1732     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)\r
1733     {\r
1734         NS_LOGE ("Failed to get the environment using GetEnv()");\r
1735         return ;\r
1736     }\r
1737 \r
1738     env->DeleteGlobalRef(g_cls_Message);\r
1739     env->DeleteGlobalRef(g_cls_Provider);\r
1740     env->DeleteGlobalRef(g_cls_SyncInfo);\r
1741     env->DeleteGlobalRef(g_cls_SyncType);\r
1742     env->DeleteGlobalRef(g_cls_MediaContents);\r
1743     env->DeleteGlobalRef(g_cls_TopicState);\r
1744     env->DeleteGlobalRef(g_cls_Message_Type);\r
1745     env->DeleteGlobalRef(g_cls_ProviderState);\r
1746     env->DeleteGlobalRef(g_cls_Topic);\r
1747     env->DeleteGlobalRef(g_cls_TopicsList);\r
1748     env->DeleteGlobalRef(g_cls_OcRepresentation);\r
1749 }\r