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