service/notification/android/notification-service/src/main/jni/provider/JniNotificationProvider.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2016 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 "JniNotificationProvider.h"
  22 #include "NSProviderService.h"
  23 #include "JniOcRepresentation.h"
  24
  25 static JavaVM *g_jvm_provider = NULL;
  26
  27 static jobject g_obj_subscriptionListener = NULL;
  28 static jobject g_obj_syncListener = NULL;
  29
  30 jclass g_cls_Message;
  31 jclass g_cls_Message_Type;
  32 jclass g_cls_Consumer;
  33 jclass g_cls_SyncInfo;
  34 jclass g_cls_SyncType;
  35 jclass g_cls_MediaContents;
  36 jclass g_cls_Topic;
  37 jclass g_cls_TopicsList;
  38 jclass g_cls_TopicState;
  39 jclass g_cls_OcRepresentation;
  40 jmethodID g_mid_OcRepresentation_N_ctor_bool = NULL;
  41
  42 static JNIEnv *GetJNIEnv(jint *ret)
  43 {
  44     JNIEnv *env = NULL;
  45
  46     *ret = g_jvm_provider->GetEnv((void **) &env, JNI_CURRENT_VERSION);
  47     switch (*ret)
  48     {
  49         case JNI_OK:
  50             return env;
  51         case JNI_EDETACHED:
  52             if (g_jvm_provider->AttachCurrentThread(&env, NULL) != JNI_OK)
  53             {
  54                 LOGE ("Failed to get the environment");
  55                 return NULL;
  56             }
  57             else
  58             {
  59                 return env;
  60             }
  61         case JNI_EVERSION:
  62             LOGE ("JNI version is not supported");
  63         default:
  64             LOGE ("Failed to get the environment");
  65             return NULL;
  66     }
  67 }
  68
  69 OIC::Service::NSMessage *getNativeMessage(JNIEnv *env, jobject jMsg)
  70 {
  71     LOGD("JNIProviderService: getMessage - IN");
  72
  73     jclass cls = env->GetObjectClass( jMsg);
  74
  75     // Message type
  76     jclass cls_messageType = (jclass) (env->NewLocalRef(g_cls_Message_Type));
  77     if (!cls_messageType)
  78     {
  79         LOGE ("Failed to Get ObjectClass for Message Type");
  80         return nullptr;
  81     }
  82     jmethodID mid = env->GetMethodID(cls_messageType, "ordinal", "()I");
  83     jfieldID fid_type = env->GetFieldID( cls, "mType",
  84                                          "Lorg/iotivity/service/ns/common/Message$MessageType;");
  85     if (fid_type == NULL)
  86     {
  87         LOGE("Error: jfieldID for message type  is null");
  88         return nullptr;
  89     }
  90     jobject jobj = env->GetObjectField( jMsg, fid_type);
  91     if (jobj == NULL)
  92     {
  93         LOGE("Error: object of field  Message Type is null");
  94         return nullptr;
  95     }
  96     jint jtype = env->CallIntMethod(jobj, mid);
  97     OIC::Service::NSMessage::NSMessageType  type = (OIC::Service::NSMessage::NSMessageType) jtype;
  98
  99     LOGD("Message Type: %ld\n", (long )type);
 100
 101     // Message Time
 102     jfieldID fid_tm = env->GetFieldID( cls, "mTime", "Ljava/lang/String;");
 103     if (fid_tm == NULL)
 104     {
 105         LOGE("Error: jfieldID for message time is null");
 106         return nullptr;
 107     }
 108     jstring jtime = (jstring)env->GetObjectField( jMsg, fid_tm);
 109     const char *time = "";
 110     if (jtime)
 111     {
 112         time = env->GetStringUTFChars( jtime, NULL);
 113     }
 114     else
 115     {
 116         LOGD("Info: messageTitle is null");
 117     }
 118     LOGD("Message Time: %s\n", time);
 119
 120     // Message TTL
 121     jfieldID fid_ttl = env->GetFieldID( cls, "mTTL", "J");
 122     if (fid_ttl == NULL)
 123     {
 124         LOGE("Error: jfieldID for message ttl is null");
 125         return nullptr;
 126     }
 127
 128     jlong jttl = (jlong) env->GetLongField( jMsg, fid_ttl);
 129     uint64_t  ttl = jttl;
 130     LOGD("TTL: %d\n", ttl);
 131
 132     // Message Title
 133     jfieldID fid_title = env->GetFieldID( cls, "mTitle", "Ljava/lang/String;");
 134     if (fid_title == NULL)
 135     {
 136         LOGE("Error: jfieldID for message title is null");
 137         return nullptr;
 138     }
 139     jstring jmsgTitle = (jstring)env->GetObjectField( jMsg, fid_title);
 140     const char *messageTitle = "";
 141     if (jmsgTitle)
 142     {
 143         messageTitle = env->GetStringUTFChars( jmsgTitle, NULL);
 144     }
 145     else
 146     {
 147         LOGD("Info: messageTitle is null");
 148     }
 149     LOGD("Message Title: %s\n", messageTitle);
 150
 151     // Message Content Text
 152     jfieldID fid_body = env->GetFieldID( cls, "mContentText", "Ljava/lang/String;");
 153     if (fid_body == NULL)
 154     {
 155         LOGE("Error: jfieldID for message context Text is null");
 156         return nullptr;
 157     }
 158     jstring jmsgBody = (jstring)env->GetObjectField( jMsg, fid_body);
 159     const char *messageBody = "";
 160     if (jmsgBody)
 161     {
 162         messageBody = env->GetStringUTFChars( jmsgBody, NULL);
 163     }
 164     else
 165     {
 166         LOGD("Info: messageBody is null");
 167     }
 168     LOGD("Message Body: %s\n", messageBody);
 169
 170     // Message Source
 171     jfieldID fid_source = env->GetFieldID( cls, "mSourceName", "Ljava/lang/String;");
 172     if (fid_source == NULL)
 173     {
 174         LOGE("Error: jfieldID for message source is null");
 175         return nullptr;
 176     }
 177     jstring jmsgSource = (jstring)env->GetObjectField( jMsg, fid_source);
 178     const char *messageSource = "";
 179     if (jmsgSource)
 180     {
 181         messageSource = env->GetStringUTFChars( jmsgSource, NULL);
 182     }
 183     else
 184     {
 185         LOGD("Info: messageSource is null");
 186     }
 187     LOGD("Message Source: %s\n", messageSource);
 188
 189     // Message Topic
 190     jfieldID fid_topic = env->GetFieldID( cls, "mTopic", "Ljava/lang/String;");
 191     if (fid_topic == NULL)
 192     {
 193         LOGE("Error: jfieldID for topic  is null");
 194         return nullptr;
 195     }
 196     jstring jtopic = (jstring)env->GetObjectField( jMsg, fid_topic);
 197     const char *topic = "";
 198     if (jtopic)
 199     {
 200         topic = env->GetStringUTFChars( jtopic, NULL);
 201     }
 202     else
 203     {
 204         LOGD("Info: topic is null");
 205     }
 206     LOGD("Topic : %s\n", topic);
 207
 208     // Message MediaContents
 209     jfieldID fid_media = env->GetFieldID( cls, "mMediaContents",
 210                                           "Lorg/iotivity/service/ns/common/MediaContents;");
 211     if (fid_media == NULL)
 212     {
 213         LOGE("Error: jfieldID for MediaContents is null");
 214         return nullptr;
 215     }
 216     jobject jmedia = env->GetObjectField( jMsg, fid_media);
 217     OIC::Service::NSMediaContents *media = nullptr;
 218     if (jmedia == NULL)
 219     {
 220         LOGD("Info: jmedia object of MediaContents inside Message is null");
 221     }
 222     else
 223     {
 224         jclass cls_MediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));
 225         if (!cls_MediaContents)
 226         {
 227             LOGE ("Failed to Get ObjectClass for class MediaContents");
 228             return nullptr;
 229         }
 230         jfieldID fid_icon = env->GetFieldID( cls_MediaContents, "mIconImage", "Ljava/lang/String;");
 231         if (fid_icon == NULL)
 232         {
 233             LOGE("Error: jfieldID for iconImage is null");
 234             return nullptr;
 235         }
 236         jstring jiconImage = (jstring)env->GetObjectField( jmedia, fid_icon);
 237         const char *iconImage = "";
 238         if (jiconImage)
 239         {
 240             iconImage = env->GetStringUTFChars( jiconImage, NULL);
 241             media = new OIC::Service::NSMediaContents(std::string(iconImage));
 242             env->ReleaseStringUTFChars(jiconImage, iconImage);
 243         }
 244         else
 245         {
 246             LOGD("Info: iconImage is null");
 247         }
 248         env->DeleteLocalRef(cls_MediaContents);
 249         LOGD("iconImage: %s\n", iconImage);
 250     }
 251
 252     // Message ExtraInfo
 253     jfieldID fid_extraInfo = env->GetFieldID( cls, "mExtraInfo",
 254                              "Lorg/iotivity/base/OcRepresentation;");
 255     if (fid_extraInfo == NULL)
 256     {
 257         LOGE("Error: jfieldID for mExtraInfo is null");
 258         return nullptr;
 259     }
 260     jobject jExtraInfo = env->GetObjectField( jMsg, fid_extraInfo);
 261     OC::OCRepresentation *representation = nullptr;
 262     if (jExtraInfo == NULL)
 263     {
 264         LOGE("Error: jExtraInfo object of Message is null");
 265     }
 266     else
 267     {
 268         representation = GetHandle<OC::OCRepresentation>(env, jExtraInfo);
 269         if (env->ExceptionCheck())
 270         {
 271             LOGE("Failed to get native handle from OcRepresentation");
 272         }
 273         if (!representation)
 274         {
 275             LOGE("Failed to get native object OcRepresentation");
 276         }
 277     }
 278
 279     OIC::Service::NSMessage *nsMsg;
 280     jfieldID nativeHandle = env->GetFieldID(cls, "mNativeHandle", "J");
 281     if (!nativeHandle)
 282     {
 283         LOGE("Error: fieldID for mNativeHandle is null");
 284         return nullptr;
 285     }
 286     jlong jMessage = env->GetLongField(jMsg, nativeHandle);
 287     if (jMessage)
 288     {
 289         LOGD ("calling sendMessage on mNativeHandle");
 290         nsMsg = (OIC::Service::NSMessage *) (jMessage);
 291     }
 292     else
 293     {
 294         nsMsg = OIC::Service::NSProviderService::getInstance()->createMessage();
 295     }
 296
 297     nsMsg->setType(type);
 298     nsMsg->setTime(std::string(time));
 299     nsMsg->setTTL(ttl);
 300     nsMsg->setTitle(std::string(messageTitle));
 301     nsMsg->setContentText(std::string(messageBody));
 302     nsMsg->setSourceName(std::string(messageSource));
 303     if(media != nullptr)
 304     {
 305         nsMsg->setMediaContents(media);
 306     }
 307     nsMsg->setTopic(std::string(topic));
 308     if (representation != nullptr)
 309     {
 310         nsMsg->setExtraInfo(*representation);
 311     }
 312
 313     env->DeleteLocalRef(cls_messageType);
 314
 315     if (jtime)
 316     {
 317         env->ReleaseStringUTFChars(jtime, time);
 318     }
 319     if (jmsgTitle)
 320     {
 321         env->ReleaseStringUTFChars(jmsgTitle, messageTitle);
 322     }
 323     if (jmsgBody)
 324     {
 325         env->ReleaseStringUTFChars(jmsgBody, messageBody);
 326     }
 327     if (jmsgSource)
 328     {
 329         env->ReleaseStringUTFChars(jmsgSource, messageSource);
 330     }
 331     if (jtopic)
 332     {
 333         env->ReleaseStringUTFChars(jtopic, topic);
 334     }
 335
 336     LOGD("JNIProviderService: getMessage - OUT");
 337     return nsMsg;
 338
 339 }
 340
 341 jobject getJavaMessageType(JNIEnv *env, OIC::Service::NSMessage::NSMessageType type)
 342 {
 343     LOGD ("JNIProviderService: getJavaMessageType - IN");
 344     switch (type)
 345     {
 346         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_ALERT:
 347             {
 348                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
 349                                           "ALERT", "Lorg/iotivity/service/ns/common/Message$MessageType;");
 350                 return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
 351             }
 352         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_NOTICE:
 353             {
 354                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
 355                                           "NOTICE", "Lorg/iotivity/service/ns/common/Message$MessageType;");
 356                 return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
 357             }
 358         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_EVENT:
 359             {
 360                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
 361                                           "EVENT", "Lorg/iotivity/service/ns/common/Message$MessageType;");
 362                 return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
 363             }
 364         case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_INFO:
 365             {
 366                 static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
 367                                           "INFO", "Lorg/iotivity/service/ns/common/Message$MessageType;");
 368                 return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
 369             }
 370         default:
 371             return NULL;
 372     }
 373     LOGD ("JNIProviderService: getJavaMessageType - OUT");
 374     return NULL;
 375 }
 376
 377 jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message)
 378 {
 379     LOGD ("JNIProviderService: getJavaMessage - IN");
 380
 381     LOGD ("id : %llu\n", message->getMessageId());
 382     LOGD ("title : %s\n", message->getTitle().c_str());
 383     LOGD ("content : %s\n", message->getContentText().c_str());
 384     LOGD ("source : %s\n", message->getSourceName().c_str());
 385
 386     jlong jMessageId = (jlong) message->getMessageId();
 387     jstring jProviderId = env->NewStringUTF(message->getProviderId().c_str());
 388     jstring jTitle = env->NewStringUTF(message->getTitle().c_str());
 389     jstring jContentText = env->NewStringUTF(message->getContentText().c_str());
 390     jstring jSourceName = env->NewStringUTF(message->getSourceName().c_str());
 391     jstring jTopic = env->NewStringUTF(message->getTopic().c_str());
 392
 393     jstring jTime = env->NewStringUTF(message->getTime().c_str());
 394     jlong jTTL = (jlong) message->getTTL();
 395
 396     jlong pMessage = (long) message;
 397
 398     jclass cls_message = (jclass) (env->NewLocalRef(g_cls_Message));
 399     if (!cls_message)
 400     {
 401         LOGE ("Failed to Get ObjectClass for Message");
 402         return NULL ;
 403     }
 404     jmethodID mid_message = env->GetMethodID(
 405                                 cls_message, "<init>",
 406                                 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
 407     if (!mid_message)
 408     {
 409         LOGE ("Failed to Get MethodID for Message<init>");
 410         return NULL;
 411     }
 412     jobject obj_message = env->NewObject(cls_message, mid_message,
 413                                          jTitle, jContentText, jSourceName);
 414     if (!obj_message)
 415     {
 416         LOGE ("Failed to Get Java Object for Message");
 417         return NULL;
 418     }
 419     jfieldID fid_nativeHandle = env->GetFieldID(cls_message, "mNativeHandle", "J");
 420     if (!fid_nativeHandle)
 421     {
 422         LOGE("Failed to get nativeHandle for Message");
 423         return NULL;
 424     }
 425     env->SetLongField(obj_message, fid_nativeHandle, pMessage);
 426
 427     jfieldID fid_messageId = env->GetFieldID(cls_message, "mMessageId", "J");
 428     if (!fid_messageId)
 429     {
 430         LOGE("Failed to get field MessageID for Message");
 431         return NULL;
 432     }
 433     env->SetLongField(obj_message, fid_messageId, jMessageId);
 434
 435     jfieldID fid_providerId = env->GetFieldID(cls_message, "mProviderId", "Ljava/lang/String;");
 436     if (!fid_providerId)
 437     {
 438         LOGE("Failed to get field ProviderID for Message");
 439         return NULL;
 440     }
 441     env->SetObjectField(obj_message, fid_providerId, jProviderId);
 442
 443     jfieldID fid_time = env->GetFieldID(cls_message, "mTime", "Ljava/lang/String;");
 444     if (!fid_time)
 445     {
 446         LOGE("Failed to get field Time for Message");
 447         return NULL;
 448     }
 449     env->SetObjectField(obj_message, fid_time, jTime);
 450
 451     jfieldID fid_ttl = env->GetFieldID(cls_message, "mTTL", "J");
 452     if (!fid_ttl)
 453     {
 454         LOGE("Failed to get field TTL for Message");
 455         return NULL;
 456     }
 457     env->SetLongField(obj_message, fid_ttl, jTTL);
 458
 459     jfieldID fid_topic = env->GetFieldID(cls_message, "mTopic", "Ljava/lang/String;");
 460     if (!fid_topic)
 461     {
 462         LOGE("Failed to get mTopic for Message");
 463         return NULL;
 464     }
 465     env->SetObjectField(obj_message, fid_topic, jTopic);
 466
 467     OIC::Service::NSMediaContents *mediaCont = message->getMediaContents();
 468     if (mediaCont != nullptr)
 469     {
 470         jstring jIconImage = env->NewStringUTF(mediaCont->getIconImage().c_str());
 471         jclass cls_mediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));
 472         if (!cls_mediaContents)
 473         {
 474             LOGE ("Failed to Get ObjectClass for MediaContents");
 475             return NULL;
 476         }
 477         jmethodID mid_mediaContents = env->GetMethodID(
 478                                           cls_mediaContents, "<init>", "(Ljava/lang/String;)V");
 479         if (!mid_mediaContents)
 480         {
 481             LOGE ("Failed to Get MethodID for MediaContents<init>");
 482             return NULL;
 483         }
 484         jobject obj_mediaContents = env->NewObject(cls_mediaContents, mid_mediaContents,
 485                                     jIconImage);
 486
 487         jfieldID fid_mediaContents = env->GetFieldID(cls_message, "mMediaContents",
 488                                      "Lorg/iotivity/service/ns/common/MediaContents;");
 489         if (!fid_mediaContents)
 490         {
 491             LOGE("Failed to get field mediaContents for Message");
 492             return NULL;
 493         }
 494         env->SetObjectField(obj_message, fid_mediaContents, obj_mediaContents);
 495
 496     }
 497
 498     jobject jType = getJavaMessageType(env, message->getType());
 499     if (jType)
 500     {
 501         jfieldID fid_type = env->GetFieldID(cls_message, "mType",
 502                                             "Lorg/iotivity/service/ns/common/Message$MessageType;");
 503         if (!fid_type)
 504         {
 505             LOGE("Failed to get field Type for Message");
 506             return NULL;
 507         }
 508         env->SetObjectField(obj_message, fid_type, jType);
 509     }
 510
 511     LOGD("Reading OCRepresentation Object from Native");
 512     OC::OCRepresentation *ocRepresentation = new OC::OCRepresentation(message->getExtraInfo());
 513     jlong handle = reinterpret_cast<jlong>(ocRepresentation);
 514     jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 515                               handle, true);
 516     if (!jRepresentation)
 517     {
 518         LOGE("Failed to create OcRepresentation");
 519         delete ocRepresentation;
 520     }
 521     else
 522     {
 523         LOGD("Created OCRepresentation Object from Native");
 524     }
 525     jfieldID fid_extraInfo = env->GetFieldID(cls_message, "mExtraInfo",
 526                              "Lorg/iotivity/base/OcRepresentation;");
 527     if (!fid_extraInfo)
 528     {
 529         LOGE("Failed to get mExtraInfo for Message");
 530         delete ocRepresentation;
 531         return NULL;
 532     }
 533     LOGD ("setting extraInfo field");
 534     env->SetObjectField(obj_message, fid_extraInfo, jRepresentation);
 535
 536     env->DeleteLocalRef(cls_message);
 537     LOGD ("JNIProviderService: getJavaMessage - OUT");
 538     return obj_message;
 539 }
 540
 541 jobject getJavaTopicState(JNIEnv *env, OIC::Service::NSTopic::NSTopicState nsState)
 542 {
 543     LOGD("JNIProviderService: getJavaTopicState - IN");
 544
 545     // TopicState
 546     jclass cls_topicState = (jclass) (env->NewLocalRef(g_cls_TopicState));
 547     if (!cls_topicState)
 548     {
 549         LOGE ("Failed to Get ObjectClass for TopicState Type");
 550         return NULL;
 551     }
 552
 553     switch (nsState)
 554     {
 555         case OIC::Service::NSTopic::NSTopicState::UNSUBSCRIBED:
 556             {
 557                 static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,
 558                                           "UNSUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");
 559                 return env->GetStaticObjectField(cls_topicState, fieldID);
 560             }
 561         case OIC::Service::NSTopic::NSTopicState::SUBSCRIBED:
 562             {
 563                 static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,
 564                                           "SUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");
 565                 return env->GetStaticObjectField(cls_topicState, fieldID);
 566             }
 567         default:
 568             return NULL;
 569
 570     }
 571
 572     LOGD("JNIProviderService: getJavaTopicState - OUT");
 573     return NULL;
 574 }
 575
 576 jobject getJavaTopicsList(JNIEnv *env, OIC::Service::NSTopicsList *topicList)
 577 {
 578     LOGD("JNIProviderService: getJavaTopicsList - IN");
 579     jclass cls_topicList = (jclass) (env->NewLocalRef(g_cls_TopicsList));
 580     if (!cls_topicList)
 581     {
 582         LOGE ("Failed to Get ObjectClass for TopicsList");
 583         return NULL;
 584     }
 585     jmethodID mid_topicList = env->GetMethodID(cls_topicList, "<init>", "()V");
 586     if (!mid_topicList)
 587     {
 588         LOGE ("Failed to Get MethodID for TopicsList<init>");
 589         return NULL;
 590     }
 591     jobject obj_topicList = env->NewObject(cls_topicList, mid_topicList);
 592     if (!obj_topicList)
 593     {
 594         LOGE ("Failed to Get object for TopicsList");
 595         return NULL;
 596     }
 597     jmethodID mid_addTopic = env->GetMethodID(cls_topicList, "addTopic",
 598                              "(Ljava/lang/String;Lorg/iotivity/service/ns/common/Topic$TopicState;)V");
 599     if (!mid_addTopic)
 600     {
 601         LOGE ("Failed to Get MethodID for addTopic");
 602         return NULL;
 603     }
 604     for (auto it : topicList->getTopicsList())
 605     {
 606         jobject jState = getJavaTopicState(env, it->getState());
 607         std::string topicName = it->getTopicName();
 608         jstring jTopicName = env->NewStringUTF(topicName.c_str());
 609         env->CallVoidMethod(obj_topicList, mid_addTopic, jTopicName, jState);
 610     }
 611     env->DeleteLocalRef(cls_topicList);
 612     LOGD("JNIProviderService: getJavaTopicsList - OUT");
 613     return obj_topicList;
 614 }
 615
 616 jobject getJavaSyncType(JNIEnv *env, OIC::Service::NSSyncInfo::NSSyncType nsType)
 617 {
 618     LOGD ("JNIProviderService: getJavaSyncType - IN");
 619
 620     // SyncType
 621     jclass cls_SyncType = (jclass) (env->NewLocalRef(g_cls_SyncType));
 622     if (!cls_SyncType)
 623     {
 624         LOGE ("Failed to Get ObjectClass for SyncType");
 625         return NULL;
 626     }
 627     switch (nsType)
 628     {
 629         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_UNREAD:
 630             {
 631                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 632                                           "UNREAD", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 633                 return env->GetStaticObjectField(cls_SyncType, fieldID);
 634             }
 635         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ :
 636             {
 637                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 638                                           "READ", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 639                 return env->GetStaticObjectField(cls_SyncType, fieldID);
 640             }
 641         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED :
 642             {
 643                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 644                                           "DELETED", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 645                 return env->GetStaticObjectField(cls_SyncType, fieldID);
 646             }
 647         default:
 648             return NULL;
 649     }
 650
 651     LOGD ("JNIProviderService: getJavaSyncType - OUT");
 652     return NULL;
 653 }
 654
 655
 656 void onSubscribeListenerCb(OIC::Service::NSConsumer *consumer)
 657 {
 658     LOGD("JNIProviderService_onSubscribeListenerCb - IN");
 659
 660     jint envRet;
 661     JNIEnv *env = GetJNIEnv(&envRet);
 662     if (NULL == env) return ;
 663
 664     jobject jSubscriptionListener = (jobject) env->NewLocalRef(g_obj_subscriptionListener);
 665     if (!jSubscriptionListener)
 666     {
 667         LOGE ("Failed to Get jSubscriptionListener");
 668         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 669         return ;
 670     }
 671
 672     LOGD("consumer ID : %s\n", consumer->getConsumerId().c_str());
 673
 674     jstring jConsumerId = env->NewStringUTF( consumer->getConsumerId().c_str());
 675
 676     jclass cls_consumer = (jclass) (env->NewLocalRef(g_cls_Consumer));
 677     if (!cls_consumer)
 678     {
 679         LOGE ("Failed to Get ObjectClass for Consumer");
 680         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 681         return ;
 682     }
 683
 684     jmethodID mid_consumer = env->GetMethodID(
 685                                  cls_consumer,
 686                                  "<init>",
 687                                  "(Ljava/lang/String;)V");
 688     if (!mid_consumer)
 689     {
 690         LOGE ("Failed to Get MethodID for Consumer<init>");
 691         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 692         return ;
 693     }
 694     jobject obj_consumer = env->NewObject( cls_consumer, mid_consumer, jConsumerId);
 695
 696     jclass cls = env->GetObjectClass( jSubscriptionListener);
 697     if (!cls)
 698     {
 699         LOGE("Failed to Get ObjectClass of jSubscriptionListener");
 700         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 701         return;
 702     }
 703     jmethodID mid = env->GetMethodID(
 704                         cls,
 705                         "onConsumerSubscribed",
 706                         "(Lorg/iotivity/service/ns/provider/Consumer;)V");
 707     if (!mid)
 708     {
 709         LOGE("Failed to Get MethodID of onConsumerSubscribed");
 710         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 711         return;
 712     }
 713
 714     env->CallVoidMethod( jSubscriptionListener, mid, obj_consumer);
 715     env->DeleteLocalRef(jSubscriptionListener);
 716     env->DeleteLocalRef(cls_consumer);
 717     if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 718     LOGD("JNIProviderService_onSubscribeListenerCb - OUT");
 719     return;
 720 }
 721
 722 void onSyncInfoListenerCb(OIC::Service::NSSyncInfo *sync)
 723 {
 724     LOGD("JNIProviderService_onSyncInfoListenerCb - IN");
 725
 726     jint envRet;
 727     JNIEnv *env = GetJNIEnv(&envRet);
 728     if (NULL == env) return ;
 729
 730     jobject jSyncListener = (jobject) env->NewLocalRef(g_obj_syncListener);
 731     if (!jSyncListener)
 732     {
 733         LOGE ("Failed to Get jSyncListener");
 734         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 735         return ;
 736     }
 737
 738     LOGD("Sync ID : %ld\n", (long) sync->getMessageId());
 739     LOGD("Sync STATE : %d\n", (int) sync->getState());
 740
 741     jlong jMessageId = (long)  sync->getMessageId();
 742     jstring jProviderId = env->NewStringUTF(sync->getProviderId().c_str());
 743     jobject syncType = getJavaSyncType(env, sync->getState());
 744     if (!syncType)
 745     {
 746         LOGE ("Failed to Get syncType for SyncInfo");
 747         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 748         return ;
 749     }
 750     jclass cls_SyncInfo = (jclass) (env->NewLocalRef(g_cls_SyncInfo));
 751     if (!cls_SyncInfo)
 752     {
 753         LOGE ("Failed to Get ObjectClass for SyncInfo");
 754         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 755         return ;
 756     }
 757     jmethodID mid_syncInfo = env->GetMethodID(
 758                                  cls_SyncInfo,
 759                                  "<init>",
 760                                  "(JLjava/lang/String;Lorg/iotivity/service/ns/common/SyncInfo$SyncType;)V");
 761     if (!mid_syncInfo)
 762     {
 763         LOGE ("Failed to Get MethodID for SyncInfo");
 764         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 765         return ;
 766     }
 767
 768     jobject obj_syncInfo = env->NewObject( cls_SyncInfo, mid_syncInfo,
 769                                            jMessageId, jProviderId, syncType);
 770     if (!obj_syncInfo)
 771     {
 772         LOGE ("Failed to Get Object for SyncInfo");
 773         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 774         return ;
 775     }
 776
 777     jclass cls = env->GetObjectClass( jSyncListener);
 778     if (!cls)
 779     {
 780         LOGE("Failed to Get ObjectClass");
 781         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 782         return;
 783     }
 784     jmethodID mid = env->GetMethodID(
 785                         cls,
 786                         "onMessageSynchronized",
 787                         "(Lorg/iotivity/service/ns/common/SyncInfo;)V");
 788     if (!mid)
 789     {
 790         LOGE("Failed to Get MethodID");
 791         if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 792         return;
 793     }
 794     env->CallVoidMethod( jSyncListener, mid, obj_syncInfo);
 795
 796     env->DeleteLocalRef(jSyncListener);
 797     env->DeleteLocalRef(cls_SyncInfo);
 798     if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
 799
 800     LOGD("JNIProviderService: OnSyncInfoListenerCb - OUT");
 801     return;
 802
 803 }
 804
 805 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStart
 806 (JNIEnv *env, jobject jObj, jobject jSubscriptionListener, jobject jSyncListener,
 807  jboolean jPolicy, jstring jUserInfo, jboolean jResourceSecurity)
 808 {
 809     LOGD("JNIProviderService: nativeStart - IN");
 810     if (!jSubscriptionListener || !jSyncListener)
 811     {
 812         LOGE("Fail to set listeners");
 813         ThrowNSException(NS_ERROR, "Listener cannot be null");
 814         return (jint) OIC::Service::NSResult::ERROR;
 815     }
 816
 817     if (g_obj_subscriptionListener != NULL)
 818     {
 819         env->DeleteGlobalRef(g_obj_subscriptionListener);
 820     }
 821     if (g_obj_syncListener != NULL)
 822     {
 823         env->DeleteGlobalRef(g_obj_syncListener);
 824     }
 825
 826     g_obj_subscriptionListener = (jobject)  env->NewGlobalRef(jSubscriptionListener);
 827     g_obj_syncListener = (jobject)  env->NewGlobalRef(jSyncListener);
 828
 829     // check access policy
 830
 831     OIC::Service::NSProviderService::ProviderConfig cfg;
 832     cfg.m_subscribeRequestCb =  onSubscribeListenerCb;
 833     cfg.m_syncInfoCb =  onSyncInfoListenerCb;
 834     cfg.subControllability = (bool) jPolicy;
 835     if (!jUserInfo)
 836     {
 837         const char *info = env->GetStringUTFChars( jUserInfo, NULL);
 838         std::string userInfo(info);
 839         cfg.userInfo = userInfo;
 840     }
 841     cfg.resourceSecurity = (bool) jResourceSecurity;
 842
 843     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->start(cfg);
 844     if (result != OIC::Service::NSResult::OK)
 845     {
 846         LOGE("Fail to start NSProviderService");
 847
 848     }
 849
 850     LOGD("JNIProviderService: nativeStart - OUT");
 851     return (jint) result;
 852 }
 853
 854 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop
 855 (JNIEnv *env, jobject jObj)
 856 {
 857     LOGD("JNIProviderService: nativeStop - IN");
 858
 859     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->stop();
 860     if (result !=  OIC::Service::NSResult::OK)
 861     {
 862         LOGD("Fail to stop NSProvider service");
 863         return (jint) result;
 864     }
 865
 866     env->DeleteGlobalRef( g_obj_subscriptionListener);
 867     env->DeleteGlobalRef( g_obj_syncListener);
 868     g_obj_subscriptionListener = NULL;
 869     g_obj_syncListener = NULL;
 870
 871     LOGD("JNIProviderService: nativeStop - OUT");
 872     return (jint) result;
 873 }
 874
 875 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage
 876 (JNIEnv *env, jobject jObj, jobject jMsg)
 877 {
 878     LOGD("JNIProviderService: nativeSendMessage - IN");
 879     if (!jMsg)
 880     {
 881         LOGD("Fail to send notification - Message is null");
 882         ThrowNSException(NS_ERROR, "Message cannot be null");
 883         return (jint) OIC::Service::NSResult::ERROR;
 884     }
 885     OIC::Service::NSMessage *nsMsg = getNativeMessage(env, jMsg);
 886     if (nsMsg == nullptr)
 887     {
 888         ThrowNSException(NS_ERROR, "Message didn't have a field ID ");
 889         return (jint) OIC::Service::NSResult::ERROR;
 890     }
 891
 892     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->sendMessage(nsMsg);
 893     if (result !=  OIC::Service::NSResult::OK)
 894     {
 895         LOGD("Fail to send NSProvider Message");
 896     }
 897     LOGD("JNIProviderService: nativeSendMessage - OUT");
 898     return (jint) result;
 899 }
 900
 901 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendSyncInfo
 902 (JNIEnv *env, jobject jObj, jlong messageId , jint syncState)
 903 {
 904     LOGD("JNIProviderService: nativeSendSyncInfo - IN");
 905     OIC::Service::NSProviderService::getInstance()->sendSyncInfo( messageId,
 906             (OIC::Service::NSSyncInfo::NSSyncType) syncState);
 907     LOGD("JNIProviderService: nativeSendSyncInfo - OUT");
 908     return;
 909 }
 910
 911 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeCreateMessage
 912 (JNIEnv *env, jobject jObj)
 913 {
 914     LOGD("JNIProviderService: nativeCreateMessage - IN");
 915     OIC::Service::NSMessage *message =
 916         OIC::Service::NSProviderService::getInstance()->createMessage();
 917     if (message == nullptr)
 918     {
 919         ThrowNSException(NS_ERROR, "Couldn't get Native Message");
 920         return NULL;
 921     }
 922     jobject jMsg =  getJavaMessage(env, message);
 923     if (!jMsg)
 924     {
 925         ThrowNSException(NS_ERROR, "Couldn't create Java Message");
 926         return NULL;
 927     }
 928     LOGD("JNIProviderService: nativeCreateMessage - OUT");
 929     return jMsg;
 930 }
 931
 932 JNIEXPORT jint JNICALL
 933 Java_org_iotivity_service_ns_provider_ProviderService_nativeEnableRemoteService
 934 (JNIEnv *env, jobject jObj, jstring jstr)
 935 {
 936     LOGD("JNIProviderService: nativeEnableRemoteService - IN");
 937     if (!jstr)
 938     {
 939         ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
 940         return (jint) OIC::Service::NSResult::ERROR;
 941     }
 942
 943     const char *address = env->GetStringUTFChars( jstr, NULL);
 944     std::string servAddress(address);
 945     OIC::Service::NSResult result  =
 946         OIC::Service::NSProviderService::getInstance()->enableRemoteService(
 947             servAddress);
 948     if (result !=  OIC::Service::NSResult::OK)
 949     {
 950         LOGE("Fail to Enable Remote Service");
 951     }
 952     env->ReleaseStringUTFChars(jstr, address);
 953     LOGD("JNIProviderService: nativeEnableRemoteService - OUT");
 954     return (jint) result;
 955 }
 956
 957 JNIEXPORT jint JNICALL
 958 Java_org_iotivity_service_ns_provider_ProviderService_nativeDisableRemoteService
 959 (JNIEnv *env, jobject jObj, jstring jstr)
 960 {
 961     LOGD("JNIProviderService: nativeDisableRemoteService - IN");
 962     if (!jstr)
 963     {
 964         ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
 965         return (jint) OIC::Service::NSResult::ERROR;
 966     }
 967
 968     const char *address = env->GetStringUTFChars( jstr, NULL);
 969     std::string servAddress(address);
 970     OIC::Service::NSResult result  =
 971         OIC::Service::NSProviderService::getInstance()->disableRemoteService(
 972             servAddress);
 973     if (result !=  OIC::Service::NSResult::OK)
 974     {
 975         LOGE("Fail to Disable Remote Service");
 976     }
 977     env->ReleaseStringUTFChars(jstr, address);
 978     LOGD("JNIProviderService: nativeDisableRemoteService - OUT");
 979     return (jint) result;
 980 }
 981
 982 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeRegisterTopic
 983 (JNIEnv *env, jobject jObj, jstring jTopicName)
 984 {
 985     LOGD("JNIProviderService: nativeRegisterTopic - IN");
 986     if (!jTopicName)
 987     {
 988         ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
 989         return (jint) OIC::Service::NSResult::ERROR;
 990     }
 991     const char *name = env->GetStringUTFChars( jTopicName, NULL);
 992     std::string topicName(name);
 993     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->registerTopic(
 994                                          topicName);
 995     if (result !=  OIC::Service::NSResult::OK)
 996     {
 997         LOGE("Fail to Register Topic");
 998     }
 999     env->ReleaseStringUTFChars(jTopicName, name);
1000     LOGD("JNIProviderService: nativeRegisterTopic - OUT");
1001     return (jint) result;
1002 }
1003 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeUnregisterTopic
1004 (JNIEnv *env, jobject jObj, jstring jTopicName)
1005 {
1006     LOGD("JNIProviderService: nativeUnregisterTopic - IN");
1007     if (!jTopicName)
1008     {
1009         ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
1010         return (jint) OIC::Service::NSResult::ERROR;
1011     }
1012     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1013     std::string topicName(name);
1014     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->unregisterTopic(
1015                                          topicName);
1016     if (result !=  OIC::Service::NSResult::OK)
1017     {
1018         LOGE("Fail to Unregister Topic");
1019     }
1020     env->ReleaseStringUTFChars(jTopicName, name);
1021     LOGD("JNIProviderService: nativeUnregisterTopic - OUT");
1022     return (jint) result;
1023 }
1024
1025 JNIEXPORT jobject JNICALL
1026 Java_org_iotivity_service_ns_provider_ProviderService_nativeGetRegisteredTopicList
1027 (JNIEnv *env, jobject jObj)
1028 {
1029     LOGD("JNIProviderService: nativeGetRegisteredTopicList - IN");
1030
1031     OIC::Service::NSTopicsList *topicList  =
1032         OIC::Service::NSProviderService::getInstance()->getRegisteredTopicList();
1033     if (topicList == nullptr)
1034     {
1035         ThrowNSException(NS_ERROR, "Topic List doesn't exist");
1036         return NULL;
1037     }
1038
1039     jobject obj_topicList = getJavaTopicsList(env, topicList);
1040
1041     LOGD("JNIProviderService: nativeGetRegisteredTopicList - OUT");
1042     return obj_topicList;
1043 }
1044
1045 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription
1046 (JNIEnv *env,  jobject jObj, jstring jConsumerId, jboolean jAccepted)
1047 {
1048     LOGD("JNIProviderService: nativeAcceptSubscription - IN");
1049     if (!jConsumerId)
1050     {
1051         ThrowNSException(NS_ERROR, "ConsumerId Can't be NULL");
1052         return (jint) OIC::Service::NSResult::ERROR;
1053     }
1054     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1055     std::string consumerId(id);
1056     LOGD("Consumer ID: %s\n", consumerId.c_str());
1057
1058     OIC::Service::NSConsumer *consumer =
1059         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1060     if (consumer)
1061         return (jint) consumer->acceptSubscription((bool)jAccepted);
1062
1063     LOGE("Couldn't find consumer");
1064     LOGD("JNIProviderService: nativeAcceptSubscription - OUT");
1065     return (jint) OIC::Service::NSResult::ERROR;
1066 }
1067 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeSetConsumerTopic
1068 (JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
1069 {
1070     LOGD("JNIProviderService: nativeSetConsumerTopic - IN");
1071     if (!jConsumerId || !jTopicName)
1072     {
1073         ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
1074         return (jint) OIC::Service::NSResult::ERROR;
1075     }
1076     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1077     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1078     std::string topicName(name);
1079     std::string consumerId(id);
1080     OIC::Service::NSConsumer *nsConsumer =
1081         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1082     if (!nsConsumer)
1083     {
1084         ThrowNSException(NS_ERROR, "Consumer does exists");
1085         return (jint) OIC::Service::NSResult::ERROR;
1086     }
1087     OIC::Service::NSResult result  = nsConsumer->setTopic(topicName);
1088
1089     if (result !=  OIC::Service::NSResult::OK)
1090     {
1091         LOGD("Fail to Select Topic");
1092     }
1093     env->ReleaseStringUTFChars(jTopicName, name);
1094     env->ReleaseStringUTFChars(jConsumerId, id);
1095     LOGD("JNIProviderService: nativeSetConsumerTopic - OUT");
1096     return (jint) result;
1097 }
1098 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeUnsetConsumerTopic
1099 (JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
1100 {
1101     LOGD("JNIProviderService: nativeUnsetConsumerTopic - IN");
1102     if (!jConsumerId || !jTopicName)
1103     {
1104         ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
1105         return (jint) OIC::Service::NSResult::ERROR;
1106     }
1107     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1108     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1109     std::string topicName(name);
1110     std::string consumerId(id);
1111     OIC::Service::NSConsumer *nsConsumer =
1112         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1113     if (!nsConsumer)
1114     {
1115         ThrowNSException(NS_ERROR, "Consumer does exists");
1116         return (jint) OIC::Service::NSResult::ERROR;
1117     }
1118     OIC::Service::NSResult result  = nsConsumer->unsetTopic(topicName);
1119
1120     if (result !=  OIC::Service::NSResult::OK)
1121     {
1122         LOGE("Fail to Unselect Topic");
1123     }
1124     env->ReleaseStringUTFChars(jTopicName, name);
1125     env->ReleaseStringUTFChars(jConsumerId, id);
1126     LOGD("JNIProviderService: nativeUnsetConsumerTopic - OUT");
1127     return (jint) result;
1128 }
1129
1130 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeGetConsumerTopicList
1131 (JNIEnv *env, jobject jObj, jstring jConsumerId)
1132 {
1133     LOGD("JNIProviderService: nativeGetConsumerTopicList - IN");
1134     if (!jConsumerId)
1135     {
1136         ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
1137         return NULL;
1138     }
1139     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1140     std::string consumerId(id);
1141     OIC::Service::NSConsumer *nsConsumer =
1142         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1143     if (!nsConsumer)
1144     {
1145         ThrowNSException(NS_ERROR, "Consumer does exists");
1146         return NULL;
1147     }
1148     env->ReleaseStringUTFChars(jConsumerId, id);
1149     OIC::Service::NSTopicsList *topicList  = nsConsumer->getConsumerTopicList();
1150     if (topicList == nullptr)
1151     {
1152         ThrowNSException(NS_ERROR, "Topic List doesn't exist");
1153         return NULL;
1154     }
1155     jobject obj_topicList = getJavaTopicsList(env, topicList);
1156     LOGD("JNIProviderService: nativeGetConsumerTopicList - OUT");
1157     return obj_topicList;
1158 }
1159
1160 // JNI OnLoad
1161 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
1162 {
1163     LOGD("ProviderService_JNI_OnLoad");
1164     g_jvm_provider = jvm;
1165
1166     JNIEnv *env;
1167     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
1168     {
1169         LOGE("Failed to get the environment using GetEnv()");
1170         return JNI_ERR;
1171     }
1172
1173     jclass localMessage = env->FindClass(
1174                               "org/iotivity/service/ns/common/Message");
1175     if (!localMessage)
1176     {
1177         LOGE("Failed to get local Message class");
1178         return JNI_ERR;
1179     }
1180     g_cls_Message = (jclass) (env->NewGlobalRef(localMessage));
1181     if (!g_cls_Message)
1182     {
1183         LOGE("Failed to set Global Message reference");
1184         return JNI_ERR;
1185     }
1186
1187     jclass localMessageType = env->FindClass(
1188                                   "org/iotivity/service/ns/common/Message$MessageType");
1189     if (!localMessageType)
1190     {
1191         LOGE("Failed to get local Message Type class");
1192         return JNI_ERR;
1193     }
1194     g_cls_Message_Type = (jclass) (env->NewGlobalRef(localMessageType));
1195     if (!g_cls_Message_Type)
1196     {
1197         LOGE("Failed to set Global Message Type reference");
1198         return JNI_ERR;
1199     }
1200
1201     jclass localConsumer = env->FindClass(
1202                                "org/iotivity/service/ns/provider/Consumer");
1203     if (!localConsumer)
1204     {
1205         LOGE("Failed to get local Provider class");
1206         return JNI_ERR;
1207     }
1208     g_cls_Consumer = (jclass) (env->NewGlobalRef(localConsumer));
1209     if (!g_cls_Consumer)
1210     {
1211         LOGE("Failed to set Global Provider reference");
1212         return JNI_ERR;
1213     }
1214
1215     jclass localSyncInfo = env->FindClass(
1216                                "org/iotivity/service/ns/common/SyncInfo");
1217     if (!localSyncInfo)
1218     {
1219         LOGE("Failed to get local SyncInfo class");
1220         return JNI_ERR;
1221     }
1222     g_cls_SyncInfo = (jclass) (env->NewGlobalRef(localSyncInfo));
1223     if (!g_cls_SyncInfo)
1224     {
1225         LOGE("Failed to set Global SyncInfo reference");
1226         return JNI_ERR;
1227     }
1228
1229     jclass localSyncType = env->FindClass(
1230                                "org/iotivity/service/ns/common/SyncInfo$SyncType");
1231     if (!localSyncType)
1232     {
1233         LOGE("Failed to get local SyncType enum");
1234         return JNI_ERR;
1235     }
1236     g_cls_SyncType = (jclass) (env->NewGlobalRef(localSyncType));
1237     if (!g_cls_SyncType)
1238     {
1239         LOGE("Failed to set Global SyncType reference");
1240         return JNI_ERR;
1241     }
1242
1243     jclass localMediaContents = env->FindClass(
1244                                     "org/iotivity/service/ns/common/MediaContents");
1245     if (!localMediaContents)
1246     {
1247         LOGE("Failed to get local MediaContents class");
1248         return JNI_ERR;
1249     }
1250     g_cls_MediaContents = (jclass) (env->NewGlobalRef(localMediaContents));
1251     if (!g_cls_MediaContents)
1252     {
1253         LOGE("Failed to set Global MediaContents reference");
1254         return JNI_ERR;
1255     }
1256
1257     jclass localTopic = env->FindClass(
1258                             "org/iotivity/service/ns/common/Topic");
1259     if (!localTopic)
1260     {
1261         LOGE("Failed to get local Topic class");
1262         return JNI_ERR;
1263     }
1264     g_cls_Topic = (jclass) (env->NewGlobalRef(localTopic));
1265     if (!g_cls_Topic)
1266     {
1267         LOGE("Failed to set Global Topic reference");
1268         return JNI_ERR;
1269     }
1270
1271     jclass localTopicsList = env->FindClass(
1272                                  "org/iotivity/service/ns/common/TopicsList");
1273     if (!localTopicsList)
1274     {
1275         LOGE("Failed to get local Topic class");
1276         return JNI_ERR;
1277     }
1278     g_cls_TopicsList = (jclass) (env->NewGlobalRef(localTopicsList));
1279     if (!g_cls_TopicsList)
1280     {
1281         LOGE("Failed to set Global TopicsList reference");
1282         return JNI_ERR;
1283     }
1284
1285     jclass localTopicState = env->FindClass(
1286                                  "org/iotivity/service/ns/common/Topic$TopicState");
1287     if (!localTopicState)
1288     {
1289         LOGE("Failed to get local TopicState enum");
1290         return JNI_ERR;
1291     }
1292     g_cls_TopicState = (jclass) (env->NewGlobalRef(localTopicState));
1293     if (!g_cls_TopicState)
1294     {
1295         LOGE("Failed to set Global TopicState reference");
1296         return JNI_ERR;
1297     }
1298
1299     //OcRepresentation
1300     jclass localOcRepresentation = env->FindClass("org/iotivity/base/OcRepresentation");
1301     if (!localOcRepresentation)
1302     {
1303         LOGE("Failed to get local OcRepresentation class");
1304         return JNI_ERR;
1305     }
1306     g_cls_OcRepresentation = (jclass) env->NewGlobalRef(localOcRepresentation);
1307     if (!g_cls_OcRepresentation)
1308     {
1309         LOGE("Failed to set Global OcRepresentation reference");
1310         return JNI_ERR;
1311     }
1312
1313     g_mid_OcRepresentation_N_ctor_bool = env->GetMethodID(g_cls_OcRepresentation, "<init>", "(JZ)V");
1314     if (!g_mid_OcRepresentation_N_ctor_bool)
1315     {
1316         LOGE("Failed to get Global OcRepresentation Constructor reference");
1317         return JNI_ERR;
1318     }
1319
1320     env->DeleteLocalRef(localMessage);
1321     env->DeleteLocalRef(localMessageType);
1322     env->DeleteLocalRef(localConsumer);
1323     env->DeleteLocalRef(localSyncInfo);
1324     env->DeleteLocalRef(localSyncType);
1325     env->DeleteLocalRef(localMediaContents);
1326     env->DeleteLocalRef(localTopic);
1327     env->DeleteLocalRef(localTopicsList);
1328     env->DeleteLocalRef(localTopicState);
1329     env->DeleteLocalRef(localOcRepresentation);
1330
1331     return NSExceptionInit(env);
1332 }
1333
1334 JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)
1335 {
1336     LOGD("ProviderService_JNI_OnUnload");
1337     JNIEnv *env;
1338
1339     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
1340     {
1341         LOGE("Failed to get the environment using GetEnv()");
1342         return ;
1343     }
1344
1345     env->DeleteGlobalRef(g_cls_Message);
1346     env->DeleteGlobalRef(g_cls_Consumer);
1347     env->DeleteGlobalRef(g_cls_SyncInfo);
1348     env->DeleteGlobalRef(g_cls_SyncType);
1349     env->DeleteGlobalRef(g_cls_MediaContents);
1350     env->DeleteGlobalRef(g_cls_Message_Type);
1351     env->DeleteGlobalRef(g_cls_Topic);
1352     env->DeleteGlobalRef(g_cls_TopicsList);
1353     env->DeleteGlobalRef(g_cls_TopicState);
1354     env->DeleteGlobalRef(g_cls_OcRepresentation);
1355 }