#include "JniNotificationProvider.h"
#include "NSProviderService.h"
+#include "NSException.h"
#include "JniOcRepresentation.h"
static JavaVM *g_jvm_provider = NULL;
case JNI_EDETACHED:
if (g_jvm_provider->AttachCurrentThread(&env, NULL) != JNI_OK)
{
- LOGE ("Failed to get the environment");
+ NS_LOGE ("Failed to get the environment");
return NULL;
}
else
return env;
}
case JNI_EVERSION:
- LOGE ("JNI version is not supported");
+ NS_LOGE ("JNI version is not supported");
+ return NULL;
default:
- LOGE ("Failed to get the environment");
+ NS_LOGE ("Failed to get the environment");
return NULL;
}
}
-OIC::Service::NSMessage *getNativeMessage(JNIEnv *env, jobject jMsg)
+OIC::Service::NSMessage getNativeMessage(JNIEnv *env, jobject jMsg)
{
- LOGD("JNIProviderService: getMessage - IN");
+ NS_LOGD ("JNIProviderService: getMessage - IN");
jclass cls = env->GetObjectClass( jMsg);
jclass cls_messageType = (jclass) (env->NewLocalRef(g_cls_Message_Type));
if (!cls_messageType)
{
- LOGE ("Failed to Get ObjectClass for Message Type");
+ ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Message Type");
return nullptr;
}
jmethodID mid = env->GetMethodID(cls_messageType, "ordinal", "()I");
"Lorg/iotivity/service/ns/common/Message$MessageType;");
if (fid_type == NULL)
{
- LOGE("Error: jfieldID for message type is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message type is null");
return nullptr;
}
jobject jobj = env->GetObjectField( jMsg, fid_type);
if (jobj == NULL)
{
- LOGE("Error: object of field Message Type is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: object of field Message Type is null");
return nullptr;
}
jint jtype = env->CallIntMethod(jobj, mid);
OIC::Service::NSMessage::NSMessageType type = (OIC::Service::NSMessage::NSMessageType) jtype;
- LOGD("Message Type: %ld\n", (long )type);
+ NS_LOGD ("Message Type: %ld\n", (long )type);
// Message Time
jfieldID fid_tm = env->GetFieldID( cls, "mTime", "Ljava/lang/String;");
if (fid_tm == NULL)
{
- LOGE("Error: jfieldID for message time is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message time is null");
return nullptr;
}
jstring jtime = (jstring)env->GetObjectField( jMsg, fid_tm);
}
else
{
- LOGD("Info: messageTitle is null");
+ NS_LOGD ("Info: messageTitle is null");
}
- LOGD("Message Time: %s\n", time);
+ NS_LOGD ("Message Time: %s\n", time);
// Message TTL
jfieldID fid_ttl = env->GetFieldID( cls, "mTTL", "J");
if (fid_ttl == NULL)
{
- LOGE("Error: jfieldID for message ttl is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message ttl is null");
return nullptr;
}
jlong jttl = (jlong) env->GetLongField( jMsg, fid_ttl);
uint64_t ttl = jttl;
- LOGD("TTL: %d\n", ttl);
+ NS_LOGD ("TTL: %lld\n", ttl);
// Message Title
jfieldID fid_title = env->GetFieldID( cls, "mTitle", "Ljava/lang/String;");
if (fid_title == NULL)
{
- LOGE("Error: jfieldID for message title is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message title is null");
return nullptr;
}
jstring jmsgTitle = (jstring)env->GetObjectField( jMsg, fid_title);
}
else
{
- LOGD("Info: messageTitle is null");
+ NS_LOGD ("Info: messageTitle is null");
}
- LOGD("Message Title: %s\n", messageTitle);
+ NS_LOGD ("Message Title: %s\n", messageTitle);
// Message Content Text
jfieldID fid_body = env->GetFieldID( cls, "mContentText", "Ljava/lang/String;");
if (fid_body == NULL)
{
- LOGE("Error: jfieldID for message context Text is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message context Text is null");
return nullptr;
}
jstring jmsgBody = (jstring)env->GetObjectField( jMsg, fid_body);
}
else
{
- LOGD("Info: messageBody is null");
+ NS_LOGD ("Info: messageBody is null");
}
- LOGD("Message Body: %s\n", messageBody);
+ NS_LOGD ("Message Body: %s\n", messageBody);
// Message Source
jfieldID fid_source = env->GetFieldID( cls, "mSourceName", "Ljava/lang/String;");
if (fid_source == NULL)
{
- LOGE("Error: jfieldID for message source is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message source is null");
return nullptr;
}
jstring jmsgSource = (jstring)env->GetObjectField( jMsg, fid_source);
}
else
{
- LOGD("Info: messageSource is null");
+ NS_LOGD ("Info: messageSource is null");
}
- LOGD("Message Source: %s\n", messageSource);
+ NS_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");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for topic is null");
return nullptr;
}
jstring jtopic = (jstring)env->GetObjectField( jMsg, fid_topic);
}
else
{
- LOGD("Info: topic is null");
+ NS_LOGD ("Info: topic is null");
}
- LOGD("Topic : %s\n", topic);
+ NS_LOGD ("Topic : %s\n", topic);
// Message MediaContents
jfieldID fid_media = env->GetFieldID( cls, "mMediaContents",
"Lorg/iotivity/service/ns/common/MediaContents;");
if (fid_media == NULL)
{
- LOGE("Error: jfieldID for MediaContents is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for MediaContents is null");
return nullptr;
}
jobject jmedia = env->GetObjectField( jMsg, fid_media);
OIC::Service::NSMediaContents *media = nullptr;
if (jmedia == NULL)
{
- LOGD("Info: jmedia object of MediaContents inside Message is null");
+ NS_LOGD ("Info: jmedia object of MediaContents inside Message is null");
}
else
{
jclass cls_MediaContents = (jclass) (env->NewLocalRef(g_cls_MediaContents));
if (!cls_MediaContents)
{
- LOGE ("Failed to Get ObjectClass for class MediaContents");
+ ThrowNSException(JNI_INVALID_VALUE, "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");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for iconImage is null");
return nullptr;
}
jstring jiconImage = (jstring)env->GetObjectField( jmedia, fid_icon);
}
else
{
- LOGD("Info: iconImage is null");
+ NS_LOGD ("Info: iconImage is null");
}
env->DeleteLocalRef(cls_MediaContents);
- LOGD("iconImage: %s\n", iconImage);
+ NS_LOGD ("iconImage: %s\n", iconImage);
}
// Message ExtraInfo
"Lorg/iotivity/base/OcRepresentation;");
if (fid_extraInfo == NULL)
{
- LOGE("Error: jfieldID for mExtraInfo is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for mExtraInfo is null");
return nullptr;
}
jobject jExtraInfo = env->GetObjectField( jMsg, fid_extraInfo);
OC::OCRepresentation *representation = nullptr;
if (jExtraInfo == NULL)
{
- LOGE("Error: jExtraInfo object of Message is null");
+ NS_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");
+ NS_LOGE ("Failed to get native handle from OcRepresentation");
}
if (!representation)
{
- LOGE("Failed to get native object OcRepresentation");
+ NS_LOGE ("Failed to get native object OcRepresentation");
}
}
- OIC::Service::NSMessage *nsMsg;
- jfieldID nativeHandle = env->GetFieldID(cls, "mNativeHandle", "J");
- if (!nativeHandle)
+ // Message Id
+ jfieldID fid_mid = env->GetFieldID( cls, "mMessageId", "J");
+ if (fid_mid == NULL)
+ {
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message mMessageId is null");
+ return nullptr;
+ }
+
+ jlong jId = (jlong) env->GetLongField( jMsg, fid_mid);
+ uint64_t jmId = jId;
+ NS_LOGD ("Message Id: %lld\n", jmId);
+
+ // Provider Id
+ jfieldID fid_pid = env->GetFieldID( cls, "mProviderId", "Ljava/lang/String;");
+ if (fid_pid == NULL)
{
- LOGE("Error: fieldID for mNativeHandle is null");
+ ThrowNSException(JNI_INVALID_VALUE, "Error: jfieldID for message mProviderId is null");
return nullptr;
}
- jlong jMessage = env->GetLongField(jMsg, nativeHandle);
- if (jMessage)
+ jstring jProId = (jstring)env->GetObjectField( jMsg, fid_pid);
+ const char *jpId = "";
+ if (jProId)
{
- LOGD ("calling sendMessage on mNativeHandle");
- nsMsg = (OIC::Service::NSMessage *) (jMessage);
+ jpId = env->GetStringUTFChars( jProId, NULL);
}
else
{
- nsMsg = OIC::Service::NSProviderService::getInstance()->createMessage();
+ NS_LOGD ("Info: messageSource is null");
}
+ NS_LOGD ("Provider Id : %s\n", jpId);
+
+
+ NSMessage *mesg = new NSMessage;
+ mesg->messageId = jmId;
+ mesg->providerId[0] = '\0';
+ strncat(mesg->providerId, jpId, NS_UTILS_UUID_STRING_SIZE - 1);
+
+ mesg->dateTime = nullptr;
+ mesg->title = nullptr;
+ mesg->contentText = nullptr;
+ mesg->sourceName = nullptr;
+ mesg->mediaContents = nullptr;
+ mesg->topic = nullptr;
+ mesg->extraInfo = nullptr;
+
+ OIC::Service::NSMessage nsMsg(mesg);
+ NS_LOGD ("Created NSMessage");
- 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));
- if(media != nullptr)
+ 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));
+ if (media != nullptr)
{
- nsMsg->setMediaContents(media);
+ nsMsg.setMediaContents(media);
}
- nsMsg->setTopic(std::string(topic));
+ nsMsg.setTopic(std::string(topic));
if (representation != nullptr)
{
- nsMsg->setExtraInfo(*representation);
+ nsMsg.setExtraInfo(*representation);
}
env->DeleteLocalRef(cls_messageType);
{
env->ReleaseStringUTFChars(jtopic, topic);
}
-
- LOGD("JNIProviderService: getMessage - OUT");
+ delete mesg;
+ NS_LOGD ("JNIProviderService: getMessage - OUT");
return nsMsg;
}
jobject getJavaMessageType(JNIEnv *env, OIC::Service::NSMessage::NSMessageType type)
{
- LOGD ("JNIProviderService: getJavaMessageType - IN");
+ NS_LOGD ("JNIProviderService: getJavaMessageType - IN");
+ jobject messageType = NULL;
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);
+ messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ break;
}
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);
+ messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ break;
}
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);
+ messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ break;
}
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);
+ messageType = env->GetStaticObjectField(g_cls_Message_Type, fieldID);
+ break;
}
default:
- return NULL;
+ {
+ messageType = NULL;
+ break;
+ }
}
- LOGD ("JNIProviderService: getJavaMessageType - OUT");
- return NULL;
+ NS_LOGD ("JNIProviderService: getJavaMessageType - OUT");
+ return messageType;
}
-jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message)
+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());
+ NS_LOGD ("JNIProviderService: getJavaMessage - IN");
- 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());
+ NS_LOGD ("id : %llu\n", message.getMessageId());
+ NS_LOGD ("title : %s\n", message.getTitle().c_str());
+ NS_LOGD ("content : %s\n", message.getContentText().c_str());
+ NS_LOGD ("source : %s\n", message.getSourceName().c_str());
- jstring jTime = env->NewStringUTF(message->getTime().c_str());
- jlong jTTL = (jlong) message->getTTL();
+ 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());
- jlong pMessage = (long) message;
+ jstring jTime = env->NewStringUTF(message.getTime().c_str());
+ jlong jTTL = (jlong) message.getTTL();
jclass cls_message = (jclass) (env->NewLocalRef(g_cls_Message));
if (!cls_message)
{
- LOGE ("Failed to Get ObjectClass for Message");
+ NS_LOGE ("Failed to Get ObjectClass for Message");
return NULL ;
}
jmethodID mid_message = env->GetMethodID(
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
if (!mid_message)
{
- LOGE ("Failed to Get MethodID for Message<init>");
+ NS_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");
+ NS_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");
+ NS_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");
+ NS_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");
+ NS_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");
+ NS_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");
+ NS_LOGE ("Failed to get mTopic for Message");
return NULL;
}
env->SetObjectField(obj_message, fid_topic, jTopic);
- OIC::Service::NSMediaContents *mediaCont = message->getMediaContents();
+ 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");
+ NS_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>");
+ NS_LOGE ("Failed to Get MethodID for MediaContents<init>");
return NULL;
}
jobject obj_mediaContents = env->NewObject(cls_mediaContents, mid_mediaContents,
"Lorg/iotivity/service/ns/common/MediaContents;");
if (!fid_mediaContents)
{
- LOGE("Failed to get field mediaContents for Message");
+ NS_LOGE ("Failed to get field mediaContents for Message");
return NULL;
}
env->SetObjectField(obj_message, fid_mediaContents, obj_mediaContents);
}
- jobject jType = getJavaMessageType(env, message->getType());
+ 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");
+ NS_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());
+ NS_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");
+ NS_LOGE ("Failed to create OcRepresentation");
delete ocRepresentation;
}
else
{
- LOGD("Created OCRepresentation Object from Native");
+ NS_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");
+ NS_LOGE ("Failed to get mExtraInfo for Message");
delete ocRepresentation;
return NULL;
}
- LOGD ("setting extraInfo field");
+ NS_LOGD ("setting extraInfo field");
env->SetObjectField(obj_message, fid_extraInfo, jRepresentation);
env->DeleteLocalRef(cls_message);
- LOGD ("JNIProviderService: getJavaMessage - OUT");
+ NS_LOGD ("JNIProviderService: getJavaMessage - OUT");
return obj_message;
}
jobject getJavaTopicState(JNIEnv *env, OIC::Service::NSTopic::NSTopicState nsState)
{
- LOGD("JNIProviderService: getJavaTopicState - IN");
+ NS_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");
+ NS_LOGE ("Failed to Get ObjectClass for TopicState Type");
return NULL;
}
+ jobject topicState = NULL;
switch (nsState)
{
{
static jfieldID fieldID = env->GetStaticFieldID(cls_topicState,
"UNSUBSCRIBED", "Lorg/iotivity/service/ns/common/Topic$TopicState;");
- return env->GetStaticObjectField(cls_topicState, fieldID);
+ topicState = env->GetStaticObjectField(cls_topicState, fieldID);
+ break;
}
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);
+ topicState = env->GetStaticObjectField(cls_topicState, fieldID);
+ break;
}
default:
- return NULL;
-
+ {
+ topicState = NULL;
+ break;
+ }
}
- LOGD("JNIProviderService: getJavaTopicState - OUT");
- return NULL;
+ NS_LOGD ("JNIProviderService: getJavaTopicState - OUT");
+ return topicState;
}
-jobject getJavaTopicsList(JNIEnv *env, OIC::Service::NSTopicsList *topicList)
+jobject getJavaTopicsList(JNIEnv *env, std::shared_ptr<OIC::Service::NSTopicsList> topicList)
{
- LOGD("JNIProviderService: getJavaTopicsList - IN");
+ NS_LOGD ("JNIProviderService: getJavaTopicsList - IN");
jclass cls_topicList = (jclass) (env->NewLocalRef(g_cls_TopicsList));
if (!cls_topicList)
{
- LOGE ("Failed to Get ObjectClass for TopicsList");
+ NS_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>");
+ NS_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");
+ NS_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");
+ NS_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();
+ 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");
+ NS_LOGD ("JNIProviderService: getJavaTopicsList - OUT");
return obj_topicList;
}
jobject getJavaSyncType(JNIEnv *env, OIC::Service::NSSyncInfo::NSSyncType nsType)
{
- LOGD ("JNIProviderService: getJavaSyncType - IN");
+ NS_LOGD ("JNIProviderService: getJavaSyncType - IN");
// SyncType
jclass cls_SyncType = (jclass) (env->NewLocalRef(g_cls_SyncType));
if (!cls_SyncType)
{
- LOGE ("Failed to Get ObjectClass for SyncType");
+ NS_LOGE ("Failed to Get ObjectClass for SyncType");
return NULL;
}
+ jobject syncType = 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);
+ syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
+ break;
}
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);
+ syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
+ break;
}
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);
+ syncType = env->GetStaticObjectField(cls_SyncType, fieldID);
+ break;
}
default:
- return NULL;
+ {
+ syncType = NULL;
+ break;
+ }
}
- LOGD ("JNIProviderService: getJavaSyncType - OUT");
- return NULL;
+ NS_LOGD ("JNIProviderService: getJavaSyncType - OUT");
+ return syncType;
}
-void onSubscribeListenerCb(OIC::Service::NSConsumer *consumer)
+void onSubscribeListenerCb(std::shared_ptr<OIC::Service::NSConsumer> consumer)
{
- LOGD("JNIProviderService_onSubscribeListenerCb - IN");
+ NS_LOGD ("JNIProviderService_onSubscribeListenerCb - IN");
- jint envRet;
+ jint envRet = 0;;
JNIEnv *env = GetJNIEnv(&envRet);
- if (NULL == env) return ;
+ 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();
+ NS_LOGE ("Failed to Get jSubscriptionListener");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
return ;
}
- LOGD("consumer ID : %s\n", consumer->getConsumerId().c_str());
+ NS_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();
+ NS_LOGE ("Failed to Get ObjectClass for Consumer");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
return ;
}
"(Ljava/lang/String;)V");
if (!mid_consumer)
{
- LOGE ("Failed to Get MethodID for Consumer<init>");
- if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ NS_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();
+ NS_LOGE ("Failed to Get ObjectClass of jSubscriptionListener");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
return;
}
jmethodID mid = env->GetMethodID(
"(Lorg/iotivity/service/ns/provider/Consumer;)V");
if (!mid)
{
- LOGE("Failed to Get MethodID of onConsumerSubscribed");
- if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ NS_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");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
+ NS_LOGD ("JNIProviderService_onSubscribeListenerCb - OUT");
return;
}
-void onSyncInfoListenerCb(OIC::Service::NSSyncInfo *sync)
+void onSyncInfoListenerCb(OIC::Service::NSSyncInfo sync)
{
- LOGD("JNIProviderService_onSyncInfoListenerCb - IN");
+ NS_LOGD ("JNIProviderService_onSyncInfoListenerCb - IN");
- jint envRet;
+ jint envRet = 0;;
JNIEnv *env = GetJNIEnv(&envRet);
- if (NULL == env) return ;
+ 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();
+ NS_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());
+ NS_LOGD ("Sync ID : %ld\n", (long) sync.getMessageId());
+ NS_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());
+ 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();
+ NS_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();
+ NS_LOGE ("Failed to Get ObjectClass for SyncInfo");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
return ;
}
jmethodID mid_syncInfo = env->GetMethodID(
"(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();
+ NS_LOGE ("Failed to Get MethodID for SyncInfo");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
return ;
}
jMessageId, jProviderId, syncType);
if (!obj_syncInfo)
{
- LOGE ("Failed to Get Object for SyncInfo");
- if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
+ NS_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;
+ NS_LOGE ("Failed to Get ObjectClass");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
+ return ;
}
jmethodID mid = env->GetMethodID(
cls,
"(Lorg/iotivity/service/ns/common/SyncInfo;)V");
if (!mid)
{
- LOGE("Failed to Get MethodID");
- if (JNI_EDETACHED == envRet) g_jvm_provider->DetachCurrentThread();
- return;
+ NS_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");
+ if (JNI_EDETACHED == envRet)
+ {
+ g_jvm_provider->DetachCurrentThread();
+ }
+ NS_LOGD ("JNIProviderService: OnSyncInfoListenerCb - OUT");
return;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStart
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStart
(JNIEnv *env, jobject jObj, jobject jSubscriptionListener, jobject jSyncListener,
jboolean jPolicy, jstring jUserInfo, jboolean jResourceSecurity)
{
- LOGD("JNIProviderService: nativeStart - IN");
+ NS_LOGD ("JNIProviderService: nativeStart - IN");
if (!jSubscriptionListener || !jSyncListener)
{
- LOGE("Fail to set listeners");
- ThrowNSException(NS_ERROR, "Listener cannot be null");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Listener cannot be null");
+ return;
}
if (g_obj_subscriptionListener != NULL)
OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->start(cfg);
if (result != OIC::Service::NSResult::OK)
{
- LOGE("Fail to start NSProviderService");
-
+ ThrowNSException((int) result, "Fail to start NSProviderService");
+ return;
}
- LOGD("JNIProviderService: nativeStart - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeStart - OUT");
+ return;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeStop
(JNIEnv *env, jobject jObj)
{
- LOGD("JNIProviderService: nativeStop - IN");
+ NS_LOGD ("JNIProviderService: nativeStop - IN");
OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->stop();
if (result != OIC::Service::NSResult::OK)
{
- LOGD("Fail to stop NSProvider service");
- return (jint) result;
+ ThrowNSException((int) result, "Fail to stop NSProviderService");
+ return;
}
env->DeleteGlobalRef( g_obj_subscriptionListener);
g_obj_subscriptionListener = NULL;
g_obj_syncListener = NULL;
- LOGD("JNIProviderService: nativeStop - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeStop - OUT");
+ return;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendMessage
(JNIEnv *env, jobject jObj, jobject jMsg)
{
- LOGD("JNIProviderService: nativeSendMessage - IN");
+ NS_LOGD ("JNIProviderService: nativeSendMessage - IN");
if (!jMsg)
{
- 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 = getNativeMessage(env, jMsg);
- if (nsMsg == nullptr)
- {
- ThrowNSException(NS_ERROR, "Message didn't have a field ID ");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Message cannot be null");
+ return;
}
+ OIC::Service::NSMessage nsMsg = getNativeMessage(env, jMsg);
OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->sendMessage(nsMsg);
if (result != OIC::Service::NSResult::OK)
{
- LOGD("Fail to send NSProvider Message");
+ ThrowNSException((int) result, "Fail to send NSProvider Message");
+ return;
}
- LOGD("JNIProviderService: nativeSendMessage - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeSendMessage - OUT");
+ return;
}
JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeSendSyncInfo
(JNIEnv *env, jobject jObj, jlong messageId , jint syncState)
{
- LOGD("JNIProviderService: nativeSendSyncInfo - IN");
- OIC::Service::NSProviderService::getInstance()->sendSyncInfo( messageId,
- (OIC::Service::NSSyncInfo::NSSyncType) syncState);
- LOGD("JNIProviderService: nativeSendSyncInfo - OUT");
+ NS_LOGD ("JNIProviderService: nativeSendSyncInfo - IN");
+ OIC::Service::NSResult result = OIC::Service::NSProviderService::getInstance()->sendSyncInfo(
+ messageId,
+ (OIC::Service::NSSyncInfo::NSSyncType) syncState);
+ if (result != OIC::Service::NSResult::OK)
+ {
+ ThrowNSException((int) result, "Fail to send NSProvider SendSyncInfo");
+ return;
+ }
+ NS_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 =
+ NS_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");
+ ThrowNSException(JNI_INVALID_VALUE, "Couldn't create Java Message");
return NULL;
}
- LOGD("JNIProviderService: nativeCreateMessage - OUT");
+ NS_LOGD ("JNIProviderService: nativeCreateMessage - OUT");
return jMsg;
}
-JNIEXPORT jint JNICALL
+JNIEXPORT void JNICALL
Java_org_iotivity_service_ns_provider_ProviderService_nativeEnableRemoteService
(JNIEnv *env, jobject jObj, jstring jstr)
{
- LOGD("JNIProviderService: nativeEnableRemoteService - IN");
+ NS_LOGD ("JNIProviderService: nativeEnableRemoteService - IN");
if (!jstr)
{
- ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Server Address Can't be NULL");
+ return;
}
const char *address = env->GetStringUTFChars( jstr, NULL);
servAddress);
if (result != OIC::Service::NSResult::OK)
{
- LOGE("Fail to Enable Remote Service");
+ ThrowNSException((int) result, "Fail to Enable Remote Service");
+ return;
}
env->ReleaseStringUTFChars(jstr, address);
- LOGD("JNIProviderService: nativeEnableRemoteService - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeEnableRemoteService - OUT");
+ return;
}
-JNIEXPORT jint JNICALL
+JNIEXPORT void JNICALL
Java_org_iotivity_service_ns_provider_ProviderService_nativeDisableRemoteService
(JNIEnv *env, jobject jObj, jstring jstr)
{
- LOGD("JNIProviderService: nativeDisableRemoteService - IN");
+ NS_LOGD ("JNIProviderService: nativeDisableRemoteService - IN");
if (!jstr)
{
- ThrowNSException(NS_ERROR, "Server Address Can't be NULL");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Server Address Can't be NULL");
+ return;
}
const char *address = env->GetStringUTFChars( jstr, NULL);
servAddress);
if (result != OIC::Service::NSResult::OK)
{
- LOGE("Fail to Disable Remote Service");
+ ThrowNSException((int) result, "Fail to Disable Remote Service");
+ return;
}
env->ReleaseStringUTFChars(jstr, address);
- LOGD("JNIProviderService: nativeDisableRemoteService - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeDisableRemoteService - OUT");
+ return;
+}
+
+JNIEXPORT void JNICALL
+Java_org_iotivity_service_ns_provider_ProviderService_nativeSubscribeMQService
+(JNIEnv *env, jobject jObj, jstring jserverAddress, jstring jTopicName)
+{
+ NS_LOGD ("JNIProviderService: nativeSubscribeMQService - IN");
+ if (!jserverAddress)
+ {
+ ThrowNSException(JNI_INVALID_VALUE, "Server Address Can't be NULL");
+ return;
+ }
+ if (!jTopicName)
+ {
+ ThrowNSException(JNI_INVALID_VALUE, "TopicName Can't be NULL");
+ return;
+ }
+
+ const char *address = env->GetStringUTFChars( jserverAddress, NULL);
+ std::string servAddress(address);
+ const char *topic = env->GetStringUTFChars( jTopicName, NULL);
+ std::string topicName(topic);
+
+ OIC::Service::NSResult result =
+ OIC::Service::NSProviderService::getInstance()->subscribeMQService(
+ servAddress, topicName);
+ if (result != OIC::Service::NSResult::OK)
+ {
+ ThrowNSException((int) result, "Fail to Subscribe to MQ Service");
+ return;
+ }
+ env->ReleaseStringUTFChars(jserverAddress, address);
+ env->ReleaseStringUTFChars(jTopicName, topic);
+ NS_LOGD ("JNIProviderService: nativeSubscribeMQService - OUT");
+ return;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeRegisterTopic
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeRegisterTopic
(JNIEnv *env, jobject jObj, jstring jTopicName)
{
- LOGD("JNIProviderService: nativeRegisterTopic - IN");
+ NS_LOGD ("JNIProviderService: nativeRegisterTopic - IN");
if (!jTopicName)
{
- ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Topic Name Can't be NULL");
+ return;
}
const char *name = env->GetStringUTFChars( jTopicName, NULL);
std::string topicName(name);
topicName);
if (result != OIC::Service::NSResult::OK)
{
- LOGE("Fail to Register Topic");
+ ThrowNSException((int) result, "Fail to Register Topic");
+ return;
}
env->ReleaseStringUTFChars(jTopicName, name);
- LOGD("JNIProviderService: nativeRegisterTopic - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeRegisterTopic - OUT");
+ return;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeUnregisterTopic
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_ProviderService_nativeUnregisterTopic
(JNIEnv *env, jobject jObj, jstring jTopicName)
{
- LOGD("JNIProviderService: nativeUnregisterTopic - IN");
+ NS_LOGD ("JNIProviderService: nativeUnregisterTopic - IN");
if (!jTopicName)
{
- ThrowNSException(NS_ERROR, "Topic Name Can't be NULL");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Topic Name Can't be NULL");
+ return;
}
const char *name = env->GetStringUTFChars( jTopicName, NULL);
std::string topicName(name);
topicName);
if (result != OIC::Service::NSResult::OK)
{
- LOGE("Fail to Unregister Topic");
+ ThrowNSException((int) result, "Fail to Unregister Topic");
+ return;
}
env->ReleaseStringUTFChars(jTopicName, name);
- LOGD("JNIProviderService: nativeUnregisterTopic - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeUnregisterTopic - OUT");
+ return;
}
JNIEXPORT jobject JNICALL
Java_org_iotivity_service_ns_provider_ProviderService_nativeGetRegisteredTopicList
(JNIEnv *env, jobject jObj)
{
- LOGD("JNIProviderService: nativeGetRegisteredTopicList - IN");
+ NS_LOGD ("JNIProviderService: nativeGetRegisteredTopicList - IN");
- OIC::Service::NSTopicsList *topicList =
+ std::shared_ptr<OIC::Service::NSTopicsList> topicList =
OIC::Service::NSProviderService::getInstance()->getRegisteredTopicList();
if (topicList == nullptr)
{
- ThrowNSException(NS_ERROR, "Topic List doesn't exist");
+ ThrowNSException(JNI_INVALID_VALUE, "Topic List doesn't exist");
return NULL;
}
jobject obj_topicList = getJavaTopicsList(env, topicList);
- LOGD("JNIProviderService: nativeGetRegisteredTopicList - OUT");
+ NS_LOGD ("JNIProviderService: nativeGetRegisteredTopicList - OUT");
return obj_topicList;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeAcceptSubscription
(JNIEnv *env, jobject jObj, jstring jConsumerId, jboolean jAccepted)
{
- LOGD("JNIProviderService: nativeAcceptSubscription - IN");
+ NS_LOGD ("JNIProviderService: nativeAcceptSubscription - IN");
if (!jConsumerId)
{
- ThrowNSException(NS_ERROR, "ConsumerId Can't be NULL");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "ConsumerId Can't be NULL");
+ return;
}
const char *id = env->GetStringUTFChars( jConsumerId, NULL);
std::string consumerId(id);
- LOGD("Consumer ID: %s\n", consumerId.c_str());
+ NS_LOGD ("Consumer ID: %s\n", consumerId.c_str());
- OIC::Service::NSConsumer *consumer =
+ std::shared_ptr<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;
+ {
+ OIC::Service::NSResult result = OIC::Service::NSResult::ERROR;
+ try
+ {
+ result = consumer->acceptSubscription((bool)jAccepted);
+ }
+ catch (OIC::Service::NSException ex)
+ {
+ ThrowNSException(NATIVE_EXCEPTION, ex.what());
+ return;
+ }
+ if (result != OIC::Service::NSResult::OK)
+ {
+ ThrowNSException((int) result, "Fail to acceptSubscription");
+ return;
+ }
+ }
+ else
+ {
+ NS_LOGE ("Couldn't find consumer");
+ ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native consumer");
+ }
+ return;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeSetConsumerTopic
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeSetConsumerTopic
(JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
{
- LOGD("JNIProviderService: nativeSetConsumerTopic - IN");
+ NS_LOGD ("JNIProviderService: nativeSetConsumerTopic - IN");
if (!jConsumerId || !jTopicName)
{
- ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Topic Name or ConsumerId Can't be NULL");
+ return;
}
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 =
+ std::shared_ptr<OIC::Service::NSConsumer> nsConsumer =
OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
if (!nsConsumer)
{
- ThrowNSException(NS_ERROR, "Consumer does exists");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_NO_NATIVE_POINTER, "Consumer does exists");
+ return;
+ }
+ OIC::Service::NSResult result = OIC::Service::NSResult::ERROR;
+ try
+ {
+ result = nsConsumer->setTopic(topicName);
+ }
+ catch (OIC::Service::NSException ex)
+ {
+ ThrowNSException(NATIVE_EXCEPTION, ex.what());
+ return;
}
- OIC::Service::NSResult result = nsConsumer->setTopic(topicName);
if (result != OIC::Service::NSResult::OK)
{
- LOGD("Fail to Select Topic");
+ ThrowNSException((int) result, "Fail to Select Topic");
+ return;
}
env->ReleaseStringUTFChars(jTopicName, name);
env->ReleaseStringUTFChars(jConsumerId, id);
- LOGD("JNIProviderService: nativeSetConsumerTopic - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeSetConsumerTopic - OUT");
+ return;
}
-JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeUnsetConsumerTopic
+JNIEXPORT void JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeUnsetConsumerTopic
(JNIEnv *env, jobject jObj, jstring jConsumerId, jstring jTopicName)
{
- LOGD("JNIProviderService: nativeUnsetConsumerTopic - IN");
+ NS_LOGD ("JNIProviderService: nativeUnsetConsumerTopic - IN");
if (!jConsumerId || !jTopicName)
{
- ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_INVALID_VALUE, "Topic Name or ConsumerId Can't be NULL");
+ return;
}
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 =
+ std::shared_ptr<OIC::Service::NSConsumer> nsConsumer =
OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
if (!nsConsumer)
{
- ThrowNSException(NS_ERROR, "Consumer does exists");
- return (jint) OIC::Service::NSResult::ERROR;
+ ThrowNSException(JNI_NO_NATIVE_POINTER, "Consumer does exists");
+ return;
+ }
+ OIC::Service::NSResult result = OIC::Service::NSResult::ERROR;
+ try
+ {
+ result = nsConsumer->unsetTopic(topicName);
+ }
+ catch (OIC::Service::NSException ex)
+ {
+ ThrowNSException(NATIVE_EXCEPTION, ex.what());
+ return;
}
- OIC::Service::NSResult result = nsConsumer->unsetTopic(topicName);
if (result != OIC::Service::NSResult::OK)
{
- LOGE("Fail to Unselect Topic");
+ ThrowNSException((int) result, "Fail to Unselect Topic");
+ return;
}
env->ReleaseStringUTFChars(jTopicName, name);
env->ReleaseStringUTFChars(jConsumerId, id);
- LOGD("JNIProviderService: nativeUnsetConsumerTopic - OUT");
- return (jint) result;
+ NS_LOGD ("JNIProviderService: nativeUnsetConsumerTopic - OUT");
+ return;
}
JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_provider_Consumer_nativeGetConsumerTopicList
(JNIEnv *env, jobject jObj, jstring jConsumerId)
{
- LOGD("JNIProviderService: nativeGetConsumerTopicList - IN");
+ NS_LOGD ("JNIProviderService: nativeGetConsumerTopicList - IN");
if (!jConsumerId)
{
- ThrowNSException(NS_ERROR, "Topic Name or ConsumerId Can't be NULL");
+ ThrowNSException(JNI_INVALID_VALUE, "Topic Name or ConsumerId Can't be NULL");
return NULL;
}
const char *id = env->GetStringUTFChars( jConsumerId, NULL);
std::string consumerId(id);
- OIC::Service::NSConsumer *nsConsumer =
+ std::shared_ptr<OIC::Service::NSConsumer> nsConsumer =
OIC::Service::NSProviderService::getInstance()->getConsumer(consumerId);
if (!nsConsumer)
{
- ThrowNSException(NS_ERROR, "Consumer does exists");
+ ThrowNSException(JNI_NO_NATIVE_POINTER, "Consumer does exists");
return NULL;
}
env->ReleaseStringUTFChars(jConsumerId, id);
- OIC::Service::NSTopicsList *topicList = nsConsumer->getConsumerTopicList();
+ std::shared_ptr<OIC::Service::NSTopicsList> topicList = nullptr;
+ try
+ {
+ topicList = nsConsumer->getConsumerTopicList();
+ }
+ catch (OIC::Service::NSException ex)
+ {
+ ThrowNSException(NATIVE_EXCEPTION, ex.what());
+ return NULL;
+ }
if (topicList == nullptr)
{
- ThrowNSException(NS_ERROR, "Topic List doesn't exist");
+ ThrowNSException(JNI_NO_NATIVE_POINTER, "Topic List doesn't exist");
return NULL;
}
jobject obj_topicList = getJavaTopicsList(env, topicList);
- LOGD("JNIProviderService: nativeGetConsumerTopicList - OUT");
+
+ NS_LOGD ("JNIProviderService: nativeGetConsumerTopicList - OUT");
return obj_topicList;
}
// JNI OnLoad
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
{
- LOGD("ProviderService_JNI_OnLoad");
+ NS_LOGD ("ProviderService_JNI_OnLoad");
g_jvm_provider = jvm;
- JNIEnv *env;
+ JNIEnv *env = NULL;
if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
{
- LOGE("Failed to get the environment using GetEnv()");
+ NS_LOGE ("Failed to get the environment using GetEnv()");
return JNI_ERR;
}
"org/iotivity/service/ns/common/Message");
if (!localMessage)
{
- LOGE("Failed to get local Message class");
+ NS_LOGE ("Failed to get local Message class");
return JNI_ERR;
}
g_cls_Message = (jclass) (env->NewGlobalRef(localMessage));
if (!g_cls_Message)
{
- LOGE("Failed to set Global Message reference");
+ NS_LOGE ("Failed to set Global Message reference");
return JNI_ERR;
}
"org/iotivity/service/ns/common/Message$MessageType");
if (!localMessageType)
{
- LOGE("Failed to get local Message Type class");
+ NS_LOGE ("Failed to get local Message Type class");
return JNI_ERR;
}
g_cls_Message_Type = (jclass) (env->NewGlobalRef(localMessageType));
if (!g_cls_Message_Type)
{
- LOGE("Failed to set Global Message Type reference");
+ NS_LOGE ("Failed to set Global Message Type reference");
return JNI_ERR;
}
"org/iotivity/service/ns/provider/Consumer");
if (!localConsumer)
{
- LOGE("Failed to get local Provider class");
+ NS_LOGE ("Failed to get local Provider class");
return JNI_ERR;
}
g_cls_Consumer = (jclass) (env->NewGlobalRef(localConsumer));
if (!g_cls_Consumer)
{
- LOGE("Failed to set Global Provider reference");
+ NS_LOGE ("Failed to set Global Provider reference");
return JNI_ERR;
}
"org/iotivity/service/ns/common/SyncInfo");
if (!localSyncInfo)
{
- LOGE("Failed to get local SyncInfo class");
+ NS_LOGE ("Failed to get local SyncInfo class");
return JNI_ERR;
}
g_cls_SyncInfo = (jclass) (env->NewGlobalRef(localSyncInfo));
if (!g_cls_SyncInfo)
{
- LOGE("Failed to set Global SyncInfo reference");
+ NS_LOGE ("Failed to set Global SyncInfo reference");
return JNI_ERR;
}
"org/iotivity/service/ns/common/SyncInfo$SyncType");
if (!localSyncType)
{
- LOGE("Failed to get local SyncType enum");
+ NS_LOGE ("Failed to get local SyncType enum");
return JNI_ERR;
}
g_cls_SyncType = (jclass) (env->NewGlobalRef(localSyncType));
if (!g_cls_SyncType)
{
- LOGE("Failed to set Global SyncType reference");
+ NS_LOGE ("Failed to set Global SyncType reference");
return JNI_ERR;
}
"org/iotivity/service/ns/common/MediaContents");
if (!localMediaContents)
{
- LOGE("Failed to get local MediaContents class");
+ NS_LOGE ("Failed to get local MediaContents class");
return JNI_ERR;
}
g_cls_MediaContents = (jclass) (env->NewGlobalRef(localMediaContents));
if (!g_cls_MediaContents)
{
- LOGE("Failed to set Global MediaContents reference");
+ NS_LOGE ("Failed to set Global MediaContents reference");
return JNI_ERR;
}
"org/iotivity/service/ns/common/Topic");
if (!localTopic)
{
- LOGE("Failed to get local Topic class");
+ NS_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");
+ NS_LOGE ("Failed to set Global Topic reference");
return JNI_ERR;
}
"org/iotivity/service/ns/common/TopicsList");
if (!localTopicsList)
{
- LOGE("Failed to get local Topic class");
+ NS_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");
+ NS_LOGE ("Failed to set Global TopicsList reference");
return JNI_ERR;
}
"org/iotivity/service/ns/common/Topic$TopicState");
if (!localTopicState)
{
- LOGE("Failed to get local TopicState enum");
+ NS_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");
+ NS_LOGE ("Failed to set Global TopicState reference");
return JNI_ERR;
}
jclass localOcRepresentation = env->FindClass("org/iotivity/base/OcRepresentation");
if (!localOcRepresentation)
{
- LOGE("Failed to get local OcRepresentation class");
+ NS_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");
+ NS_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");
+ NS_LOGE ("Failed to get Global OcRepresentation Constructor reference");
return JNI_ERR;
}
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)
{
- LOGD("ProviderService_JNI_OnUnload");
- JNIEnv *env;
+ NS_LOGD ("ProviderService_JNI_OnUnload");
+ JNIEnv *env = NULL;
if (jvm->GetEnv((void **)&env, JNI_CURRENT_VERSION) != JNI_OK)
{
- LOGE("Failed to get the environment using GetEnv()");
+ NS_LOGE ("Failed to get the environment using GetEnv()");
return ;
}
projects / platform / upstream / iotivity.git / blobdiff