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

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