#include "JniNotificationProvider.h"
#include "NSProviderService.h"
+#include "JniOcRepresentation.h"
-static JavaVM *g_jvm = NULL;
+static JavaVM *g_jvm_provider = NULL;
static jobject g_obj_subscriptionListener = NULL;
static jobject g_obj_syncListener = NULL;
jclass g_cls_SyncInfo;
jclass g_cls_SyncType;
jclass g_cls_MediaContents;
+jclass g_cls_Topic;
+jclass g_cls_TopicsList;
+jclass g_cls_TopicState;
+jclass g_cls_OcRepresentation;
+jmethodID g_mid_OcRepresentation_N_ctor_bool = NULL;
static JNIEnv *GetJNIEnv(jint *ret)
{
JNIEnv *env = NULL;
- *ret = g_jvm->GetEnv((void **) &env, JNI_CURRENT_VERSION);
+ *ret = g_jvm_provider->GetEnv((void **) &env, JNI_CURRENT_VERSION);
switch (*ret)
{
case JNI_OK:
return env;
case JNI_EDETACHED:
- if (g_jvm->AttachCurrentThread(&env, NULL) != JNI_OK)
+ if (g_jvm_provider->AttachCurrentThread(&env, NULL) != JNI_OK)
{
LOGE ("Failed to get the environment");
return NULL;
}
}
-void onSubscribeListenerCb(OIC::Service::NSConsumer *consumer)
-{
- LOGI("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->DetachCurrentThread();
- return ;
- }
-
- LOGI("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->DetachCurrentThread();
- return ;
- }
-
- jmethodID mid_consumer = env->GetMethodID(
- cls_consumer,
- "<init>",
- "(JLjava/lang/String;Lorg/iotivity/service/ns/provider/Consumer)V");
- if (!mid_consumer)
- {
- LOGE ("Failed to Get MethodID for Consumer<init>");
- if (JNI_EDETACHED == envRet) g_jvm->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->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->DetachCurrentThread();
- return;
- }
-
- env->CallVoidMethod( jSubscriptionListener, mid, obj_consumer);
- env->DeleteLocalRef(jSubscriptionListener);
- env->DeleteLocalRef(cls_consumer);
- if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
- LOGI("JNIProviderService_onSubscribeListenerCb - OUT");
- return;
-}
-
-void onSyncInfoListenerCb(OIC::Service::NSSyncInfo *sync)
-{
- LOGI("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->DetachCurrentThread();
- return ;
- }
-
- LOGI("Sync ID : %ld\n", (long) sync->getMessageId());
- LOGI("Sync STATE : %d\n", (int) sync->getState());
-
- jlong jMessageId = (long) sync->getMessageId();
- jstring jProviderId = env->NewStringUTF(sync->getProviderId().c_str());
- jobject syncType;
-
- jclass cls_SyncType = (jclass) (env->NewLocalRef(g_cls_SyncType));
- if (!cls_SyncType)
- {
- LOGE ("Failed to Get ObjectClass for SyncType");
- if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
- return ;
- }
- switch (sync->getState())
- {
- case OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_UNREAD:
- {
- static jfieldID fieldID = env->GetStaticFieldID(cls_SyncType,
- "UNREAD", "Lorg/iotivity/service/ns/common/SyncInfo$SyncType;");
- syncType = 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;");
- syncType = 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;");
- syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
- }
-
- }
-
- 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->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->DetachCurrentThread();
- return ;
- }
-
- jobject obj_syncInfo = env->NewObject( cls_SyncInfo, mid_syncInfo, jMessageId, jProviderId,
- syncType);
-
- jclass cls = env->GetObjectClass( jSyncListener);
- if (!cls)
- {
- LOGE("Failed to Get ObjectClass");
- if (JNI_EDETACHED == envRet) g_jvm->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->DetachCurrentThread();
- return;
- }
- env->CallVoidMethod( jSyncListener, mid, obj_syncInfo);
-
- env->DeleteLocalRef(jSyncListener);
- env->DeleteLocalRef(cls_SyncInfo);
- env->DeleteLocalRef(cls_SyncType);
- if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
-
- LOGI("JNIProviderService: OnSyncInfoListenerCb - OUT");
- return;
-
-}
-
-OIC::Service::NSMessage *getMessage(JNIEnv *env, jobject jMsg)
+OIC::Service::NSMessage *getNativeMessage(JNIEnv *env, jobject jMsg)
{
- LOGI("JNIProviderService: getMessage - IN");
+ LOGD("JNIProviderService: getMessage - IN");
jclass cls = env->GetObjectClass( jMsg);
jint jtype = env->CallIntMethod(jobj, mid);
OIC::Service::NSMessage::NSMessageType type = (OIC::Service::NSMessage::NSMessageType) jtype;
- LOGI("Message Type: %ld\n", (long )type);
+ LOGD("Message Type: %ld\n", (long )type);
// Message Time
jfieldID fid_tm = env->GetFieldID( cls, "mTime", "Ljava/lang/String;");
}
else
{
- LOGI("Info: messageTitle is null");
+ LOGD("Info: messageTitle is null");
}
- LOGI("Message Time: %s\n", time);
+ LOGD("Message Time: %s\n", time);
// Message TTL
jfieldID fid_ttl = env->GetFieldID( cls, "mTTL", "J");
LOGE("Error: jfieldID for message ttl is null");
return nullptr;
}
- jlong jttl = (jlong) env->GetObjectField( jMsg, fid_ttl);
- uint64_t ttl = jttl;
- LOGI("Message ID: %lld\n", ttl);
+ jlong jttl = (jlong) env->GetLongField( jMsg, fid_ttl);
+ uint64_t ttl = jttl;
+ LOGD("TTL: %d\n", ttl);
// Message Title
jfieldID fid_title = env->GetFieldID( cls, "mTitle", "Ljava/lang/String;");
}
else
{
- LOGI("Info: messageTitle is null");
+ LOGD("Info: messageTitle is null");
}
- LOGI("Message Title: %s\n", messageTitle);
+ LOGD("Message Title: %s\n", messageTitle);
// Message Content Text
jfieldID fid_body = env->GetFieldID( cls, "mContentText", "Ljava/lang/String;");
}
else
{
- LOGI("Info: messageBody is null");
+ LOGD("Info: messageBody is null");
}
- LOGI("Message Body: %s\n", messageBody);
+ LOGD("Message Body: %s\n", messageBody);
// Message Source
jfieldID fid_source = env->GetFieldID( cls, "mSourceName", "Ljava/lang/String;");
}
else
{
- LOGI("Info: messageSource is null");
+ LOGD("Info: messageSource is null");
+ }
+ LOGD("Message Source: %s\n", messageSource);
+
+ // Message Topic
+ jfieldID fid_topic = env->GetFieldID( cls, "mTopic", "Ljava/lang/String;");
+ if (fid_topic == NULL)
+ {
+ LOGE("Error: jfieldID for topic is null");
+ return nullptr;
+ }
+ jstring jtopic = (jstring)env->GetObjectField( jMsg, fid_topic);
+ const char *topic = "";
+ if (jtopic)
+ {
+ topic = env->GetStringUTFChars( jtopic, NULL);
+ }
+ else
+ {
+ LOGD("Info: topic is null");
}
- LOGI("Message Source: %s\n", messageSource);
+ LOGD("Topic : %s\n", topic);
// Message MediaContents
jfieldID fid_media = env->GetFieldID( cls, "mMediaContents",
return nullptr;
}
jobject jmedia = env->GetObjectField( jMsg, fid_media);
+ OIC::Service::NSMediaContents *media = nullptr;
if (jmedia == NULL)
{
- LOGE("Error: jmedia object of MediaContents inside Message is null");
- return nullptr;
+ LOGD("Info: jmedia object of MediaContents inside Message is null");
}
- jclass cls_MediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));
- if (!cls_MediaContents)
+ else
{
- LOGE ("Failed to Get ObjectClass for class MediaContents");
+ jclass cls_MediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));
+ if (!cls_MediaContents)
+ {
+ LOGE ("Failed to Get ObjectClass for class MediaContents");
+ return nullptr;
+ }
+ jfieldID fid_icon = env->GetFieldID( cls_MediaContents, "mIconImage", "Ljava/lang/String;");
+ if (fid_icon == NULL)
+ {
+ LOGE("Error: jfieldID for iconImage is null");
+ return nullptr;
+ }
+ jstring jiconImage = (jstring)env->GetObjectField( jmedia, fid_icon);
+ const char *iconImage = "";
+ if (jiconImage)
+ {
+ iconImage = env->GetStringUTFChars( jiconImage, NULL);
+ media = new OIC::Service::NSMediaContents(std::string(iconImage));
+ env->ReleaseStringUTFChars(jiconImage, iconImage);
+ }
+ else
+ {
+ LOGD("Info: iconImage is null");
+ }
+ env->DeleteLocalRef(cls_MediaContents);
+ LOGD("iconImage: %s\n", iconImage);
+ }
+
+ // Message ExtraInfo
+ jfieldID fid_extraInfo = env->GetFieldID( cls, "mExtraInfo",
+ "Lorg/iotivity/base/OcRepresentation;");
+ if (fid_extraInfo == NULL)
+ {
+ LOGE("Error: jfieldID for mExtraInfo is null");
return nullptr;
}
- jfieldID fid_icon = env->GetFieldID( cls_MediaContents, "mIconImage", "Ljava/lang/String;");
- if (fid_icon == NULL)
+ jobject jExtraInfo = env->GetObjectField( jMsg, fid_extraInfo);
+ OC::OCRepresentation *representation = nullptr;
+ if (jExtraInfo == NULL)
+ {
+ LOGE("Error: jExtraInfo object of Message is null");
+ }
+ else
+ {
+ representation = GetHandle<OC::OCRepresentation>(env, jExtraInfo);
+ if (env->ExceptionCheck())
+ {
+ LOGE("Failed to get native handle from OcRepresentation");
+ }
+ if (!representation)
+ {
+ LOGE("Failed to get native object OcRepresentation");
+ }
+ }
+
+ OIC::Service::NSMessage *nsMsg;
+ jfieldID nativeHandle = env->GetFieldID(cls, "mNativeHandle", "J");
+ if (!nativeHandle)
{
- LOGE("Error: jfieldID for iconImage is null");
+ LOGE("Error: fieldID for mNativeHandle is null");
return nullptr;
}
- jstring jiconImage = (jstring)env->GetObjectField( jmedia, fid_icon);
- const char *iconImage = "";
- if (jiconImage)
+ jlong jMessage = env->GetLongField(jMsg, nativeHandle);
+ if (jMessage)
{
- iconImage = env->GetStringUTFChars( jiconImage, NULL);
+ LOGD ("calling sendMessage on mNativeHandle");
+ nsMsg = (OIC::Service::NSMessage *) (jMessage);
}
else
{
- LOGI("Info: iconImage is null");
+ nsMsg = OIC::Service::NSProviderService::getInstance()->createMessage();
}
- LOGI("iconImage: %s\n", iconImage);
-
- OIC::Service::NSMediaContents *media = new OIC::Service::NSMediaContents(std::string(iconImage));
- OIC::Service::NSMessage *nsMsg = OIC::Service::NSProviderService::getInstance()->CreateMessage();
-
nsMsg->setType(type);
nsMsg->setTime(std::string(time));
nsMsg->setTTL(ttl);
nsMsg->setTitle(std::string(messageTitle));
nsMsg->setContentText(std::string(messageBody));
nsMsg->setSourceName(std::string(messageSource));
- nsMsg->setMediaContents(media);
+ if(media != nullptr)
+ {
+ nsMsg->setMediaContents(media);
+ }
+ nsMsg->setTopic(std::string(topic));
+ if (representation != nullptr)
+ {
+ nsMsg->setExtraInfo(*representation);
+ }
env->DeleteLocalRef(cls_messageType);
- env->DeleteLocalRef(cls_MediaContents);
- if (jtime)
+ if (jtime)
{
env->ReleaseStringUTFChars(jtime, time);
}
- if (jmsgTitle)
+ if (jmsgTitle)
{
env->ReleaseStringUTFChars(jmsgTitle, messageTitle);
}
- if (jmsgBody)
+ if (jmsgBody)
{
env->ReleaseStringUTFChars(jmsgBody, messageBody);
}
- if (jmsgSource)
+ if (jmsgSource)
{
env->ReleaseStringUTFChars(jmsgSource, messageSource);
}
- if (jiconImage)
+ if (jtopic)
{
- env->ReleaseStringUTFChars(jiconImage, iconImage);
+ env->ReleaseStringUTFChars(jtopic, topic);
}
- LOGI("JNIProviderService: getMessage - OUT");
+ LOGD("JNIProviderService: getMessage - OUT");
return nsMsg;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStart(
- JNIEnv *env, jobject jObj, jboolean jPolicy, jobject jSubscriptionListener,
- jobject jSyncListener)
+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)
{
- LOGI("JNIProviderService: nativeStart - IN");
+ LOGD("JNIProviderService: nativeStart - IN");
if (!jSubscriptionListener || !jSyncListener)
{
LOGE("Fail to set listeners");
OIC::Service::NSProviderService::ProviderConfig cfg;
cfg.m_subscribeRequestCb = onSubscribeListenerCb;
cfg.m_syncInfoCb = onSyncInfoListenerCb;
- cfg.policy = (bool) jPolicy;
+ cfg.subControllability = (bool) jPolicy;
+ if (!jUserInfo)
+ {
+ const char *info = env->GetStringUTFChars( jUserInfo, NULL);
+ std::string userInfo(info);
+ cfg.userInfo = userInfo;
+ }
+ cfg.resourceSecurity = (bool) jResourceSecurity;
- OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->Start(cfg);
+ OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->start(cfg);
if (result != OIC::Service::NSResult::OK)
{
LOGE("Fail to start NSProviderService");
}
- LOGI("JNIProviderService: nativeStart - OUT");
+ LOGD("JNIProviderService: nativeStart - OUT");
return (jint) result;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop(
- JNIEnv *env, jobject jObj)
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop
+(JNIEnv *env, jobject jObj)
{
- LOGI("JNIProviderService: nativeStop - IN");
+ LOGD("JNIProviderService: nativeStop - IN");
- OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->Stop();
+ OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->stop();
if (result != OIC::Service::NSResult::OK)
{
- LOGI("Fail to stop NSProvider service");
+ LOGD("Fail to stop NSProvider service");
return (jint) result;
}
g_obj_subscriptionListener = NULL;
g_obj_syncListener = NULL;
- LOGI("JNIProviderService: nativeStop - OUT");
+ LOGD("JNIProviderService: nativeStop - OUT");
return (jint) result;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage(
- JNIEnv *env, jobject jObj, jobject jMsg)
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage
+(JNIEnv *env, jobject jObj, jobject jMsg)
{
- LOGI("JNIProviderService: nativeSendMessage - IN");
+ LOGD("JNIProviderService: nativeSendMessage - IN");
if (!jMsg)
{
- LOGI("Fail to send notification - Message is null");
+ LOGD("Fail to send notification - Message is null");
ThrowNSException(NS_ERROR, "Message cannot be null");
return (jint) OIC::Service::NSResult::ERROR;
}
- OIC::Service::NSMessage *nsMsg = getMessage(env, jMsg);
+ OIC::Service::NSMessage *nsMsg = getNativeMessage(env, jMsg);
if (nsMsg == nullptr)
{
ThrowNSException(NS_ERROR, "Message didn't have a field ID ");
return (jint) OIC::Service::NSResult::ERROR;
}
- OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->SendMessage(nsMsg);
+ OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->sendMessage(nsMsg);
if (result != OIC::Service::NSResult::OK)
{
- LOGI("Fail to send NSProvider Message");
+ LOGD("Fail to send NSProvider Message");
}
- LOGI("JNIProviderService: nativeSendMessage - OUT");
+ LOGD("JNIProviderService: nativeSendMessage - OUT");
return (jint) result;
}
-JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendSyncInfo(
- JNIEnv *env, jobject jObj, jlong messageId , jint syncState)
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendSyncInfo
+(JNIEnv *env, jobject jObj, jlong messageId , jint syncState)
{
- LOGI("JNIProviderService: nativeSendSyncInfo - IN");
- OIC::Service::NSProviderService::getInstance()->SendSyncInfo( messageId,
+ LOGD("JNIProviderService: nativeSendSyncInfo - IN");
+ OIC::Service::NSProviderService::getInstance()->sendSyncInfo( messageId,
(OIC::Service::NSSyncInfo::NSSyncType) syncState);
- LOGI("JNIProviderService: nativeSendSyncInfo - OUT");
+ LOGD("JNIProviderService: nativeSendSyncInfo - OUT");
return;
}
+JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeCreateMessage
+(JNIEnv *env, jobject jObj)
+{
+ LOGD("JNIProviderService: nativeCreateMessage - IN");
+ OIC::Service::NSMessage *message =
+ OIC::Service::NSProviderService::getInstance()->createMessage();
+ if (message == nullptr)
+ {
+ ThrowNSException(NS_ERROR, "Couldn't get Native Message");
+ return NULL;
+ }
+ jobject jMsg = getJavaMessage(env, message);
+ if (!jMsg)
+ {
+ ThrowNSException(NS_ERROR, "Couldn't create Java Message");
+ return NULL;
+ }
+ LOGD("JNIProviderService: nativeCreateMessage - OUT");
+ return jMsg;
+}
+
JNIEXPORT jint JNICALL
-Java_org_iotivity_service_ns_provider_ProviderService_nativeEnableRemoteService(JNIEnv *env,
- jobject jObj, jstring jstr)
+Java_org_iotivity_service_ns_provider_ProviderService_nativeEnableRemoteService
+(JNIEnv *env, jobject jObj, jstring jstr)
{
- LOGI("JNIProviderService: nativeEnableRemoteService - IN");
+ LOGD("JNIProviderService: nativeEnableRemoteService - IN");
if (!jstr)
{
ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
const char *address = env->GetStringUTFChars( jstr, NULL);
std::string servAddress(address);
- OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->EnableRemoteService(
- servAddress);
+ OIC::Service::NSResult result =
+ OIC::Service::NSProviderService::getInstance()->enableRemoteService(
+ servAddress);
if (result != OIC::Service::NSResult::OK)
{
LOGE("Fail to Enable Remote Service");
}
env->ReleaseStringUTFChars(jstr, address);
- LOGI("JNIProviderService: nativeEnableRemoteService - OUT");
+ LOGD("JNIProviderService: nativeEnableRemoteService - OUT");
return (jint) result;
}
JNIEXPORT jint JNICALL
-Java_org_iotivity_service_ns_provider_ProviderService_nativeDisableRemoteService(JNIEnv *env,
- jobject jObj, jstring jstr)
+Java_org_iotivity_service_ns_provider_ProviderService_nativeDisableRemoteService
+(JNIEnv *env, jobject jObj, jstring jstr)
{
- LOGI("JNIProviderService: nativeDisableRemoteService - IN");
+ LOGD("JNIProviderService: nativeDisableRemoteService - IN");
if (!jstr)
{
ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
const char *address = env->GetStringUTFChars( jstr, NULL);
std::string servAddress(address);
- OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->DisableRemoteService(
- servAddress);
+ OIC::Service::NSResult result =
+ OIC::Service::NSProviderService::getInstance()->disableRemoteService(
+ servAddress);
if (result != OIC::Service::NSResult::OK)
{
LOGE("Fail to Disable Remote Service");
}
env->ReleaseStringUTFChars(jstr, address);
- LOGI("JNIProviderService: nativeDisableRemoteService - OUT");
+ LOGD("JNIProviderService: nativeDisableRemoteService - OUT");
return (jint) result;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription(
- JNIEnv *env,
- jobject jObj, jobject jConsumer, jboolean jAccepted)
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeRegisterTopic
+(JNIEnv *env, jobject jObj, jstring jTopicName)
{
- LOGD("JNIProviderService: nativeAcceptSubscription - IN");
+ LOGD("JNIProviderService: nativeRegisterTopic - IN");
+ if (!jTopicName)
+ {
+ ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
+ return (jint) OIC::Service::NSResult::ERROR;
+ }
+ const char *name = env->GetStringUTFChars( jTopicName, NULL);
+ std::string topicName(name);
+ OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->registerTopic(
+ topicName);
+ if (result != OIC::Service::NSResult::OK)
+ {
+ LOGE("Fail to Register Topic");
+ }
+ env->ReleaseStringUTFChars(jTopicName, name);
+ LOGD("JNIProviderService: nativeRegisterTopic - OUT");
+ return (jint) result;
+}
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeUnregisterTopic
+(JNIEnv *env, jobject jObj, jstring jTopicName)
+{
+ LOGD("JNIProviderService: nativeUnregisterTopic - IN");
+ if (!jTopicName)
+ {
+ ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
+ return (jint) OIC::Service::NSResult::ERROR;
+ }
+ const char *name = env->GetStringUTFChars( jTopicName, NULL);
+ std::string topicName(name);
+ OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->unregisterTopic(
+ topicName);
+ if (result != OIC::Service::NSResult::OK)
+ {
+ LOGE("Fail to Unregister Topic");
+ }
+ env->ReleaseStringUTFChars(jTopicName, name);
+ LOGD("JNIProviderService: nativeUnregisterTopic - OUT");
+ return (jint) result;
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_iotivity_service_ns_provider_ProviderService_nativeGetRegisteredTopicList
+(JNIEnv *env, jobject jObj)
+{
+ LOGD("JNIProviderService: nativeGetRegisteredTopicList - IN");
+
+ OIC::Service::NSTopicsList *topicList =
+ OIC::Service::NSProviderService::getInstance()->getRegisteredTopicList();
+ if (topicList == nullptr)
+ {
+ ThrowNSException(NS_ERROR, "Topic List doesn't exist");
+ return NULL;
+ }
+
+ jobject obj_topicList = getJavaTopicsList(env, topicList);
- jclass consumerClass = env->GetObjectClass( jConsumer);
- if (!consumerClass)
+ LOGD("JNIProviderService: nativeGetRegisteredTopicList - OUT");
+ return obj_topicList;
+}
+
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription
+(JNIEnv *env, jobject jObj, jstring jConsumerId, jboolean jAccepted)
+{
+ LOGD("JNIProviderService: nativeAcceptSubscription - IN");
+ if (!jConsumerId)
{
- ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Consumer");
+ ThrowNSException(NS_ERROR, "ConsumerId Can't be NULL");
return (jint) OIC::Service::NSResult::ERROR;
}
+ const char *id = env->GetStringUTFChars( jConsumerId, NULL);
+ std::string consumerId(id);
+ LOGD("Consumer ID: %s\n", consumerId.c_str());
- // Consumer ID
- jfieldID fid_id = env->GetFieldID(consumerClass, "mConsumerId", "Ljava/lang/String;");
- if (fid_id == NULL)
+ OIC::Service::NSConsumer *consumer =
+ OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
+ if (consumer)
+ return (jint) consumer->acceptSubscription((bool)jAccepted);
+
+ LOGE("Couldn't find consumer");
+ LOGD("JNIProviderService: nativeAcceptSubscription - OUT");
+ return (jint) OIC::Service::NSResult::ERROR;
+}
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeSetConsumerTopic
+(JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
+{
+ LOGD("JNIProviderService: nativeSetConsumerTopic - IN");
+ if (!jConsumerId || !jTopicName)
{
- LOGE("Error: jfieldID for mConsumerId is null");
- ThrowNSException(NS_ERROR, "ConsumerId not found");
+ ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
return (jint) OIC::Service::NSResult::ERROR;
}
+ const char *name = env->GetStringUTFChars( jTopicName, NULL);
+ const char *id = env->GetStringUTFChars( jConsumerId, NULL);
+ std::string topicName(name);
+ std::string consumerId(id);
+ OIC::Service::NSConsumer *nsConsumer =
+ OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
+ if (!nsConsumer)
+ {
+ ThrowNSException(NS_ERROR, "Consumer does exists");
+ return (jint) OIC::Service::NSResult::ERROR;
+ }
+ OIC::Service::NSResult result = nsConsumer->setTopic(topicName);
- jstring jconId = (jstring)env->GetObjectField( jConsumer, fid_id);
- const char *conId = "";
- if (conId)
+ if (result != OIC::Service::NSResult::OK)
{
- conId = env->GetStringUTFChars( jconId, NULL);
+ LOGD("Fail to Select Topic");
}
- else
+ env->ReleaseStringUTFChars(jTopicName, name);
+ env->ReleaseStringUTFChars(jConsumerId, id);
+ LOGD("JNIProviderService: nativeSetConsumerTopic - OUT");
+ return (jint) result;
+}
+JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeUnsetConsumerTopic
+(JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
+{
+ LOGD("JNIProviderService: nativeUnsetConsumerTopic - IN");
+ if (!jConsumerId || !jTopicName)
{
- LOGI("Info: Consumer Id is null");
+ ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
+ return (jint) OIC::Service::NSResult::ERROR;
+ }
+ const char *name = env->GetStringUTFChars( jTopicName, NULL);
+ const char *id = env->GetStringUTFChars( jConsumerId, NULL);
+ std::string topicName(name);
+ std::string consumerId(id);
+ OIC::Service::NSConsumer *nsConsumer =
+ OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
+ if (!nsConsumer)
+ {
+ ThrowNSException(NS_ERROR, "Consumer does exists");
+ return (jint) OIC::Service::NSResult::ERROR;
}
- std::string consumerId(conId);
- env->ReleaseStringUTFChars(jconId, conId);
+ OIC::Service::NSResult result = nsConsumer->unsetTopic(topicName);
- LOGI("Consumer ID: %s\n", consumerId.c_str());
+ if (result != OIC::Service::NSResult::OK)
+ {
+ LOGE("Fail to Unselect Topic");
+ }
+ env->ReleaseStringUTFChars(jTopicName, name);
+ env->ReleaseStringUTFChars(jConsumerId, id);
+ LOGD("JNIProviderService: nativeUnsetConsumerTopic - OUT");
+ return (jint) result;
+}
- OIC::Service::NSConsumer *consumer = new OIC::Service::NSConsumer(consumerId);
- int result = consumer->acceptSubscription(consumer, (bool)jAccepted);
- if (jAccepted)
+JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeGetConsumerTopicList
+(JNIEnv *env, jobject jObj, jstring jConsumerId)
+{
+ LOGD("JNIProviderService: nativeGetConsumerTopicList - IN");
+ if (!jConsumerId)
{
- LOGI("Subscription Accepted");
+ ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
+ return NULL;
}
- else
+ const char *id = env->GetStringUTFChars( jConsumerId, NULL);
+ std::string consumerId(id);
+ OIC::Service::NSConsumer *nsConsumer =
+ OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
+ if (!nsConsumer)
{
- LOGI("Subscription Denied");
+ ThrowNSException(NS_ERROR, "Consumer does exists");
+ return NULL;
}
-
- LOGD("JNIProviderService: nativeAcceptSubscription - OUT");
- return result;
+ env->ReleaseStringUTFChars(jConsumerId, id);
+ OIC::Service::NSTopicsList *topicList = nsConsumer->getConsumerTopicList();
+ if (topicList == nullptr)
+ {
+ ThrowNSException(NS_ERROR, "Topic List doesn't exist");
+ return NULL;
+ }
+ jobject obj_topicList = getJavaTopicsList(env, topicList);
+ LOGD("JNIProviderService: nativeGetConsumerTopicList - OUT");
+ return obj_topicList;
}
// JNI OnLoad
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
{
LOGD("ProviderService_JNI_OnLoad");
- g_jvm = jvm;
+ g_jvm_provider = jvm;
JNIEnv *env;
if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
return JNI_ERR;
}
+ jclass localTopic = env->FindClass(
+ "org/iotivity/service/ns/common/Topic");
+ if (!localTopic)
+ {
+ LOGE("Failed to get local Topic class");
+ return JNI_ERR;
+ }
+ g_cls_Topic = (jclass) (env->NewGlobalRef(localTopic));
+ if (!g_cls_Topic)
+ {
+ LOGE("Failed to set Global Topic reference");
+ return JNI_ERR;
+ }
+
+ jclass localTopicsList = env->FindClass(
+ "org/iotivity/service/ns/common/TopicsList");
+ if (!localTopicsList)
+ {
+ LOGE("Failed to get local Topic class");
+ return JNI_ERR;
+ }
+ g_cls_TopicsList = (jclass) (env->NewGlobalRef(localTopicsList));
+ if (!g_cls_TopicsList)
+ {
+ LOGE("Failed to set Global TopicsList reference");
+ return JNI_ERR;
+ }
+
+ jclass localTopicState = env->FindClass(
+ "org/iotivity/service/ns/common/Topic$TopicState");
+ if (!localTopicState)
+ {
+ LOGE("Failed to get local TopicState enum");
+ return JNI_ERR;
+ }
+ g_cls_TopicState = (jclass) (env->NewGlobalRef(localTopicState));
+ if (!g_cls_TopicState)
+ {
+ LOGE("Failed to set Global TopicState reference");
+ return JNI_ERR;
+ }
+
+ //OcRepresentation
+ jclass localOcRepresentation = env->FindClass("org/iotivity/base/OcRepresentation");
+ if (!localOcRepresentation)
+ {
+ LOGE("Failed to get local OcRepresentation class");
+ return JNI_ERR;
+ }
+ g_cls_OcRepresentation = (jclass) env->NewGlobalRef(localOcRepresentation);
+ if (!g_cls_OcRepresentation)
+ {
+ LOGE("Failed to set Global OcRepresentation reference");
+ return JNI_ERR;
+ }
+
+ g_mid_OcRepresentation_N_ctor_bool = env->GetMethodID(g_cls_OcRepresentation, "<init>", "(JZ)V");
+ if (!g_mid_OcRepresentation_N_ctor_bool)
+ {
+ LOGE("Failed to get Global OcRepresentation Constructor reference");
+ return JNI_ERR;
+ }
+
env->DeleteLocalRef(localMessage);
env->DeleteLocalRef(localMessageType);
env->DeleteLocalRef(localConsumer);
env->DeleteLocalRef(localSyncInfo);
env->DeleteLocalRef(localSyncType);
env->DeleteLocalRef(localMediaContents);
+ env->DeleteLocalRef(localTopic);
+ env->DeleteLocalRef(localTopicsList);
+ env->DeleteLocalRef(localTopicState);
+ env->DeleteLocalRef(localOcRepresentation);
return NSExceptionInit(env);
}
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)
{
- LOGI("ProviderService_JNI_OnUnload");
+ LOGD("ProviderService_JNI_OnUnload");
JNIEnv *env;
if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
env->DeleteGlobalRef(g_cls_SyncType);
env->DeleteGlobalRef(g_cls_MediaContents);
env->DeleteGlobalRef(g_cls_Message_Type);
+ env->DeleteGlobalRef(g_cls_Topic);
+ env->DeleteGlobalRef(g_cls_TopicsList);
+ env->DeleteGlobalRef(g_cls_TopicState);
+ env->DeleteGlobalRef(g_cls_OcRepresentation);
}
projects / platform / upstream / iotivity.git / blobdiff