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     }
 552     else
 553     {
 554         NS_LOGD ("Created OCRepresentation Object from Native");
 555     }
 556     jfieldID fid_extraInfo = env->GetFieldID(cls_message, "mExtraInfo",
 557                              "Lorg/iotivity/base/OcRepresentation;");
 558     if (!fid_extraInfo)
 559     {
 560         NS_LOGE ("Failed to get mExtraInfo for Message");
 561         delete ocRepresentation;
 562         return NULL;
 563     }
 564     NS_LOGD ("setting extraInfo field");
 565     env->SetObjectField(obj_message, fid_extraInfo, jRepresentation);
 566
 567     env->DeleteLocalRef(cls_message);
 568     NS_LOGD ("JNIProviderService: getJavaMessage - OUT");
 569     return obj_message;
 570 }
 571
 572 jobject getJavaTopicState(JNIEnv *env, OIC::Service::NSTopic::NSTopicState nsState)
 573 {
 574     NS_LOGD ("JNIProviderService: getJavaTopicState - IN");
 575
 576     // TopicState
 577     jclass cls_topicState = (jclass) (env->NewLocalRef(g_cls_TopicState));
 578     if (!cls_topicState)
 579     {
 580         NS_LOGE ("Failed to Get ObjectClass for TopicState Type");
 581         return NULL;
 582     }
 583     jobject topicState = NULL;
 584
 585     switch (nsState)
 586     {
 587         case OIC::Service::NSTopic::NSTopicState::UNSUBSCRIBED:
 588             {
 589                 static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,
 590                                           "UNSUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");
 591                 topicState = env->GetStaticObjectField(cls_topicState, fieldID);
 592                 break;
 593             }
 594         case OIC::Service::NSTopic::NSTopicState::SUBSCRIBED:
 595             {
 596                 static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,
 597                                           "SUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");
 598                 topicState = env->GetStaticObjectField(cls_topicState, fieldID);
 599                 break;
 600             }
 601         default:
 602             {
 603                 topicState = NULL;
 604                 break;
 605             }
 606     }
 607
 608     NS_LOGD ("JNIProviderService: getJavaTopicState - OUT");
 609     return topicState;
 610 }
 611
 612 jobject getJavaTopicsList(JNIEnv *env, std::shared_ptr<OIC::Service::NSTopicsList> topicList)
 613 {
 614     NS_LOGD ("JNIProviderService: getJavaTopicsList - IN");
 615     jclass cls_topicList = (jclass) (env->NewLocalRef(g_cls_TopicsList));
 616     if (!cls_topicList)
 617     {
 618         NS_LOGE ("Failed to Get ObjectClass for TopicsList");
 619         return NULL;
 620     }
 621     jmethodID mid_topicList = env->GetMethodID(cls_topicList, "<init>", "()V");
 622     if (!mid_topicList)
 623     {
 624         NS_LOGE ("Failed to Get MethodID for TopicsList<init>");
 625         return NULL;
 626     }
 627     jobject obj_topicList = env->NewObject(cls_topicList, mid_topicList);
 628     if (!obj_topicList)
 629     {
 630         NS_LOGE ("Failed to Get object for TopicsList");
 631         return NULL;
 632     }
 633     jmethodID mid_addTopic = env->GetMethodID(cls_topicList, "addTopic",
 634                              "(Ljava/lang/String;Lorg/iotivity/service/ns/common/Topic$TopicState;)V");
 635     if (!mid_addTopic)
 636     {
 637         NS_LOGE ("Failed to Get MethodID for addTopic");
 638         return NULL;
 639     }
 640     for (auto it : topicList->getTopicsList())
 641     {
 642         jobject jState = getJavaTopicState(env, it.getState());
 643         std::string topicName = it.getTopicName();
 644         jstring jTopicName = env->NewStringUTF(topicName.c_str());
 645         env->CallVoidMethod(obj_topicList, mid_addTopic, jTopicName, jState);
 646     }
 647     env->DeleteLocalRef(cls_topicList);
 648     NS_LOGD ("JNIProviderService: getJavaTopicsList - OUT");
 649     return obj_topicList;
 650 }
 651
 652 jobject getJavaSyncType(JNIEnv *env, OIC::Service::NSSyncInfo::NSSyncType nsType)
 653 {
 654     NS_LOGD ("JNIProviderService: getJavaSyncType - IN");
 655
 656     // SyncType
 657     jclass cls_SyncType = (jclass) (env->NewLocalRef(g_cls_SyncType));
 658     if (!cls_SyncType)
 659     {
 660         NS_LOGE ("Failed to Get ObjectClass for SyncType");
 661         return NULL;
 662     }
 663     jobject syncType = NULL;
 664     switch (nsType)
 665     {
 666         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_UNREAD:
 667             {
 668                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 669                                           "UNREAD", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 670                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
 671                 break;
 672             }
 673         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ :
 674             {
 675                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 676                                           "READ", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 677                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
 678                 break;
 679             }
 680         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED :
 681             {
 682                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 683                                           "DELETED", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 684                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
 685                 break;
 686             }
 687         default:
 688             {
 689                 syncType = NULL;
 690                 break;
 691             }
 692     }
 693
 694     NS_LOGD ("JNIProviderService: getJavaSyncType - OUT");
 695     return syncType;
 696 }
 697
 698
 699 void onSubscribeListenerCb(std::shared_ptr<OIC::Service::NSConsumer> consumer)
 700 {
 701     NS_LOGD ("JNIProviderService_onSubscribeListenerCb - IN");
 702
 703     jint envRet = 0;;
 704     JNIEnv *env = GetJNIEnv(&envRet);
 705     if (NULL == env)
 706     {
 707         return ;
 708     }
 709
 710     jobject jSubscriptionListener = (jobject) env->NewLocalRef(g_obj_subscriptionListener);
 711     if (!jSubscriptionListener)
 712     {
 713         NS_LOGE ("Failed to Get jSubscriptionListener");
 714         if (JNI_EDETACHED == envRet)
 715         {
 716             g_jvm_provider->DetachCurrentThread();
 717         }
 718         return ;
 719     }
 720
 721     NS_LOGD ("consumer ID : %s\n", consumer->getConsumerId().c_str());
 722
 723     jstring jConsumerId = env->NewStringUTF( consumer->getConsumerId().c_str());
 724
 725     jclass cls_consumer = (jclass) (env->NewLocalRef(g_cls_Consumer));
 726     if (!cls_consumer)
 727     {
 728         NS_LOGE ("Failed to Get ObjectClass for Consumer");
 729         if (JNI_EDETACHED == envRet)
 730         {
 731             g_jvm_provider->DetachCurrentThread();
 732         }
 733         return ;
 734     }
 735
 736     jmethodID mid_consumer = env->GetMethodID(
 737                                  cls_consumer,
 738                                  "<init>",
 739                                  "(Ljava/lang/String;)V");
 740     if (!mid_consumer)
 741     {
 742         NS_LOGE ("Failed to Get MethodID for Consumer<init>");
 743         if (JNI_EDETACHED == envRet)
 744         {
 745             g_jvm_provider->DetachCurrentThread();
 746         }
 747         return ;
 748     }
 749     jobject obj_consumer = env->NewObject( cls_consumer, mid_consumer, jConsumerId);
 750
 751     jclass cls = env->GetObjectClass( jSubscriptionListener);
 752     if (!cls)
 753     {
 754         NS_LOGE ("Failed to Get ObjectClass of jSubscriptionListener");
 755         if (JNI_EDETACHED == envRet)
 756         {
 757             g_jvm_provider->DetachCurrentThread();
 758         }
 759         return;
 760     }
 761     jmethodID mid = env->GetMethodID(
 762                         cls,
 763                         "onConsumerSubscribed",
 764                         "(Lorg/iotivity/service/ns/provider/Consumer;)V");
 765     if (!mid)
 766     {
 767         NS_LOGE ("Failed to Get MethodID of onConsumerSubscribed");
 768         if (JNI_EDETACHED == envRet)
 769         {
 770             g_jvm_provider->DetachCurrentThread();
 771         }
 772         return;
 773     }
 774
 775     env->CallVoidMethod( jSubscriptionListener, mid, obj_consumer);
 776     env->DeleteLocalRef(jSubscriptionListener);
 777     env->DeleteLocalRef(cls_consumer);
 778     if (JNI_EDETACHED == envRet)
 779     {
 780         g_jvm_provider->DetachCurrentThread();
 781     }
 782     NS_LOGD ("JNIProviderService_onSubscribeListenerCb - OUT");
 783     return;
 784 }
 785
 786 void onSyncInfoListenerCb(OIC::Service::NSSyncInfo sync)
 787 {
 788     NS_LOGD ("JNIProviderService_onSyncInfoListenerCb - IN");
 789
 790     jint envRet = 0;;
 791     JNIEnv *env = GetJNIEnv(&envRet);
 792     if (NULL == env)
 793     {
 794         return ;
 795     }
 796
 797     jobject jSyncListener = (jobject) env->NewLocalRef(g_obj_syncListener);
 798     if (!jSyncListener)
 799     {
 800         NS_LOGE ("Failed to Get jSyncListener");
 801         if (JNI_EDETACHED == envRet)
 802         {
 803             g_jvm_provider->DetachCurrentThread();
 804         }
 805         return ;
 806     }
 807
 808     NS_LOGD ("Sync ID : %ld\n", (long) sync.getMessageId());
 809     NS_LOGD ("Sync STATE : %d\n", (int) sync.getState());
 810
 811     jlong jMessageId = (long)  sync.getMessageId();
 812     jstring jProviderId = env->NewStringUTF(sync.getProviderId().c_str());
 813     jobject syncType = getJavaSyncType(env, sync.getState());
 814     if (!syncType)
 815     {
 816         NS_LOGE ("Failed to Get syncType for SyncInfo");
 817         if (JNI_EDETACHED == envRet)
 818         {
 819             g_jvm_provider->DetachCurrentThread();
 820         }
 821         return ;
 822     }
 823     jclass cls_SyncInfo = (jclass) (env->NewLocalRef(g_cls_SyncInfo));
 824     if (!cls_SyncInfo)
 825     {
 826         NS_LOGE ("Failed to Get ObjectClass for SyncInfo");
 827         if (JNI_EDETACHED == envRet)
 828         {
 829             g_jvm_provider->DetachCurrentThread();
 830         }
 831         return ;
 832     }
 833     jmethodID mid_syncInfo = env->GetMethodID(
 834                                  cls_SyncInfo,
 835                                  "<init>",
 836                                  "(JLjava/lang/String;Lorg/iotivity/service/ns/common/SyncInfo$SyncType;)V");
 837     if (!mid_syncInfo)
 838     {
 839         NS_LOGE ("Failed to Get MethodID for SyncInfo");
 840         if (JNI_EDETACHED == envRet)
 841         {
 842             g_jvm_provider->DetachCurrentThread();
 843         }
 844         return ;
 845     }
 846
 847     jobject obj_syncInfo = env->NewObject( cls_SyncInfo, mid_syncInfo,
 848                                            jMessageId, jProviderId, syncType);
 849     if (!obj_syncInfo)
 850     {
 851         NS_LOGE ("Failed to Get Object for SyncInfo");
 852         if (JNI_EDETACHED == envRet)
 853         {
 854             g_jvm_provider->DetachCurrentThread();
 855         }
 856         return ;
 857     }
 858
 859     jclass cls = env->GetObjectClass( jSyncListener);
 860     if (!cls)
 861     {
 862         NS_LOGE ("Failed to Get ObjectClass");
 863         if (JNI_EDETACHED == envRet)
 864         {
 865             g_jvm_provider->DetachCurrentThread();
 866         }
 867         return ;
 868     }
 869     jmethodID mid = env->GetMethodID(
 870                         cls,
 871                         "onMessageSynchronized",
 872                         "(Lorg/iotivity/service/ns/common/SyncInfo;)V");
 873     if (!mid)
 874     {
 875         NS_LOGE ("Failed to Get MethodID");
 876         if (JNI_EDETACHED == envRet)
 877         {
 878             g_jvm_provider->DetachCurrentThread();
 879         }
 880         return ;
 881     }
 882     env->CallVoidMethod( jSyncListener, mid, obj_syncInfo);
 883
 884     env->DeleteLocalRef(jSyncListener);
 885     env->DeleteLocalRef(cls_SyncInfo);
 886     if (JNI_EDETACHED == envRet)
 887     {
 888         g_jvm_provider->DetachCurrentThread();
 889     }
 890     NS_LOGD ("JNIProviderService: OnSyncInfoListenerCb - OUT");
 891     return;
 892
 893 }
 894
 895 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStart
 896 (JNIEnv *env, jobject jObj, jobject jSubscriptionListener, jobject jSyncListener,
 897  jboolean jPolicy, jstring jUserInfo, jboolean jResourceSecurity)
 898 {
 899     NS_LOGD ("JNIProviderService: nativeStart - IN");
 900     if (!jSubscriptionListener || !jSyncListener)
 901     {
 902         ThrowNSException(JNI_INVALID_VALUE, "Listener cannot be null");
 903         return;
 904     }
 905
 906     if (g_obj_subscriptionListener != NULL)
 907     {
 908         env->DeleteGlobalRef(g_obj_subscriptionListener);
 909     }
 910     if (g_obj_syncListener != NULL)
 911     {
 912         env->DeleteGlobalRef(g_obj_syncListener);
 913     }
 914
 915     g_obj_subscriptionListener = (jobject)  env->NewGlobalRef(jSubscriptionListener);
 916     g_obj_syncListener = (jobject)  env->NewGlobalRef(jSyncListener);
 917
 918     // check access policy
 919
 920     OIC::Service::NSProviderService::ProviderConfig cfg;
 921     cfg.m_subscribeRequestCb =  onSubscribeListenerCb;
 922     cfg.m_syncInfoCb =  onSyncInfoListenerCb;
 923     cfg.subControllability = (bool) jPolicy;
 924     if (!jUserInfo)
 925     {
 926         const char *info = env->GetStringUTFChars( jUserInfo, NULL);
 927         std::string userInfo(info);
 928         cfg.userInfo = userInfo;
 929     }
 930     cfg.resourceSecurity = (bool) jResourceSecurity;
 931
 932     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->start(cfg);
 933     if (result != OIC::Service::NSResult::OK)
 934     {
 935         ThrowNSException((int) result, "Fail to start NSProviderService");
 936         return;
 937     }
 938
 939     NS_LOGD ("JNIProviderService: nativeStart - OUT");
 940     return;
 941 }
 942
 943 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop
 944 (JNIEnv *env, jobject jObj)
 945 {
 946     NS_LOGD ("JNIProviderService: nativeStop - IN");
 947
 948     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->stop();
 949     if (result !=  OIC::Service::NSResult::OK)
 950     {
 951         ThrowNSException((int) result, "Fail to stop NSProviderService");
 952         return;
 953     }
 954
 955     env->DeleteGlobalRef( g_obj_subscriptionListener);
 956     env->DeleteGlobalRef( g_obj_syncListener);
 957     g_obj_subscriptionListener = NULL;
 958     g_obj_syncListener = NULL;
 959
 960     NS_LOGD ("JNIProviderService: nativeStop - OUT");
 961     return;
 962 }
 963
 964 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage
 965 (JNIEnv *env, jobject jObj, jobject jMsg)
 966 {
 967     NS_LOGD ("JNIProviderService: nativeSendMessage - IN");
 968     if (!jMsg)
 969     {
 970         ThrowNSException(JNI_INVALID_VALUE, "Message cannot be null");
 971         return;
 972     }
 973     OIC::Service::NSMessage nsMsg = getNativeMessage(env, jMsg);
 974
 975     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->sendMessage(nsMsg);
 976     if (result !=  OIC::Service::NSResult::OK)
 977     {
 978         ThrowNSException((int) result, "Fail to send NSProvider Message");
 979         return;
 980     }
 981     NS_LOGD ("JNIProviderService: nativeSendMessage - OUT");
 982     return;
 983 }
 984
 985 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendSyncInfo
 986 (JNIEnv *env, jobject jObj, jlong messageId , jint syncState)
 987 {
 988     NS_LOGD ("JNIProviderService: nativeSendSyncInfo - IN");
 989     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->sendSyncInfo(
 990                                         messageId,
 991                                         (OIC::Service::NSSyncInfo::NSSyncType) syncState);
 992     if (result !=  OIC::Service::NSResult::OK)
 993     {
 994         ThrowNSException((int) result, "Fail to send NSProvider SendSyncInfo");
 995         return;
 996     }
 997     NS_LOGD ("JNIProviderService: nativeSendSyncInfo - OUT");
 998     return;
 999 }
1000
1001 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeCreateMessage
1002 (JNIEnv *env, jobject jObj)
1003 {
1004     NS_LOGD ("JNIProviderService: nativeCreateMessage - IN");
1005     OIC::Service::NSMessage message =
1006         OIC::Service::NSProviderService::getInstance()->createMessage();
1007     jobject jMsg =  getJavaMessage(env, message);
1008     if (!jMsg)
1009     {
1010         ThrowNSException(JNI_INVALID_VALUE, "Couldn't create Java Message");
1011         return NULL;
1012     }
1013     NS_LOGD ("JNIProviderService: nativeCreateMessage - OUT");
1014     return jMsg;
1015 }
1016
1017 JNIEXPORT void JNICALL
1018 Java_org_iotivity_service_ns_provider_ProviderService_nativeEnableRemoteService
1019 (JNIEnv *env, jobject jObj, jstring jstr)
1020 {
1021     NS_LOGD ("JNIProviderService: nativeEnableRemoteService - IN");
1022     if (!jstr)
1023     {
1024         ThrowNSException(JNI_INVALID_VALUE, "Server Address Can't be NULL");
1025         return;
1026     }
1027
1028     const char *address = env->GetStringUTFChars( jstr, NULL);
1029     std::string servAddress(address);
1030     OIC::Service::NSResult result  =
1031         OIC::Service::NSProviderService::getInstance()->enableRemoteService(
1032             servAddress);
1033     if (result !=  OIC::Service::NSResult::OK)
1034     {
1035         ThrowNSException((int) result, "Fail to  Enable Remote Service");
1036         return;
1037     }
1038     env->ReleaseStringUTFChars(jstr, address);
1039     NS_LOGD ("JNIProviderService: nativeEnableRemoteService - OUT");
1040     return;
1041 }
1042
1043 JNIEXPORT void JNICALL
1044 Java_org_iotivity_service_ns_provider_ProviderService_nativeDisableRemoteService
1045 (JNIEnv *env, jobject jObj, jstring jstr)
1046 {
1047     NS_LOGD ("JNIProviderService: nativeDisableRemoteService - IN");
1048     if (!jstr)
1049     {
1050         ThrowNSException(JNI_INVALID_VALUE, "Server Address Can't be NULL");
1051         return;
1052     }
1053
1054     const char *address = env->GetStringUTFChars( jstr, NULL);
1055     std::string servAddress(address);
1056     OIC::Service::NSResult result  =
1057         OIC::Service::NSProviderService::getInstance()->disableRemoteService(
1058             servAddress);
1059     if (result !=  OIC::Service::NSResult::OK)
1060     {
1061         ThrowNSException((int) result, "Fail to  Disable Remote Service");
1062         return;
1063     }
1064     env->ReleaseStringUTFChars(jstr, address);
1065     NS_LOGD ("JNIProviderService: nativeDisableRemoteService - OUT");
1066     return;
1067 }
1068
1069 JNIEXPORT void JNICALL
1070 Java_org_iotivity_service_ns_provider_ProviderService_nativeSubscribeMQService
1071 (JNIEnv *env, jobject jObj, jstring jserverAddress, jstring jTopicName)
1072 {
1073     NS_LOGD ("JNIProviderService: nativeSubscribeMQService - IN");
1074     if (!jserverAddress)
1075     {
1076         ThrowNSException(JNI_INVALID_VALUE, "Server Address Can't be NULL");
1077         return;
1078     }
1079     if (!jTopicName)
1080     {
1081         ThrowNSException(JNI_INVALID_VALUE, "TopicName Can't be NULL");
1082         return;
1083     }
1084
1085     const char *address = env->GetStringUTFChars( jserverAddress, NULL);
1086     std::string servAddress(address);
1087     const char *topic = env->GetStringUTFChars( jTopicName, NULL);
1088     std::string topicName(topic);
1089
1090     OIC::Service::NSResult result  =
1091         OIC::Service::NSProviderService::getInstance()->subscribeMQService(
1092             servAddress, topicName);
1093     if (result !=  OIC::Service::NSResult::OK)
1094     {
1095         ThrowNSException((int) result, "Fail to  Subscribe to MQ Service");
1096         return;
1097     }
1098     env->ReleaseStringUTFChars(jserverAddress, address);
1099     env->ReleaseStringUTFChars(jTopicName, topic);
1100     NS_LOGD ("JNIProviderService: nativeSubscribeMQService - OUT");
1101     return;
1102 }
1103
1104 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeRegisterTopic
1105 (JNIEnv *env, jobject jObj, jstring jTopicName)
1106 {
1107     NS_LOGD ("JNIProviderService: nativeRegisterTopic - IN");
1108     if (!jTopicName)
1109     {
1110         ThrowNSException(JNI_INVALID_VALUE, "Topic Name Can't be NULL");
1111         return;
1112     }
1113     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1114     std::string topicName(name);
1115     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->registerTopic(
1116                                          topicName);
1117     if (result !=  OIC::Service::NSResult::OK)
1118     {
1119         ThrowNSException((int) result, "Fail to  Register Topic");
1120         return;
1121     }
1122     env->ReleaseStringUTFChars(jTopicName, name);
1123     NS_LOGD ("JNIProviderService: nativeRegisterTopic - OUT");
1124     return;
1125 }
1126 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeUnregisterTopic
1127 (JNIEnv *env, jobject jObj, jstring jTopicName)
1128 {
1129     NS_LOGD ("JNIProviderService: nativeUnregisterTopic - IN");
1130     if (!jTopicName)
1131     {
1132         ThrowNSException(JNI_INVALID_VALUE, "Topic Name Can't be NULL");
1133         return;
1134     }
1135     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1136     std::string topicName(name);
1137     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->unregisterTopic(
1138                                          topicName);
1139     if (result !=  OIC::Service::NSResult::OK)
1140     {
1141         ThrowNSException((int) result, "Fail to  Unregister Topic");
1142         return;
1143     }
1144     env->ReleaseStringUTFChars(jTopicName, name);
1145     NS_LOGD ("JNIProviderService: nativeUnregisterTopic - OUT");
1146     return;
1147 }
1148
1149 JNIEXPORT jobject JNICALL
1150 Java_org_iotivity_service_ns_provider_ProviderService_nativeGetRegisteredTopicList
1151 (JNIEnv *env, jobject jObj)
1152 {
1153     NS_LOGD ("JNIProviderService: nativeGetRegisteredTopicList - IN");
1154
1155     std::shared_ptr<OIC::Service::NSTopicsList> topicList  =
1156         OIC::Service::NSProviderService::getInstance()->getRegisteredTopicList();
1157     if (topicList == nullptr)
1158     {
1159         ThrowNSException(JNI_INVALID_VALUE, "Topic List doesn't exist");
1160         return NULL;
1161     }
1162
1163     jobject obj_topicList = getJavaTopicsList(env, topicList);
1164
1165     NS_LOGD ("JNIProviderService: nativeGetRegisteredTopicList - OUT");
1166     return obj_topicList;
1167 }
1168
1169 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription
1170 (JNIEnv *env,  jobject jObj, jstring jConsumerId, jboolean jAccepted)
1171 {
1172     NS_LOGD ("JNIProviderService: nativeAcceptSubscription - IN");
1173     if (!jConsumerId)
1174     {
1175         ThrowNSException(JNI_INVALID_VALUE, "ConsumerId Can't be NULL");
1176         return;
1177     }
1178     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1179     std::string consumerId(id);
1180     NS_LOGD ("Consumer ID: %s\n", consumerId.c_str());
1181
1182     std::shared_ptr<OIC::Service::NSConsumer> consumer =
1183         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1184     if (consumer)
1185     {
1186         OIC::Service::NSResult result = OIC::Service::NSResult::ERROR;
1187         try
1188         {
1189             result = consumer->acceptSubscription((bool)jAccepted);
1190         }
1191         catch (OIC::Service::NSException ex)
1192         {
1193             ThrowNSException(NATIVE_EXCEPTION, ex.what());
1194             return;
1195         }
1196         if (result !=  OIC::Service::NSResult::OK)
1197         {
1198             ThrowNSException((int) result, "Fail to  acceptSubscription");
1199             return;
1200         }
1201     }
1202     else
1203     {
1204         NS_LOGE ("Couldn't find consumer");
1205         ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native consumer");
1206     }
1207     return;
1208 }
1209 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeSetConsumerTopic
1210 (JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
1211 {
1212     NS_LOGD ("JNIProviderService: nativeSetConsumerTopic - IN");
1213     if (!jConsumerId || !jTopicName)
1214     {
1215         ThrowNSException(JNI_INVALID_VALUE, "Topic Name or ConsumerId Can't be NULL");
1216         return;
1217     }
1218     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1219     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1220     std::string topicName(name);
1221     std::string consumerId(id);
1222     std::shared_ptr<OIC::Service::NSConsumer> nsConsumer =
1223         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1224     if (!nsConsumer)
1225     {
1226         ThrowNSException(JNI_NO_NATIVE_POINTER, "Consumer does exists");
1227         return;
1228     }
1229     OIC::Service::NSResult result = OIC::Service::NSResult::ERROR;
1230     try
1231     {
1232         result  = nsConsumer->setTopic(topicName);
1233     }
1234     catch (OIC::Service::NSException ex)
1235     {
1236         ThrowNSException(NATIVE_EXCEPTION, ex.what());
1237         return;
1238     }
1239
1240     if (result !=  OIC::Service::NSResult::OK)
1241     {
1242         ThrowNSException((int) result, "Fail to  Select Topic");
1243         return;
1244     }
1245     env->ReleaseStringUTFChars(jTopicName, name);
1246     env->ReleaseStringUTFChars(jConsumerId, id);
1247     NS_LOGD ("JNIProviderService: nativeSetConsumerTopic - OUT");
1248     return;
1249 }
1250 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeUnsetConsumerTopic
1251 (JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
1252 {
1253     NS_LOGD ("JNIProviderService: nativeUnsetConsumerTopic - IN");
1254     if (!jConsumerId || !jTopicName)
1255     {
1256         ThrowNSException(JNI_INVALID_VALUE, "Topic Name or ConsumerId Can't be NULL");
1257         return;
1258     }
1259     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1260     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1261     std::string topicName(name);
1262     std::string consumerId(id);
1263     std::shared_ptr<OIC::Service::NSConsumer> nsConsumer =
1264         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1265     if (!nsConsumer)
1266     {
1267         ThrowNSException(JNI_NO_NATIVE_POINTER, "Consumer does exists");
1268         return;
1269     }
1270     OIC::Service::NSResult result = OIC::Service::NSResult::ERROR;
1271     try
1272     {
1273         result  = nsConsumer->unsetTopic(topicName);
1274     }
1275     catch (OIC::Service::NSException ex)
1276     {
1277         ThrowNSException(NATIVE_EXCEPTION, ex.what());
1278         return;
1279     }
1280
1281     if (result !=  OIC::Service::NSResult::OK)
1282     {
1283         ThrowNSException((int) result, "Fail to  Unselect Topic");
1284         return;
1285     }
1286     env->ReleaseStringUTFChars(jTopicName, name);
1287     env->ReleaseStringUTFChars(jConsumerId, id);
1288     NS_LOGD ("JNIProviderService: nativeUnsetConsumerTopic - OUT");
1289     return;
1290 }
1291
1292 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeGetConsumerTopicList
1293 (JNIEnv *env, jobject jObj, jstring jConsumerId)
1294 {
1295     NS_LOGD ("JNIProviderService: nativeGetConsumerTopicList - IN");
1296     if (!jConsumerId)
1297     {
1298         ThrowNSException(JNI_INVALID_VALUE, "Topic Name or ConsumerId Can't be NULL");
1299         return NULL;
1300     }
1301     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1302     std::string consumerId(id);
1303     std::shared_ptr<OIC::Service::NSConsumer> nsConsumer =
1304         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1305     if (!nsConsumer)
1306     {
1307         ThrowNSException(JNI_NO_NATIVE_POINTER, "Consumer does exists");
1308         return NULL;
1309     }
1310     env->ReleaseStringUTFChars(jConsumerId, id);
1311     std::shared_ptr<OIC::Service::NSTopicsList> topicList = nullptr;
1312     try
1313     {
1314         topicList  = nsConsumer->getConsumerTopicList();
1315     }
1316     catch (OIC::Service::NSException ex)
1317     {
1318         ThrowNSException(NATIVE_EXCEPTION, ex.what());
1319         return NULL;
1320     }
1321     if (topicList == nullptr)
1322     {
1323         ThrowNSException(JNI_NO_NATIVE_POINTER, "Topic List doesn't exist");
1324         return NULL;
1325     }
1326     jobject obj_topicList = getJavaTopicsList(env, topicList);
1327
1328     NS_LOGD ("JNIProviderService: nativeGetConsumerTopicList - OUT");
1329     return obj_topicList;
1330 }
1331
1332 // JNI OnLoad
1333 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
1334 {
1335     NS_LOGD ("ProviderService_JNI_OnLoad");
1336     g_jvm_provider = jvm;
1337
1338     JNIEnv *env = NULL;
1339     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
1340     {
1341         NS_LOGE ("Failed to get the environment using GetEnv()");
1342         return JNI_ERR;
1343     }
1344
1345     jclass localMessage = env->FindClass(
1346                               "org/iotivity/service/ns/common/Message");
1347     if (!localMessage)
1348     {
1349         NS_LOGE ("Failed to get local Message class");
1350         return JNI_ERR;
1351     }
1352     g_cls_Message = (jclass) (env->NewGlobalRef(localMessage));
1353     if (!g_cls_Message)
1354     {
1355         NS_LOGE ("Failed to set Global Message reference");
1356         return JNI_ERR;
1357     }
1358
1359     jclass localMessageType = env->FindClass(
1360                                   "org/iotivity/service/ns/common/Message$MessageType");
1361     if (!localMessageType)
1362     {
1363         NS_LOGE ("Failed to get local Message Type class");
1364         return JNI_ERR;
1365     }
1366     g_cls_Message_Type = (jclass) (env->NewGlobalRef(localMessageType));
1367     if (!g_cls_Message_Type)
1368     {
1369         NS_LOGE ("Failed to set Global Message Type reference");
1370         return JNI_ERR;
1371     }
1372
1373     jclass localConsumer = env->FindClass(
1374                                "org/iotivity/service/ns/provider/Consumer");
1375     if (!localConsumer)
1376     {
1377         NS_LOGE ("Failed to get local Provider class");
1378         return JNI_ERR;
1379     }
1380     g_cls_Consumer = (jclass) (env->NewGlobalRef(localConsumer));
1381     if (!g_cls_Consumer)
1382     {
1383         NS_LOGE ("Failed to set Global Provider reference");
1384         return JNI_ERR;
1385     }
1386
1387     jclass localSyncInfo = env->FindClass(
1388                                "org/iotivity/service/ns/common/SyncInfo");
1389     if (!localSyncInfo)
1390     {
1391         NS_LOGE ("Failed to get local SyncInfo class");
1392         return JNI_ERR;
1393     }
1394     g_cls_SyncInfo = (jclass) (env->NewGlobalRef(localSyncInfo));
1395     if (!g_cls_SyncInfo)
1396     {
1397         NS_LOGE ("Failed to set Global SyncInfo reference");
1398         return JNI_ERR;
1399     }
1400
1401     jclass localSyncType = env->FindClass(
1402                                "org/iotivity/service/ns/common/SyncInfo$SyncType");
1403     if (!localSyncType)
1404     {
1405         NS_LOGE ("Failed to get local SyncType enum");
1406         return JNI_ERR;
1407     }
1408     g_cls_SyncType = (jclass) (env->NewGlobalRef(localSyncType));
1409     if (!g_cls_SyncType)
1410     {
1411         NS_LOGE ("Failed to set Global SyncType reference");
1412         return JNI_ERR;
1413     }
1414
1415     jclass localMediaContents = env->FindClass(
1416                                     "org/iotivity/service/ns/common/MediaContents");
1417     if (!localMediaContents)
1418     {
1419         NS_LOGE ("Failed to get local MediaContents class");
1420         return JNI_ERR;
1421     }
1422     g_cls_MediaContents = (jclass) (env->NewGlobalRef(localMediaContents));
1423     if (!g_cls_MediaContents)
1424     {
1425         NS_LOGE ("Failed to set Global MediaContents reference");
1426         return JNI_ERR;
1427     }
1428
1429     jclass localTopic = env->FindClass(
1430                             "org/iotivity/service/ns/common/Topic");
1431     if (!localTopic)
1432     {
1433         NS_LOGE ("Failed to get local Topic class");
1434         return JNI_ERR;
1435     }
1436     g_cls_Topic = (jclass) (env->NewGlobalRef(localTopic));
1437     if (!g_cls_Topic)
1438     {
1439         NS_LOGE ("Failed to set Global Topic reference");
1440         return JNI_ERR;
1441     }
1442
1443     jclass localTopicsList = env->FindClass(
1444                                  "org/iotivity/service/ns/common/TopicsList");
1445     if (!localTopicsList)
1446     {
1447         NS_LOGE ("Failed to get local Topic class");
1448         return JNI_ERR;
1449     }
1450     g_cls_TopicsList = (jclass) (env->NewGlobalRef(localTopicsList));
1451     if (!g_cls_TopicsList)
1452     {
1453         NS_LOGE ("Failed to set Global TopicsList reference");
1454         return JNI_ERR;
1455     }
1456
1457     jclass localTopicState = env->FindClass(
1458                                  "org/iotivity/service/ns/common/Topic$TopicState");
1459     if (!localTopicState)
1460     {
1461         NS_LOGE ("Failed to get local TopicState enum");
1462         return JNI_ERR;
1463     }
1464     g_cls_TopicState = (jclass) (env->NewGlobalRef(localTopicState));
1465     if (!g_cls_TopicState)
1466     {
1467         NS_LOGE ("Failed to set Global TopicState reference");
1468         return JNI_ERR;
1469     }
1470
1471     //OcRepresentation
1472     jclass localOcRepresentation = env->FindClass("org/iotivity/base/OcRepresentation");
1473     if (!localOcRepresentation)
1474     {
1475         NS_LOGE ("Failed to get local OcRepresentation class");
1476         return JNI_ERR;
1477     }
1478     g_cls_OcRepresentation = (jclass) env->NewGlobalRef(localOcRepresentation);
1479     if (!g_cls_OcRepresentation)
1480     {
1481         NS_LOGE ("Failed to set Global OcRepresentation reference");
1482         return JNI_ERR;
1483     }
1484
1485     g_mid_OcRepresentation_N_ctor_bool = env->GetMethodID(g_cls_OcRepresentation, "<init>", "(JZ)V");
1486     if (!g_mid_OcRepresentation_N_ctor_bool)
1487     {
1488         NS_LOGE ("Failed to get Global OcRepresentation Constructor reference");
1489         return JNI_ERR;
1490     }
1491
1492     env->DeleteLocalRef(localMessage);
1493     env->DeleteLocalRef(localMessageType);
1494     env->DeleteLocalRef(localConsumer);
1495     env->DeleteLocalRef(localSyncInfo);
1496     env->DeleteLocalRef(localSyncType);
1497     env->DeleteLocalRef(localMediaContents);
1498     env->DeleteLocalRef(localTopic);
1499     env->DeleteLocalRef(localTopicsList);
1500     env->DeleteLocalRef(localTopicState);
1501     env->DeleteLocalRef(localOcRepresentation);
1502
1503     return NSExceptionInit(env);
1504 }
1505
1506 JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)
1507 {
1508     NS_LOGD ("ProviderService_JNI_OnUnload");
1509     JNIEnv *env = NULL;
1510
1511     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
1512     {
1513         NS_LOGE ("Failed to get the environment using GetEnv()");
1514         return ;
1515     }
1516
1517     env->DeleteGlobalRef(g_cls_Message);
1518     env->DeleteGlobalRef(g_cls_Consumer);
1519     env->DeleteGlobalRef(g_cls_SyncInfo);
1520     env->DeleteGlobalRef(g_cls_SyncType);
1521     env->DeleteGlobalRef(g_cls_MediaContents);
1522     env->DeleteGlobalRef(g_cls_Message_Type);
1523     env->DeleteGlobalRef(g_cls_Topic);
1524     env->DeleteGlobalRef(g_cls_TopicsList);
1525     env->DeleteGlobalRef(g_cls_TopicState);
1526     env->DeleteGlobalRef(g_cls_OcRepresentation);
1527 }