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                         "onSyncInfoReceived",
 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, jboolean jPolicy, jobject jSubscriptionListener, jobject jSyncListener)
 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.policy = (bool) jPolicy;
 766
 767     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->Start(cfg);
 768     if (result != OIC::Service::NSResult::OK)
 769     {
 770         LOGE("Fail to start NSProviderService");
 771
 772     }
 773
 774     LOGD("JNIProviderService: nativeStart - OUT");
 775     return (jint) result;
 776 }
 777
 778 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop
 779 (JNIEnv *env, jobject jObj)
 780 {
 781     LOGD("JNIProviderService: nativeStop - IN");
 782
 783     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->Stop();
 784     if (result !=  OIC::Service::NSResult::OK)
 785     {
 786         LOGD("Fail to stop NSProvider service");
 787         return (jint) result;
 788     }
 789
 790     env->DeleteGlobalRef( g_obj_subscriptionListener);
 791     env->DeleteGlobalRef( g_obj_syncListener);
 792     g_obj_subscriptionListener = NULL;
 793     g_obj_syncListener = NULL;
 794
 795     LOGD("JNIProviderService: nativeStop - OUT");
 796     return (jint) result;
 797 }
 798
 799 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage
 800 (JNIEnv *env, jobject jObj, jobject jMsg)
 801 {
 802     LOGD("JNIProviderService: nativeSendMessage - IN");
 803     if (!jMsg)
 804     {
 805         LOGD("Fail to send notification - Message is null");
 806         ThrowNSException(NS_ERROR, "Message cannot be null");
 807         return (jint) OIC::Service::NSResult::ERROR;
 808     }
 809     OIC::Service::NSMessage *nsMsg = getNativeMessage(env, jMsg);
 810     if (nsMsg == nullptr)
 811     {
 812         ThrowNSException(NS_ERROR, "Message didn't have a field ID ");
 813         return (jint) OIC::Service::NSResult::ERROR;
 814     }
 815
 816     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->SendMessage(nsMsg);
 817     if (result !=  OIC::Service::NSResult::OK)
 818     {
 819         LOGD("Fail to send NSProvider Message");
 820     }
 821     LOGD("JNIProviderService: nativeSendMessage - OUT");
 822     return (jint) result;
 823 }
 824
 825 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendSyncInfo
 826 (JNIEnv *env, jobject jObj, jlong messageId , jint syncState)
 827 {
 828     LOGD("JNIProviderService: nativeSendSyncInfo - IN");
 829     OIC::Service::NSProviderService::getInstance()->SendSyncInfo( messageId,
 830             (OIC::Service::NSSyncInfo::NSSyncType) syncState);
 831     LOGD("JNIProviderService: nativeSendSyncInfo - OUT");
 832     return;
 833 }
 834
 835 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeCreateMessage
 836 (JNIEnv *env, jobject jObj)
 837 {
 838     LOGD("JNIProviderService: nativeCreateMessage - IN");
 839     OIC::Service::NSMessage* message =
 840                       OIC::Service::NSProviderService::getInstance()->CreateMessage();
 841     if(message == nullptr)
 842     {
 843         ThrowNSException(NS_ERROR, "Couldn't get Native Message");
 844         return NULL;
 845     }
 846     jobject jMsg =  getJavaMessage(env, message);
 847     if(!jMsg)
 848     {
 849         ThrowNSException(NS_ERROR, "Couldn't create Java Message");
 850         return NULL;
 851     }
 852     LOGD("JNIProviderService: nativeCreateMessage - OUT");
 853     return jMsg;
 854 }
 855
 856 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeEnableRemoteService
 857 (JNIEnv *env,jobject jObj, jstring jstr)
 858 {
 859     LOGD("JNIProviderService: nativeEnableRemoteService - IN");
 860     if (!jstr)
 861     {
 862         ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
 863         return (jint) OIC::Service::NSResult::ERROR;
 864     }
 865
 866     const char *address = env->GetStringUTFChars( jstr, NULL);
 867     std::string servAddress(address);
 868     OIC::Service::NSResult result  =
 869         OIC::Service::NSProviderService::getInstance()->EnableRemoteService(
 870             servAddress);
 871     if (result !=  OIC::Service::NSResult::OK)
 872     {
 873         LOGE("Fail to Enable Remote Service");
 874     }
 875     env->ReleaseStringUTFChars(jstr, address);
 876     LOGD("JNIProviderService: nativeEnableRemoteService - OUT");
 877     return (jint) result;
 878 }
 879
 880 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeDisableRemoteService
 881 (JNIEnv *env,jobject jObj, jstring jstr)
 882 {
 883     LOGD("JNIProviderService: nativeDisableRemoteService - IN");
 884     if (!jstr)
 885     {
 886         ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
 887         return (jint) OIC::Service::NSResult::ERROR;
 888     }
 889
 890     const char *address = env->GetStringUTFChars( jstr, NULL);
 891     std::string servAddress(address);
 892     OIC::Service::NSResult result  =
 893         OIC::Service::NSProviderService::getInstance()->DisableRemoteService(
 894             servAddress);
 895     if (result !=  OIC::Service::NSResult::OK)
 896     {
 897         LOGE("Fail to Disable Remote Service");
 898     }
 899     env->ReleaseStringUTFChars(jstr, address);
 900     LOGD("JNIProviderService: nativeDisableRemoteService - OUT");
 901     return (jint) result;
 902 }
 903
 904 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeAddTopic
 905 (JNIEnv *env, jobject jObj, jstring jTopicName)
 906 {
 907     LOGD("JNIProviderService: nativeAddTopic - IN");
 908     if (!jTopicName)
 909     {
 910         ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
 911         return (jint) OIC::Service::NSResult::ERROR;
 912     }
 913     const char *name = env->GetStringUTFChars( jTopicName, NULL);
 914     std::string topicName(name);
 915     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->AddTopic(
 916                                          topicName);
 917     if (result !=  OIC::Service::NSResult::OK)
 918     {
 919         LOGE("Fail to Add Topic");
 920     }
 921     env->ReleaseStringUTFChars(jTopicName, name);
 922     LOGD("JNIProviderService: nativeAddTopic - OUT");
 923     return (jint) result;
 924 }
 925 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeDeleteTopic
 926 (JNIEnv *env, jobject jObj, jstring jTopicName)
 927 {
 928     LOGD("JNIProviderService: nativeDeleteTopic - IN");
 929     if (!jTopicName)
 930     {
 931         ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
 932         return (jint) OIC::Service::NSResult::ERROR;
 933     }
 934     const char *name = env->GetStringUTFChars( jTopicName, NULL);
 935     std::string topicName(name);
 936     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->DeleteTopic(
 937                                          topicName);
 938     if (result !=  OIC::Service::NSResult::OK)
 939     {
 940         LOGE("Fail to Add Topic");
 941     }
 942     env->ReleaseStringUTFChars(jTopicName, name);
 943     LOGD("JNIProviderService: nativeDeleteTopic - OUT");
 944     return (jint) result;
 945 }
 946
 947 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeGetTopics
 948 (JNIEnv *env, jobject jObj)
 949 {
 950     LOGD("JNIProviderService: nativeGetTopics - IN");
 951
 952     OIC::Service::NSTopicsList *topicList  =
 953         OIC::Service::NSProviderService::getInstance()->GetTopics();
 954     if (topicList == nullptr)
 955     {
 956         ThrowNSException(NS_ERROR, "Topic List doesn't exist");
 957         return NULL;
 958     }
 959
 960     jobject obj_topicList = getJavaTopicsList(env, topicList);
 961
 962     LOGD("JNIProviderService: nativeGetTopics - OUT");
 963     return obj_topicList;
 964 }
 965
 966 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription
 967 (JNIEnv *env,  jobject jObj, jobject jConsumer, jboolean jAccepted)
 968 {
 969     LOGD("JNIProviderService: nativeAcceptSubscription - IN");
 970
 971     jclass consumerClass =  env->GetObjectClass( jConsumer);
 972     if (!consumerClass)
 973     {
 974         ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Consumer");
 975         return (jint) OIC::Service::NSResult::ERROR;
 976     }
 977
 978     // Consumer ID
 979     jfieldID fid_id =  env->GetFieldID(consumerClass, "mConsumerId",  "Ljava/lang/String;");
 980     if (fid_id == NULL)
 981     {
 982         LOGE("Error: jfieldID for mConsumerId  is null");
 983         ThrowNSException(NS_ERROR, "ConsumerId not found");
 984         return (jint) OIC::Service::NSResult::ERROR;
 985     }
 986
 987     jstring jconId = (jstring)env->GetObjectField( jConsumer, fid_id);
 988     if (!jconId)
 989     {
 990         ThrowNSException(NS_ERROR, "ProviderId cannot be null");
 991         return (jint) OIC::Service::NSResult::ERROR;
 992     }
 993     const char *conId = env->GetStringUTFChars( jconId, NULL);
 994     std::string consumerId(conId);
 995     env->ReleaseStringUTFChars(jconId, conId);
 996
 997     LOGD("Consumer ID: %s\n", consumerId.c_str());
 998
 999     OIC::Service::NSConsumer *consumer =
1000         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1001     if (consumer)
1002         return (jint) consumer->acceptSubscription(consumer,  (bool)jAccepted);
1003
1004     LOGE("Couldn't find consumer");
1005     LOGD("JNIProviderService: nativeAcceptSubscription - OUT");
1006     return (jint) OIC::Service::NSResult::ERROR;
1007 }
1008 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeSelectTopic
1009 (JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
1010 {
1011     LOGD("JNIProviderService: nativeSelectTopic - IN");
1012     if (!jConsumerId || !jTopicName)
1013     {
1014         ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
1015         return (jint) OIC::Service::NSResult::ERROR;
1016     }
1017     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1018     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1019     std::string topicName(name);
1020     std::string consumerId(id);
1021     OIC::Service::NSConsumer *nsConsumer =
1022         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1023     if (!nsConsumer)
1024     {
1025         ThrowNSException(NS_ERROR, "Consumer does exists");
1026         return (jint) OIC::Service::NSResult::ERROR;
1027     }
1028     OIC::Service::NSResult result  = nsConsumer->selectTopic(topicName);
1029
1030     if (result !=  OIC::Service::NSResult::OK)
1031     {
1032         LOGD("Fail to Select Topic");
1033     }
1034     env->ReleaseStringUTFChars(jTopicName, name);
1035     env->ReleaseStringUTFChars(jConsumerId, id);
1036     LOGD("JNIProviderService: nativeSelectTopic - OUT");
1037     return (jint) result;
1038 }
1039 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeUnselectTopic
1040 (JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
1041 {
1042     LOGD("JNIProviderService: nativeUnselectTopic - IN");
1043     if (!jConsumerId || !jTopicName)
1044     {
1045         ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
1046         return (jint) OIC::Service::NSResult::ERROR;
1047     }
1048     const char *name = env->GetStringUTFChars( jTopicName, NULL);
1049     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1050     std::string topicName(name);
1051     std::string consumerId(id);
1052     OIC::Service::NSConsumer *nsConsumer =
1053         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1054     if (!nsConsumer)
1055     {
1056         ThrowNSException(NS_ERROR, "Consumer does exists");
1057         return (jint) OIC::Service::NSResult::ERROR;
1058     }
1059     OIC::Service::NSResult result  = nsConsumer->unselectTopic(topicName);
1060
1061     if (result !=  OIC::Service::NSResult::OK)
1062     {
1063         LOGE("Fail to Unselect Topic");
1064     }
1065     env->ReleaseStringUTFChars(jTopicName, name);
1066     env->ReleaseStringUTFChars(jConsumerId, id);
1067     LOGD("JNIProviderService: nativeUnselectTopic - OUT");
1068     return (jint) result;
1069 }
1070
1071 JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeGetConsumerTopics
1072 (JNIEnv *env, jobject jObj, jstring jConsumerId)
1073 {
1074     LOGD("JNIProviderService: nativeGetConsumerTopics - IN");
1075     if (!jConsumerId)
1076     {
1077         ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
1078         return NULL;
1079     }
1080     const char *id = env->GetStringUTFChars( jConsumerId, NULL);
1081     std::string consumerId(id);
1082     OIC::Service::NSConsumer *nsConsumer =
1083         OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
1084     if (!nsConsumer)
1085     {
1086         ThrowNSException(NS_ERROR, "Consumer does exists");
1087         return NULL;
1088     }
1089     env->ReleaseStringUTFChars(jConsumerId, id);
1090     OIC::Service::NSTopicsList *topicList  = nsConsumer->getConsumerTopics();
1091     if (topicList == nullptr)
1092     {
1093         ThrowNSException(NS_ERROR, "Topic List doesn't exist");
1094         return NULL;
1095     }
1096     jobject obj_topicList = getJavaTopicsList(env, topicList);
1097     LOGD("JNIProviderService: nativeGetConsumerTopics - OUT");
1098     return obj_topicList;
1099 }
1100
1101 // JNI OnLoad
1102 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
1103 {
1104     LOGD("ProviderService_JNI_OnLoad");
1105     g_jvm = jvm;
1106
1107     JNIEnv *env;
1108     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
1109     {
1110         LOGE("Failed to get the environment using GetEnv()");
1111         return JNI_ERR;
1112     }
1113
1114     jclass localMessage = env->FindClass(
1115                               "org/iotivity/service/ns/common/Message");
1116     if (!localMessage)
1117     {
1118         LOGE("Failed to get local Message class");
1119         return JNI_ERR;
1120     }
1121     g_cls_Message = (jclass) (env->NewGlobalRef(localMessage));
1122     if (!g_cls_Message)
1123     {
1124         LOGE("Failed to set Global Message reference");
1125         return JNI_ERR;
1126     }
1127
1128     jclass localMessageType = env->FindClass(
1129                                   "org/iotivity/service/ns/common/Message$MessageType");
1130     if (!localMessageType)
1131     {
1132         LOGE("Failed to get local Message Type class");
1133         return JNI_ERR;
1134     }
1135     g_cls_Message_Type = (jclass) (env->NewGlobalRef(localMessageType));
1136     if (!g_cls_Message_Type)
1137     {
1138         LOGE("Failed to set Global Message Type reference");
1139         return JNI_ERR;
1140     }
1141
1142     jclass localConsumer = env->FindClass(
1143                                "org/iotivity/service/ns/provider/Consumer");
1144     if (!localConsumer)
1145     {
1146         LOGE("Failed to get local Provider class");
1147         return JNI_ERR;
1148     }
1149     g_cls_Consumer = (jclass) (env->NewGlobalRef(localConsumer));
1150     if (!g_cls_Consumer)
1151     {
1152         LOGE("Failed to set Global Provider reference");
1153         return JNI_ERR;
1154     }
1155
1156     jclass localSyncInfo = env->FindClass(
1157                                "org/iotivity/service/ns/common/SyncInfo");
1158     if (!localSyncInfo)
1159     {
1160         LOGE("Failed to get local SyncInfo class");
1161         return JNI_ERR;
1162     }
1163     g_cls_SyncInfo = (jclass) (env->NewGlobalRef(localSyncInfo));
1164     if (!g_cls_SyncInfo)
1165     {
1166         LOGE("Failed to set Global SyncInfo reference");
1167         return JNI_ERR;
1168     }
1169
1170     jclass localSyncType = env->FindClass(
1171                                "org/iotivity/service/ns/common/SyncInfo$SyncType");
1172     if (!localSyncType)
1173     {
1174         LOGE("Failed to get local SyncType enum");
1175         return JNI_ERR;
1176     }
1177     g_cls_SyncType = (jclass) (env->NewGlobalRef(localSyncType));
1178     if (!g_cls_SyncType)
1179     {
1180         LOGE("Failed to set Global SyncType reference");
1181         return JNI_ERR;
1182     }
1183
1184     jclass localMediaContents = env->FindClass(
1185                                     "org/iotivity/service/ns/common/MediaContents");
1186     if (!localMediaContents)
1187     {
1188         LOGE("Failed to get local MediaContents class");
1189         return JNI_ERR;
1190     }
1191     g_cls_MediaContents = (jclass) (env->NewGlobalRef(localMediaContents));
1192     if (!g_cls_MediaContents)
1193     {
1194         LOGE("Failed to set Global MediaContents reference");
1195         return JNI_ERR;
1196     }
1197
1198     jclass localTopic = env->FindClass(
1199                             "org/iotivity/service/ns/common/Topic");
1200     if (!localTopic)
1201     {
1202         LOGE("Failed to get local Topic class");
1203         return JNI_ERR;
1204     }
1205     g_cls_Topic = (jclass) (env->NewGlobalRef(localTopic));
1206     if (!g_cls_Topic)
1207     {
1208         LOGE("Failed to set Global Topic reference");
1209         return JNI_ERR;
1210     }
1211
1212     jclass localTopicsList = env->FindClass(
1213                                  "org/iotivity/service/ns/common/TopicsList");
1214     if (!localTopicsList)
1215     {
1216         LOGE("Failed to get local Topic class");
1217         return JNI_ERR;
1218     }
1219     g_cls_TopicsList = (jclass) (env->NewGlobalRef(localTopicsList));
1220     if (!g_cls_TopicsList)
1221     {
1222         LOGE("Failed to set Global TopicsList reference");
1223         return JNI_ERR;
1224     }
1225
1226     jclass localTopicState = env->FindClass(
1227                                  "org/iotivity/service/ns/common/Topic$TopicState");
1228     if (!localTopicState)
1229     {
1230         LOGE("Failed to get local TopicState enum");
1231         return JNI_ERR;
1232     }
1233     g_cls_TopicState = (jclass) (env->NewGlobalRef(localTopicState));
1234     if (!g_cls_TopicState)
1235     {
1236         LOGE("Failed to set Global TopicState reference");
1237         return JNI_ERR;
1238     }
1239
1240     env->DeleteLocalRef(localMessage);
1241     env->DeleteLocalRef(localMessageType);
1242     env->DeleteLocalRef(localConsumer);
1243     env->DeleteLocalRef(localSyncInfo);
1244     env->DeleteLocalRef(localSyncType);
1245     env->DeleteLocalRef(localMediaContents);
1246     env->DeleteLocalRef(localTopic);
1247     env->DeleteLocalRef(localTopicsList);
1248     env->DeleteLocalRef(localTopicState);
1249
1250     return NSExceptionInit(env);
1251 }
1252
1253 JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)
1254 {
1255     LOGD("ProviderService_JNI_OnUnload");
1256     JNIEnv *env;
1257
1258     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
1259     {
1260         LOGE("Failed to get the environment using GetEnv()");
1261         return ;
1262     }
1263
1264     env->DeleteGlobalRef(g_cls_Message);
1265     env->DeleteGlobalRef(g_cls_Consumer);
1266     env->DeleteGlobalRef(g_cls_SyncInfo);
1267     env->DeleteGlobalRef(g_cls_SyncType);
1268     env->DeleteGlobalRef(g_cls_MediaContents);
1269     env->DeleteGlobalRef(g_cls_Message_Type);
1270     env->DeleteGlobalRef(g_cls_Topic);
1271     env->DeleteGlobalRef(g_cls_TopicsList);
1272     env->DeleteGlobalRef(g_cls_TopicState);
1273 }