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
  36 static JNIEnv *GetJNIEnv(jint *ret)
  37 {
  38     JNIEnv *env = NULL;
  39
  40     *ret = g_jvm->GetEnv((void **) &env, JNI_CURRENT_VERSION);
  41     switch (*ret)
  42     {
  43         case JNI_OK:
  44             return env;
  45         case JNI_EDETACHED:
  46             if (g_jvm->AttachCurrentThread(&env, NULL) != JNI_OK)
  47             {
  48                 LOGE ("Failed to get the environment");
  49                 return NULL;
  50             }
  51             else
  52             {
  53                 return env;
  54             }
  55         case JNI_EVERSION:
  56             LOGE ("JNI version is not supported");
  57         default:
  58             LOGE ("Failed to get the environment");
  59             return NULL;
  60     }
  61 }
  62
  63 void onSubscribeListenerCb(OIC::Service::NSConsumer *consumer)
  64 {
  65     LOGI("JNIProviderService_onSubscribeListenerCb - IN");
  66
  67     jint envRet;
  68     JNIEnv *env = GetJNIEnv(&envRet);
  69     if (NULL == env) return ;
  70
  71     jobject jSubscriptionListener = (jobject) env->NewLocalRef(g_obj_subscriptionListener);
  72     if (!jSubscriptionListener)
  73     {
  74         LOGE ("Failed to Get jSubscriptionListener");
  75         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
  76         return ;
  77     }
  78
  79     LOGI("consumer ID : %s\n", consumer->getConsumerId().c_str());
  80
  81     jstring jConsumerId = env->NewStringUTF( consumer->getConsumerId().c_str());
  82
  83     jclass cls_consumer = (jclass) (env->NewLocalRef(g_cls_Consumer));
  84     if (!cls_consumer)
  85     {
  86         LOGE ("Failed to Get ObjectClass for Consumer");
  87         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
  88         return ;
  89     }
  90
  91     jmethodID mid_consumer = env->GetMethodID(
  92                                  cls_consumer,
  93                                  "<init>",
  94                                  "(JLjava/lang/String;Lorg/iotivity/service/ns/provider/Consumer)V");
  95     if (!mid_consumer)
  96     {
  97         LOGE ("Failed to Get MethodID for Consumer<init>");
  98         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
  99         return ;
 100     }
 101     jobject obj_consumer = env->NewObject( cls_consumer, mid_consumer, jConsumerId);
 102
 103     jclass cls = env->GetObjectClass( jSubscriptionListener);
 104     if (!cls)
 105     {
 106         LOGE("Failed to Get ObjectClass of jSubscriptionListener");
 107         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 108         return;
 109     }
 110     jmethodID mid = env->GetMethodID(
 111                         cls,
 112                         "onConsumerSubscribed",
 113                         "(Lorg/iotivity/service/ns/provider/Consumer;)V");
 114     if (!mid)
 115     {
 116         LOGE("Failed to Get MethodID of onConsumerSubscribed");
 117         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 118         return;
 119     }
 120
 121     env->CallVoidMethod( jSubscriptionListener, mid, obj_consumer);
 122     env->DeleteLocalRef(jSubscriptionListener);
 123     env->DeleteLocalRef(cls_consumer);
 124     if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 125     LOGI("JNIProviderService_onSubscribeListenerCb - OUT");
 126     return;
 127 }
 128
 129 void onSyncInfoListenerCb(OIC::Service::NSSyncInfo *sync)
 130 {
 131     LOGI("JNIProviderService_onSyncInfoListenerCb - IN");
 132
 133     jint envRet;
 134     JNIEnv *env = GetJNIEnv(&envRet);
 135     if (NULL == env) return ;
 136
 137     jobject jSyncListener = (jobject) env->NewLocalRef(g_obj_syncListener);
 138     if (!jSyncListener)
 139     {
 140         LOGE ("Failed to Get jSyncListener");
 141         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 142         return ;
 143     }
 144
 145     LOGI("Sync ID : %ld\n", (long) sync->getMessageId());
 146     LOGI("Sync STATE : %d\n", (int) sync->getState());
 147
 148     jlong jMessageId = (long)  sync->getMessageId();
 149     jstring jProviderId = env->NewStringUTF(sync->getProviderId().c_str());
 150     jobject syncType;
 151
 152     jclass cls_SyncType = (jclass) (env->NewLocalRef(g_cls_SyncType));
 153     if (!cls_SyncType)
 154     {
 155         LOGE ("Failed to Get ObjectClass for SyncType");
 156         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 157         return ;
 158     }
 159     switch (sync->getState())
 160     {
 161         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_UNREAD:
 162             {
 163                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 164                                           "UNREAD", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 165                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
 166             }
 167         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ :
 168             {
 169                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 170                                           "READ", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 171                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
 172             }
 173         case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED :
 174             {
 175                 static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
 176                                           "DELETED", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
 177                 syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
 178             }
 179
 180     }
 181
 182     jclass cls_SyncInfo = (jclass) (env->NewLocalRef(g_cls_SyncInfo));
 183     if (!cls_SyncInfo)
 184     {
 185         LOGE ("Failed to Get ObjectClass for SyncInfo");
 186         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 187         return ;
 188     }
 189     jmethodID mid_syncInfo = env->GetMethodID(
 190                                  cls_SyncInfo,
 191                                  "<init>",
 192                                  "(JLjava/lang/String;Lorg/iotivity/service/ns/common/SyncInfo$SyncType)V");
 193     if (!mid_syncInfo)
 194     {
 195         LOGE ("Failed to Get MethodID for SyncInfo");
 196         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 197         return ;
 198     }
 199
 200     jobject obj_syncInfo = env->NewObject( cls_SyncInfo, mid_syncInfo, jMessageId, jProviderId,
 201                                            syncType);
 202
 203     jclass cls = env->GetObjectClass( jSyncListener);
 204     if (!cls)
 205     {
 206         LOGE("Failed to Get ObjectClass");
 207         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 208         return;
 209     }
 210     jmethodID mid = env->GetMethodID( cls, "onMessageSynchronized",
 211                                       "(Lorg/iotivity/service/ns/common/SyncInfo)V");
 212     if (!mid)
 213     {
 214         LOGE("Failed to Get MethodID");
 215         if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 216         return;
 217     }
 218     env->CallVoidMethod( jSyncListener, mid, obj_syncInfo);
 219
 220     env->DeleteLocalRef(jSyncListener);
 221     env->DeleteLocalRef(cls_SyncInfo);
 222     env->DeleteLocalRef(cls_SyncType);
 223     if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
 224
 225     LOGI("JNIProviderService: OnSyncInfoListenerCb - OUT");
 226     return;
 227
 228 }
 229
 230 OIC::Service::NSMessage *getMessage(JNIEnv *env, jobject jMsg)
 231 {
 232     LOGI("JNIProviderService: getMessage - IN");
 233
 234     jclass cls = env->GetObjectClass( jMsg);
 235
 236     // Message type
 237     jclass cls_messageType = (jclass) (env->NewLocalRef(g_cls_Message_Type));
 238     if (!cls_messageType)
 239     {
 240         LOGE ("Failed to Get ObjectClass for Message Type");
 241         return nullptr;
 242     }
 243     jmethodID mid = env->GetMethodID(cls_messageType, "ordinal", "()I");
 244     jfieldID fid_type = env->GetFieldID( cls, "mType",
 245                                          "Lorg/iotivity/service/ns/common/Message$MessageType;");
 246     if (fid_type == NULL)
 247     {
 248         LOGE("Error: jfieldID for message type  is null");
 249         return nullptr;
 250     }
 251     jobject jobj = env->GetObjectField( jMsg, fid_type);
 252     if (jobj == NULL)
 253     {
 254         LOGE("Error: object of field  Message Type is null");
 255         return nullptr;
 256     }
 257     jint jtype = env->CallIntMethod(jobj, mid);
 258     OIC::Service::NSMessage::NSMessageType  type = (OIC::Service::NSMessage::NSMessageType) jtype;
 259
 260     LOGI("Message Type: %ld\n", (long )type);
 261
 262     // Message Time
 263     jfieldID fid_tm = env->GetFieldID( cls, "mTime", "Ljava/lang/String;");
 264     if (fid_tm == NULL)
 265     {
 266         LOGE("Error: jfieldID for message time is null");
 267         return nullptr;
 268     }
 269     jstring jtime = (jstring)env->GetObjectField( jMsg, fid_tm);
 270     const char *time = "";
 271     if (jtime)
 272     {
 273         time = env->GetStringUTFChars( jtime, NULL);
 274     }
 275     else
 276     {
 277         LOGI("Info: messageTitle is null");
 278     }
 279     LOGI("Message Time: %s\n", time);
 280
 281     // Message TTL
 282     jfieldID fid_ttl = env->GetFieldID( cls, "mTTL", "J");
 283     if (fid_ttl == NULL)
 284     {
 285         LOGE("Error: jfieldID for message ttl is null");
 286         return nullptr;
 287     }
 288     jlong jttl = (jlong) env->GetObjectField( jMsg, fid_ttl);
 289     uint64_t  ttl = jttl;
 290
 291     LOGI("Message ID: %lld\n", ttl);
 292
 293     // Message Title
 294     jfieldID fid_title = env->GetFieldID( cls, "mTitle", "Ljava/lang/String;");
 295     if (fid_title == NULL)
 296     {
 297         LOGE("Error: jfieldID for message title is null");
 298         return nullptr;
 299     }
 300     jstring jmsgTitle = (jstring)env->GetObjectField( jMsg, fid_title);
 301     const char *messageTitle = "";
 302     if (jmsgTitle)
 303     {
 304         messageTitle = env->GetStringUTFChars( jmsgTitle, NULL);
 305     }
 306     else
 307     {
 308         LOGI("Info: messageTitle is null");
 309     }
 310     LOGI("Message Title: %s\n", messageTitle);
 311
 312     // Message Content Text
 313     jfieldID fid_body = env->GetFieldID( cls, "mContentText", "Ljava/lang/String;");
 314     if (fid_body == NULL)
 315     {
 316         LOGE("Error: jfieldID for message context Text is null");
 317         return nullptr;
 318     }
 319     jstring jmsgBody = (jstring)env->GetObjectField( jMsg, fid_body);
 320     const char *messageBody = "";
 321     if (jmsgBody)
 322     {
 323         messageBody = env->GetStringUTFChars( jmsgBody, NULL);
 324     }
 325     else
 326     {
 327         LOGI("Info: messageBody is null");
 328     }
 329     LOGI("Message Body: %s\n", messageBody);
 330
 331     // Message Source
 332     jfieldID fid_source = env->GetFieldID( cls, "mSourceName", "Ljava/lang/String;");
 333     if (fid_source == NULL)
 334     {
 335         LOGE("Error: jfieldID for message source is null");
 336         return nullptr;
 337     }
 338     jstring jmsgSource = (jstring)env->GetObjectField( jMsg, fid_source);
 339     const char *messageSource = "";
 340     if (jmsgSource)
 341     {
 342         messageSource = env->GetStringUTFChars( jmsgSource, NULL);
 343     }
 344     else
 345     {
 346         LOGI("Info: messageSource is null");
 347     }
 348     LOGI("Message Source: %s\n", messageSource);
 349
 350     // Message MediaContents
 351     jfieldID fid_media = env->GetFieldID( cls, "mMediaContents",
 352                                           "Lorg/iotivity/service/ns/common/MediaContents;");
 353     if (fid_media == NULL)
 354     {
 355         LOGE("Error: jfieldID for MediaContents is null");
 356         return nullptr;
 357     }
 358     jobject jmedia = env->GetObjectField( jMsg, fid_media);
 359     if (jmedia == NULL)
 360     {
 361         LOGE("Error: jmedia object of MediaContents inside Message is null");
 362         return nullptr;
 363     }
 364     jclass cls_MediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));
 365     if (!cls_MediaContents)
 366     {
 367         LOGE ("Failed to Get ObjectClass for class MediaContents");
 368         return nullptr;
 369     }
 370     jfieldID fid_icon = env->GetFieldID( cls_MediaContents, "mIconImage", "Ljava/lang/String;");
 371     if (fid_icon == NULL)
 372     {
 373         LOGE("Error: jfieldID for iconImage is null");
 374         return nullptr;
 375     }
 376     jstring jiconImage = (jstring)env->GetObjectField( jmedia, fid_icon);
 377     const char *iconImage = "";
 378     if (jiconImage)
 379     {
 380         iconImage = env->GetStringUTFChars( jiconImage, NULL);
 381     }
 382     else
 383     {
 384         LOGI("Info: iconImage is null");
 385     }
 386
 387     LOGI("iconImage: %s\n", iconImage);
 388
 389     OIC::Service::NSMediaContents *media = new OIC::Service::NSMediaContents(std::string(iconImage));
 390     OIC::Service::NSMessage *nsMsg = OIC::Service::NSProviderService::getInstance()->CreateMessage();
 391
 392     nsMsg->setType(type);
 393     nsMsg->setTime(std::string(time));
 394     nsMsg->setTTL(ttl);
 395     nsMsg->setTitle(std::string(messageTitle));
 396     nsMsg->setContentText(std::string(messageBody));
 397     nsMsg->setSourceName(std::string(messageSource));
 398     nsMsg->setMediaContents(media);
 399
 400     env->DeleteLocalRef(cls_messageType);
 401     env->DeleteLocalRef(cls_MediaContents);
 402
 403      if (jtime)
 404     {
 405         env->ReleaseStringUTFChars(jtime, time);
 406     }
 407      if (jmsgTitle)
 408     {
 409         env->ReleaseStringUTFChars(jmsgTitle, messageTitle);
 410     }
 411      if (jmsgBody)
 412     {
 413         env->ReleaseStringUTFChars(jmsgBody, messageBody);
 414     }
 415      if (jmsgSource)
 416     {
 417         env->ReleaseStringUTFChars(jmsgSource, messageSource);
 418     }
 419     if (jiconImage)
 420     {
 421         env->ReleaseStringUTFChars(jiconImage, iconImage);
 422     }
 423
 424     LOGI("JNIProviderService: getMessage - OUT");
 425     return nsMsg;
 426
 427 }
 428
 429 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStart(
 430     JNIEnv *env, jobject jObj, jboolean jPolicy, jobject jSubscriptionListener,
 431     jobject jSyncListener)
 432 {
 433     LOGI("JNIProviderService: nativeStart - IN");
 434     if (!jSubscriptionListener || !jSyncListener)
 435     {
 436         LOGE("Fail to set listeners");
 437         ThrowNSException(NS_ERROR, "Listener cannot be null");
 438         return (jint) OIC::Service::NSResult::ERROR;
 439     }
 440
 441     if (g_obj_subscriptionListener != NULL)
 442     {
 443         env->DeleteGlobalRef(g_obj_subscriptionListener);
 444     }
 445     if (g_obj_syncListener != NULL)
 446     {
 447         env->DeleteGlobalRef(g_obj_syncListener);
 448     }
 449
 450     g_obj_subscriptionListener = (jobject)  env->NewGlobalRef(jSubscriptionListener);
 451     g_obj_syncListener = (jobject)  env->NewGlobalRef(jSyncListener);
 452
 453     // check access policy
 454
 455     OIC::Service::NSProviderService::ProviderConfig cfg;
 456     cfg.m_subscribeRequestCb =  onSubscribeListenerCb;
 457     cfg.m_syncInfoCb =  onSyncInfoListenerCb;
 458     cfg.policy = (bool) jPolicy;
 459
 460     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->Start(cfg);
 461     if (result != OIC::Service::NSResult::OK)
 462     {
 463         LOGE("Fail to start NSProviderService");
 464
 465     }
 466
 467     LOGI("JNIProviderService: nativeStart - OUT");
 468     return (jint) result;
 469 }
 470
 471 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop(
 472     JNIEnv *env, jobject jObj)
 473 {
 474     LOGI("JNIProviderService: nativeStop - IN");
 475
 476     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->Stop();
 477     if (result !=  OIC::Service::NSResult::OK)
 478     {
 479         LOGI("Fail to stop NSProvider service");
 480         return (jint) result;
 481     }
 482
 483     env->DeleteGlobalRef( g_obj_subscriptionListener);
 484     env->DeleteGlobalRef( g_obj_syncListener);
 485     g_obj_subscriptionListener = NULL;
 486     g_obj_syncListener = NULL;
 487
 488     LOGI("JNIProviderService: nativeStop - OUT");
 489     return (jint) result;
 490 }
 491
 492 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage(
 493     JNIEnv *env, jobject jObj, jobject jMsg)
 494 {
 495     LOGI("JNIProviderService: nativeSendMessage - IN");
 496     if (!jMsg)
 497     {
 498         LOGI("Fail to send notification - Message is null");
 499         ThrowNSException(NS_ERROR, "Message cannot be null");
 500         return (jint) OIC::Service::NSResult::ERROR;
 501     }
 502     OIC::Service::NSMessage *nsMsg = getMessage(env, jMsg);
 503     if (nsMsg == nullptr)
 504     {
 505         ThrowNSException(NS_ERROR, "Message didn't have a field ID ");
 506         return (jint) OIC::Service::NSResult::ERROR;
 507     }
 508
 509     OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->SendMessage(nsMsg);
 510     if (result !=  OIC::Service::NSResult::OK)
 511     {
 512         LOGI("Fail to send NSProvider Message");
 513     }
 514     LOGI("JNIProviderService: nativeSendMessage - OUT");
 515     return (jint) result;
 516 }
 517
 518 JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendSyncInfo(
 519     JNIEnv *env, jobject jObj, jlong messageId , jint syncState)
 520 {
 521     LOGI("JNIProviderService: nativeSendSyncInfo - IN");
 522     OIC::Service::NSProviderService::getInstance()->SendSyncInfo( messageId,
 523             (OIC::Service::NSSyncInfo::NSSyncType) syncState);
 524     LOGI("JNIProviderService: nativeSendSyncInfo - OUT");
 525     return;
 526 }
 527
 528 JNIEXPORT jint JNICALL
 529 Java_org_iotivity_service_ns_provider_ProviderService_nativeEnableRemoteService(JNIEnv *env,
 530         jobject jObj, jstring jstr)
 531 {
 532     LOGI("JNIProviderService: nativeEnableRemoteService - IN");
 533     if (!jstr)
 534     {
 535         ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
 536         return (jint) OIC::Service::NSResult::ERROR;
 537     }
 538
 539     const char *address = env->GetStringUTFChars( jstr, NULL);
 540     std::string servAddress(address);
 541     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->EnableRemoteService(
 542                                        servAddress);
 543     if (result !=  OIC::Service::NSResult::OK)
 544     {
 545         LOGE("Fail to Enable Remote Service");
 546     }
 547     env->ReleaseStringUTFChars(jstr, address);
 548     LOGI("JNIProviderService: nativeEnableRemoteService - OUT");
 549     return (jint) result;
 550 }
 551
 552 JNIEXPORT jint JNICALL
 553 Java_org_iotivity_service_ns_provider_ProviderService_nativeDisableRemoteService(JNIEnv *env,
 554         jobject jObj, jstring jstr)
 555 {
 556     LOGI("JNIProviderService: nativeDisableRemoteService - IN");
 557     if (!jstr)
 558     {
 559         ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
 560         return (jint) OIC::Service::NSResult::ERROR;
 561     }
 562
 563     const char *address = env->GetStringUTFChars( jstr, NULL);
 564     std::string servAddress(address);
 565     OIC::Service::NSResult result  = OIC::Service::NSProviderService::getInstance()->DisableRemoteService(
 566                                        servAddress);
 567     if (result !=  OIC::Service::NSResult::OK)
 568     {
 569         LOGE("Fail to Disable Remote Service");
 570     }
 571     env->ReleaseStringUTFChars(jstr, address);
 572     LOGI("JNIProviderService: nativeDisableRemoteService - OUT");
 573     return (jint) result;
 574 }
 575
 576 JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription(
 577     JNIEnv *env,
 578     jobject jObj, jobject jConsumer, jboolean jAccepted)
 579 {
 580     LOGD("JNIProviderService: nativeAcceptSubscription - IN");
 581
 582     jclass consumerClass =  env->GetObjectClass( jConsumer);
 583     if (!consumerClass)
 584     {
 585         ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Consumer");
 586         return (jint) OIC::Service::NSResult::ERROR;
 587     }
 588
 589     // Consumer ID
 590     jfieldID fid_id =  env->GetFieldID(consumerClass, "mConsumerId",  "Ljava/lang/String;");
 591     if (fid_id == NULL)
 592     {
 593         LOGE("Error: jfieldID for mConsumerId  is null");
 594         ThrowNSException(NS_ERROR, "ConsumerId not found");
 595         return (jint) OIC::Service::NSResult::ERROR;
 596     }
 597
 598     jstring jconId = (jstring)env->GetObjectField( jConsumer, fid_id);
 599     const char *conId = "";
 600     if (conId)
 601     {
 602         conId = env->GetStringUTFChars( jconId, NULL);
 603     }
 604     else
 605     {
 606         LOGI("Info: Consumer Id  is null");
 607     }
 608     std::string consumerId(conId);
 609     env->ReleaseStringUTFChars(jconId, conId);
 610
 611     LOGI("Consumer ID: %s\n", consumerId.c_str());
 612
 613     OIC::Service::NSConsumer *consumer = new OIC::Service::NSConsumer(consumerId);
 614     int result =  consumer->acceptSubscription(consumer,  (bool)jAccepted);
 615     if (jAccepted)
 616     {
 617         LOGI("Subscription Accepted");
 618     }
 619     else
 620     {
 621         LOGI("Subscription Denied");
 622     }
 623
 624     LOGD("JNIProviderService: nativeAcceptSubscription - OUT");
 625     return result;
 626 }
 627
 628 // JNI OnLoad
 629 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
 630 {
 631     LOGD("ProviderService_JNI_OnLoad");
 632     g_jvm = jvm;
 633
 634     JNIEnv *env;
 635     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
 636     {
 637         LOGE("Failed to get the environment using GetEnv()");
 638         return JNI_ERR;
 639     }
 640
 641     jclass localMessage = env->FindClass(
 642                               "org/iotivity/service/ns/common/Message");
 643     if (!localMessage)
 644     {
 645         LOGE("Failed to get local Message class");
 646         return JNI_ERR;
 647     }
 648     g_cls_Message = (jclass) (env->NewGlobalRef(localMessage));
 649     if (!g_cls_Message)
 650     {
 651         LOGE("Failed to set Global Message reference");
 652         return JNI_ERR;
 653     }
 654
 655     jclass localMessageType = env->FindClass(
 656                                   "org/iotivity/service/ns/common/Message$MessageType");
 657     if (!localMessageType)
 658     {
 659         LOGE("Failed to get local Message Type class");
 660         return JNI_ERR;
 661     }
 662     g_cls_Message_Type = (jclass) (env->NewGlobalRef(localMessageType));
 663     if (!g_cls_Message_Type)
 664     {
 665         LOGE("Failed to set Global Message Type reference");
 666         return JNI_ERR;
 667     }
 668
 669     jclass localConsumer = env->FindClass(
 670                                "org/iotivity/service/ns/provider/Consumer");
 671     if (!localConsumer)
 672     {
 673         LOGE("Failed to get local Provider class");
 674         return JNI_ERR;
 675     }
 676     g_cls_Consumer = (jclass) (env->NewGlobalRef(localConsumer));
 677     if (!g_cls_Consumer)
 678     {
 679         LOGE("Failed to set Global Provider reference");
 680         return JNI_ERR;
 681     }
 682
 683     jclass localSyncInfo = env->FindClass(
 684                                "org/iotivity/service/ns/common/SyncInfo");
 685     if (!localSyncInfo)
 686     {
 687         LOGE("Failed to get local SyncInfo class");
 688         return JNI_ERR;
 689     }
 690     g_cls_SyncInfo = (jclass) (env->NewGlobalRef(localSyncInfo));
 691     if (!g_cls_SyncInfo)
 692     {
 693         LOGE("Failed to set Global SyncInfo reference");
 694         return JNI_ERR;
 695     }
 696
 697     jclass localSyncType = env->FindClass(
 698                                "org/iotivity/service/ns/common/SyncInfo$SyncType");
 699     if (!localSyncType)
 700     {
 701         LOGE("Failed to get local SyncType enum");
 702         return JNI_ERR;
 703     }
 704     g_cls_SyncType = (jclass) (env->NewGlobalRef(localSyncType));
 705     if (!g_cls_SyncType)
 706     {
 707         LOGE("Failed to set Global SyncType reference");
 708         return JNI_ERR;
 709     }
 710
 711     jclass localMediaContents = env->FindClass(
 712                                     "org/iotivity/service/ns/common/MediaContents");
 713     if (!localMediaContents)
 714     {
 715         LOGE("Failed to get local MediaContents class");
 716         return JNI_ERR;
 717     }
 718     g_cls_MediaContents = (jclass) (env->NewGlobalRef(localMediaContents));
 719     if (!g_cls_MediaContents)
 720     {
 721         LOGE("Failed to set Global MediaContents reference");
 722         return JNI_ERR;
 723     }
 724
 725     env->DeleteLocalRef(localMessage);
 726     env->DeleteLocalRef(localMessageType);
 727     env->DeleteLocalRef(localConsumer);
 728     env->DeleteLocalRef(localSyncInfo);
 729     env->DeleteLocalRef(localSyncType);
 730     env->DeleteLocalRef(localMediaContents);
 731
 732     return NSExceptionInit(env);
 733 }
 734
 735 JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)
 736 {
 737     LOGI("ProviderService_JNI_OnUnload");
 738     JNIEnv *env;
 739
 740     if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
 741     {
 742         LOGE("Failed to get the environment using GetEnv()");
 743         return ;
 744     }
 745
 746     env->DeleteGlobalRef(g_cls_Message);
 747     env->DeleteGlobalRef(g_cls_Consumer);
 748     env->DeleteGlobalRef(g_cls_SyncInfo);
 749     env->DeleteGlobalRef(g_cls_SyncType);
 750     env->DeleteGlobalRef(g_cls_MediaContents);
 751     env->DeleteGlobalRef(g_cls_Message_Type);
 752 }