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

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