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