+jobject getJavaMessageType(JNIEnv *env, OIC::Service::NSMessage::NSMessageType type)
+{
+ LOGD ("JNIProviderService: getJavaMessageType - IN");
+ switch (type)
+ {
+ case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_ALERT:
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
+ "ALERT", "Lorg/iotivity/service/ns/common/Message$MessageType;");
+ return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ }
+ case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_NOTICE:
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
+ "NOTICE", "Lorg/iotivity/service/ns/common/Message$MessageType;");
+ return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ }
+ case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_EVENT:
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
+ "EVENT", "Lorg/iotivity/service/ns/common/Message$MessageType;");
+ return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ }
+ case OIC::Service::NSMessage::NSMessageType::NS_MESSAGE_INFO:
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(g_cls_Message_Type,
+ "INFO", "Lorg/iotivity/service/ns/common/Message$MessageType;");
+ return env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ }
+ default:
+ return NULL;
+ }
+ LOGD ("JNIProviderService: getJavaMessageType - OUT");
+ return NULL;
+}
+
+jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message)
+{
+ LOGD ("JNIProviderService: getJavaMessage - IN");
+
+ LOGD ("id : %llu\n", message->getMessageId());
+ LOGD ("title : %s\n", message->getTitle().c_str());
+ LOGD ("content : %s\n", message->getContentText().c_str());
+ LOGD ("source : %s\n", message->getSourceName().c_str());
+
+ jlong jMessageId = (jlong) message->getMessageId();
+ jstring jProviderId = env->NewStringUTF(message->getProviderId().c_str());
+ jstring jTitle = env->NewStringUTF(message->getTitle().c_str());
+ jstring jContentText = env->NewStringUTF(message->getContentText().c_str());
+ jstring jSourceName = env->NewStringUTF(message->getSourceName().c_str());
+ jstring jTopic = env->NewStringUTF(message->getTopic().c_str());
+
+ jstring jTime = env->NewStringUTF(message->getTime().c_str());
+ jlong jTTL = (jlong) message->getTTL();
+
+ jlong pMessage = (long) message;
+
+ jclass cls_message = (jclass) (env->NewLocalRef(g_cls_Message));
+ if (!cls_message)
+ {
+ LOGE ("Failed to Get ObjectClass for Message");
+ return NULL ;
+ }
+ jmethodID mid_message = env->GetMethodID(
+ cls_message, "<init>",
+ "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+ if (!mid_message)
+ {
+ LOGE ("Failed to Get MethodID for Message<init>");
+ return NULL;
+ }
+ jobject obj_message = env->NewObject(cls_message, mid_message,
+ jTitle, jContentText, jSourceName);
+ if (!obj_message)
+ {
+ LOGE ("Failed to Get Java Object for Message");
+ return NULL;
+ }
+ jfieldID fid_nativeHandle = env->GetFieldID(cls_message, "mNativeHandle", "J");
+ if (!fid_nativeHandle)
+ {
+ LOGE("Failed to get nativeHandle for Message");
+ return NULL;
+ }
+ env->SetLongField(obj_message, fid_nativeHandle, pMessage);
+
+ jfieldID fid_messageId = env->GetFieldID(cls_message, "mMessageId", "J");
+ if (!fid_messageId)
+ {
+ LOGE("Failed to get field MessageID for Message");
+ return NULL;
+ }
+ env->SetLongField(obj_message, fid_messageId, jMessageId);
+
+ jfieldID fid_providerId = env->GetFieldID(cls_message, "mProviderId", "Ljava/lang/String;");
+ if (!fid_providerId)
+ {
+ LOGE("Failed to get field ProviderID for Message");
+ return NULL;
+ }
+ env->SetObjectField(obj_message, fid_providerId, jProviderId);
+
+ jfieldID fid_time = env->GetFieldID(cls_message, "mTime", "Ljava/lang/String;");
+ if (!fid_time)
+ {
+ LOGE("Failed to get field Time for Message");
+ return NULL;
+ }
+ env->SetObjectField(obj_message, fid_time, jTime);
+
+ jfieldID fid_ttl = env->GetFieldID(cls_message, "mTTL", "J");
+ if (!fid_ttl)
+ {
+ LOGE("Failed to get field TTL for Message");
+ return NULL;
+ }
+ env->SetLongField(obj_message, fid_ttl, jTTL);
+
+ jfieldID fid_topic = env->GetFieldID(cls_message, "mTopic", "Ljava/lang/String;");
+ if (!fid_topic)
+ {
+ LOGE("Failed to get mTopic for Message");
+ return NULL;
+ }
+ env->SetObjectField(obj_message, fid_topic, jTopic);
+
+ OIC::Service::NSMediaContents *mediaCont = message->getMediaContents();
+ if (mediaCont != nullptr)
+ {
+ jstring jIconImage = env->NewStringUTF(mediaCont->getIconImage().c_str());
+ jclass cls_mediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));
+ if (!cls_mediaContents)
+ {
+ LOGE ("Failed to Get ObjectClass for MediaContents");
+ return NULL;
+ }
+ jmethodID mid_mediaContents = env->GetMethodID(
+ cls_mediaContents, "<init>", "(Ljava/lang/String;)V");
+ if (!mid_mediaContents)
+ {
+ LOGE ("Failed to Get MethodID for MediaContents<init>");
+ return NULL;
+ }
+ jobject obj_mediaContents = env->NewObject(cls_mediaContents, mid_mediaContents,
+ jIconImage);
+
+ jfieldID fid_mediaContents = env->GetFieldID(cls_message, "mMediaContents",
+ "Lorg/iotivity/service/ns/common/MediaContents;");
+ if (!fid_mediaContents)
+ {
+ LOGE("Failed to get field mediaContents for Message");
+ return NULL;
+ }
+ env->SetObjectField(obj_message, fid_mediaContents, obj_mediaContents);
+
+ }
+
+ jobject jType = getJavaMessageType(env, message->getType());
+ if (jType)
+ {
+ jfieldID fid_type = env->GetFieldID(cls_message, "mType",
+ "Lorg/iotivity/service/ns/common/Message$MessageType;");
+ if (!fid_type)
+ {
+ LOGE("Failed to get field Type for Message");
+ return NULL;
+ }
+ env->SetObjectField(obj_message, fid_type, jType);
+ }
+
+ LOGD("Reading OCRepresentation Object from Native");
+ OC::OCRepresentation *ocRepresentation = new OC::OCRepresentation(message->getExtraInfo());
+ jlong handle = reinterpret_cast<jlong>(ocRepresentation);
+ jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
+ handle, true);
+ if (!jRepresentation)
+ {
+ LOGE("Failed to create OcRepresentation");
+ delete ocRepresentation;
+ }
+ else
+ {
+ LOGD("Created OCRepresentation Object from Native");
+ }
+ jfieldID fid_extraInfo = env->GetFieldID(cls_message, "mExtraInfo",
+ "Lorg/iotivity/base/OcRepresentation;");
+ if (!fid_extraInfo)
+ {
+ LOGE("Failed to get mExtraInfo for Message");
+ delete ocRepresentation;
+ return NULL;
+ }
+ LOGD ("setting extraInfo field");
+ env->SetObjectField(obj_message, fid_extraInfo, jRepresentation);
+
+ env->DeleteLocalRef(cls_message);
+ LOGD ("JNIProviderService: getJavaMessage - OUT");
+ return obj_message;
+}
+
+jobject getJavaTopicState(JNIEnv *env, OIC::Service::NSTopic::NSTopicState nsState)
+{
+ LOGD("JNIProviderService: getJavaTopicState - IN");
+
+ // TopicState
+ jclass cls_topicState = (jclass) (env->NewLocalRef(g_cls_TopicState));
+ if (!cls_topicState)
+ {
+ LOGE ("Failed to Get ObjectClass for TopicState Type");
+ return NULL;
+ }
+
+ switch (nsState)
+ {
+ case OIC::Service::NSTopic::NSTopicState::UNSUBSCRIBED:
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,
+ "UNSUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");
+ return env->GetStaticObjectField(cls_topicState, fieldID);
+ }
+ case OIC::Service::NSTopic::NSTopicState::SUBSCRIBED:
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,
+ "SUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");
+ return env->GetStaticObjectField(cls_topicState, fieldID);
+ }
+ default:
+ return NULL;
+
+ }
+
+ LOGD("JNIProviderService: getJavaTopicState - OUT");
+ return NULL;
+}
+
+jobject getJavaTopicsList(JNIEnv *env, OIC::Service::NSTopicsList *topicList)
+{
+ LOGD("JNIProviderService: getJavaTopicsList - IN");
+ jclass cls_topicList = (jclass) (env->NewLocalRef(g_cls_TopicsList));
+ if (!cls_topicList)
+ {
+ LOGE ("Failed to Get ObjectClass for TopicsList");
+ return NULL;
+ }
+ jmethodID mid_topicList = env->GetMethodID(cls_topicList, "<init>", "()V");
+ if (!mid_topicList)
+ {
+ LOGE ("Failed to Get MethodID for TopicsList<init>");
+ return NULL;
+ }
+ jobject obj_topicList = env->NewObject(cls_topicList, mid_topicList);
+ if (!obj_topicList)
+ {
+ LOGE ("Failed to Get object for TopicsList");
+ return NULL;
+ }
+ jmethodID mid_addTopic = env->GetMethodID(cls_topicList, "addTopic",
+ "(Ljava/lang/String;Lorg/iotivity/service/ns/common/Topic$TopicState;)V");
+ if (!mid_addTopic)
+ {
+ LOGE ("Failed to Get MethodID for addTopic");
+ return NULL;
+ }
+ for (auto it : topicList->getTopicsList())
+ {
+ jobject jState = getJavaTopicState(env, it->getState());
+ std::string topicName = it->getTopicName();
+ jstring jTopicName = env->NewStringUTF(topicName.c_str());
+ env->CallVoidMethod(obj_topicList, mid_addTopic, jTopicName, jState);
+ }
+ env->DeleteLocalRef(cls_topicList);
+ LOGD("JNIProviderService: getJavaTopicsList - OUT");
+ return obj_topicList;
+}
+
+jobject getJavaSyncType(JNIEnv *env, OIC::Service::NSSyncInfo::NSSyncType nsType)
+{
+ LOGD ("JNIProviderService: getJavaSyncType - IN");
+
+ // SyncType
+ jclass cls_SyncType = (jclass) (env->NewLocalRef(g_cls_SyncType));
+ if (!cls_SyncType)
+ {
+ LOGE ("Failed to Get ObjectClass for SyncType");
+ return NULL;
+ }
+ switch (nsType)
+ {
+ case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_UNREAD:
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
+ "UNREAD", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
+ return env->GetStaticObjectField(cls_SyncType, fieldID);
+ }
+ case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ :
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
+ "READ", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
+ return env->GetStaticObjectField(cls_SyncType, fieldID);
+ }
+ case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_DELETED :
+ {
+ static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
+ "DELETED", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
+ return env->GetStaticObjectField(cls_SyncType, fieldID);
+ }
+ default:
+ return NULL;
+ }
+
+ LOGD ("JNIProviderService: getJavaSyncType - OUT");
+ return NULL;
+}
+
+
+void onSubscribeListenerCb(OIC::Service::NSConsumer *consumer)
+{
+ LOGD("JNIProviderService_onSubscribeListenerCb - IN");
+
+ jint envRet;
+ JNIEnv *env = GetJNIEnv(&envRet);
+ if (NULL == env) return ;
+
+ jobject jSubscriptionListener = (jobject) env->NewLocalRef(g_obj_subscriptionListener);
+ if (!jSubscriptionListener)
+ {
+ LOGE ("Failed to Get jSubscriptionListener");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+
+ LOGD("consumer ID : %s\n", consumer->getConsumerId().c_str());
+
+ jstring jConsumerId = env->NewStringUTF( consumer->getConsumerId().c_str());
+
+ jclass cls_consumer = (jclass) (env->NewLocalRef(g_cls_Consumer));
+ if (!cls_consumer)
+ {
+ LOGE ("Failed to Get ObjectClass for Consumer");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+
+ jmethodID mid_consumer = env->GetMethodID(
+ cls_consumer,
+ "<init>",
+ "(Ljava/lang/String;)V");
+ if (!mid_consumer)
+ {
+ LOGE ("Failed to Get MethodID for Consumer<init>");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+ jobject obj_consumer = env->NewObject( cls_consumer, mid_consumer, jConsumerId);
+
+ jclass cls = env->GetObjectClass( jSubscriptionListener);
+ if (!cls)
+ {
+ LOGE("Failed to Get ObjectClass of jSubscriptionListener");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return;
+ }
+ jmethodID mid = env->GetMethodID(
+ cls,
+ "onConsumerSubscribed",
+ "(Lorg/iotivity/service/ns/provider/Consumer;)V");
+ if (!mid)
+ {
+ LOGE("Failed to Get MethodID of onConsumerSubscribed");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return;
+ }
+
+ env->CallVoidMethod( jSubscriptionListener, mid, obj_consumer);
+ env->DeleteLocalRef(jSubscriptionListener);
+ env->DeleteLocalRef(cls_consumer);
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ LOGD("JNIProviderService_onSubscribeListenerCb - OUT");
+ return;
+}
+
+void onSyncInfoListenerCb(OIC::Service::NSSyncInfo *sync)
+{
+ LOGD("JNIProviderService_onSyncInfoListenerCb - IN");
+
+ jint envRet;
+ JNIEnv *env = GetJNIEnv(&envRet);
+ if (NULL == env) return ;
+
+ jobject jSyncListener = (jobject) env->NewLocalRef(g_obj_syncListener);
+ if (!jSyncListener)
+ {
+ LOGE ("Failed to Get jSyncListener");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+
+ LOGD("Sync ID : %ld\n", (long) sync->getMessageId());
+ LOGD("Sync STATE : %d\n", (int) sync->getState());
+
+ jlong jMessageId = (long) sync->getMessageId();
+ jstring jProviderId = env->NewStringUTF(sync->getProviderId().c_str());
+ jobject syncType = getJavaSyncType(env, sync->getState());
+ if (!syncType)
+ {
+ LOGE ("Failed to Get syncType for SyncInfo");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+ jclass cls_SyncInfo = (jclass) (env->NewLocalRef(g_cls_SyncInfo));
+ if (!cls_SyncInfo)
+ {
+ LOGE ("Failed to Get ObjectClass for SyncInfo");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+ jmethodID mid_syncInfo = env->GetMethodID(
+ cls_SyncInfo,
+ "<init>",
+ "(JLjava/lang/String;Lorg/iotivity/service/ns/common/SyncInfo$SyncType;)V");
+ if (!mid_syncInfo)
+ {
+ LOGE ("Failed to Get MethodID for SyncInfo");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+
+ jobject obj_syncInfo = env->NewObject( cls_SyncInfo, mid_syncInfo,
+ jMessageId, jProviderId, syncType);
+ if (!obj_syncInfo)
+ {
+ LOGE ("Failed to Get Object for SyncInfo");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return ;
+ }
+
+ jclass cls = env->GetObjectClass( jSyncListener);
+ if (!cls)
+ {
+ LOGE("Failed to Get ObjectClass");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return;
+ }
+ jmethodID mid = env->GetMethodID(
+ cls,
+ "onMessageSynchronized",
+ "(Lorg/iotivity/service/ns/common/SyncInfo;)V");
+ if (!mid)
+ {
+ LOGE("Failed to Get MethodID");
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ return;
+ }
+ env->CallVoidMethod( jSyncListener, mid, obj_syncInfo);
+
+ env->DeleteLocalRef(jSyncListener);
+ env->DeleteLocalRef(cls_SyncInfo);
+ if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+
+ LOGD("JNIProviderService: OnSyncInfoListenerCb - OUT");
+ return;
+
+}
+
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStart
+(JNIEnv *env, jobject jObj, jobject jSubscriptionListener, jobject jSyncListener,
+ jboolean jPolicy, jstring jUserInfo, jboolean jResourceSecurity)