X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=service%2Fnotification%2Fandroid%2Fnotification-service%2Fsrc%2Fmain%2Fjni%2Fconsumer%2FJniNotificationConsumer.cpp;h=7abe708b124f1c2dcea37f575c2df80e5a302288;hb=7f00f942c39b7bc27c7eeecf213a239c3fe4173c;hp=ad4a1231cd10798d9467aaa2026ee10fa626ab4a;hpb=edcfc3d2329da7b914771c0dcff5f42c9b74fd93;p=platform%2Fupstream%2Fiotivity.git diff --git a/service/notification/android/notification-service/src/main/jni/consumer/JniNotificationConsumer.cpp b/service/notification/android/notification-service/src/main/jni/consumer/JniNotificationConsumer.cpp index ad4a123..7abe708 100755 --- a/service/notification/android/notification-service/src/main/jni/consumer/JniNotificationConsumer.cpp +++ b/service/notification/android/notification-service/src/main/jni/consumer/JniNotificationConsumer.cpp @@ -20,6 +20,7 @@ #include "JniNotificationConsumer.h" #include "NSConsumerService.h" +#include "NSException.h" #include "JniOcRepresentation.h" static JavaVM *g_jvm_consumer = NULL; @@ -54,7 +55,7 @@ static JNIEnv *GetJNIEnv(jint *ret) case JNI_EDETACHED: if (g_jvm_consumer->AttachCurrentThread(&env, NULL) != JNI_OK) { - LOGE ("Failed to get the environment"); + NS_LOGE ("Failed to get the environment"); return NULL; } else @@ -62,99 +63,116 @@ static JNIEnv *GetJNIEnv(jint *ret) 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; } } jobject getJavaProviderState(JNIEnv *env, OIC::Service::NSProviderState state) { - LOGD ("ConsumerService_getJavaProviderState - IN"); + NS_LOGD ("ConsumerService_getJavaProviderState - IN"); + jobject providerState = NULL; switch (state) { case OIC::Service::NSProviderState::ALLOW: { static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState, "ALLOW", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;"); - return env->GetStaticObjectField(g_cls_ProviderState, fieldID); + providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID); + break; } case OIC::Service::NSProviderState::DENY: { static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState, "DENY", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;"); - return env->GetStaticObjectField(g_cls_ProviderState, fieldID); + providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID); + break; } case OIC::Service::NSProviderState::TOPIC: { static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState, "TOPIC", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;"); - return env->GetStaticObjectField(g_cls_ProviderState, fieldID); + providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID); + break; } case OIC::Service::NSProviderState::STOPPED: { static jfieldID fieldID = env->GetStaticFieldID(g_cls_ProviderState, "STOPPED", "Lorg/iotivity/service/ns/consumer/Provider$ProviderState;"); - return env->GetStaticObjectField(g_cls_ProviderState, fieldID); + providerState = env->GetStaticObjectField(g_cls_ProviderState, fieldID); + break; } default: - return NULL; + { + providerState = NULL; + break; + } } - LOGD ("ConsumerService_getJavaProviderState - OUT"); - return NULL; + NS_LOGD ("ConsumerService_getJavaProviderState - OUT"); + return providerState; } jobject getJavaSyncType(JNIEnv *env, OIC::Service::NSSyncInfo::NSSyncType nsType) { - LOGD ("ConsumerService_getJavaSyncType - IN"); + NS_LOGD ("ConsumerService_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 ("ConsumerService_getJavaSyncType - OUT"); - return NULL; + NS_LOGD ("ConsumerService_getJavaSyncType - OUT"); + return syncType; } jobject getJavaTopicState(JNIEnv *env, OIC::Service::NSTopic::NSTopicState nsState) { - LOGD ("ConsumerService_getJavaTopicState - IN"); + NS_LOGD ("ConsumerService_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) { @@ -162,72 +180,77 @@ jobject getJavaTopicState(JNIEnv *env, OIC::Service::NSTopic::NSTopicState nsSta { 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 ("ConsumerService_getJavaTopicState - OUT"); - return NULL; + NS_LOGD ("ConsumerService_getJavaTopicState - OUT"); + return topicState; } -jobject getJavaTopicsList(JNIEnv *env, OIC::Service::NSTopicsList *topicList) +jobject getJavaTopicsList(JNIEnv *env, std::shared_ptr topicList) { - LOGD ("ConsumerService_getJavaTopicsList - IN"); + NS_LOGD ("ConsumerService_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, "", "()V"); if (!mid_topicList) { - LOGE ("Failed to Get MethodID for TopicsList"); + NS_LOGE ("Failed to Get MethodID for TopicsList"); 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 ("ConsumerService_getJavaTopicsList - OUT"); + NS_LOGD ("ConsumerService_getJavaTopicsList - OUT"); return obj_topicList; } bool getNativeTopicState(JNIEnv *env, jobject jTopic , OIC::Service::NSTopic::NSTopicState &state ) { - LOGD ("ConsumerService_getNativeTopicState - IN"); + NS_LOGD ("ConsumerService_getNativeTopicState - IN"); jclass cls_topic = env->GetObjectClass( jTopic); // TopicState jclass cls_TopicState = (jclass) (env->NewLocalRef(g_cls_TopicState)); if (!cls_TopicState) { - LOGE ("Failed to Get ObjectClass for cls_TopicState Type"); + NS_LOGE ("Failed to Get ObjectClass for cls_TopicState Type"); return false; } jmethodID mid = env->GetMethodID(cls_TopicState, "ordinal", "()I"); @@ -235,110 +258,111 @@ bool getNativeTopicState(JNIEnv *env, jobject jTopic , OIC::Service::NSTopic::N "Lorg/iotivity/service/ns/common/Topic$TopicState;"); if (fid_state == NULL) { - LOGE("Error: jfieldID for state type is null"); + NS_LOGE ("Error: jfieldID for state type is null"); return false; } jobject jobj = env->GetObjectField( jTopic, fid_state); if (jobj == NULL) { - LOGE("Error: object of field state Type is null"); + NS_LOGE ("Error: object of field state Type is null"); return false; } jint jState = env->CallIntMethod(jobj, mid); state = (OIC::Service::NSTopic::NSTopicState) jState; - LOGD ("ConsumerService_getNativeTopicState - OUT"); + NS_LOGD ("ConsumerService_getNativeTopicState - OUT"); return true; } const char *getNativeTopicName(JNIEnv *env, jobject jTopic) { - LOGD ("ConsumerService_getNativeTopicName - IN"); + NS_LOGD ("ConsumerService_getNativeTopicName - IN"); jclass cls_topic = env->GetObjectClass( jTopic); if (cls_topic == NULL) { - LOGE("Error: Class for Topic is null"); + NS_LOGE ("Error: Class for Topic is null"); return nullptr; } jfieldID fid_name = env->GetFieldID( cls_topic, "mTopicName", "Ljava/lang/String;"); if (fid_name == NULL) { - LOGE("Error: jfieldID for Topic Name is null"); + NS_LOGE ("Error: jfieldID for Topic Name is null"); return nullptr; } jstring jTopicName = (jstring) env->GetObjectField( jTopic, fid_name); - const char *topicName; + const char *topicName = NULL; if (jTopicName) { topicName = env->GetStringUTFChars( jTopicName, NULL); } else { - LOGI("Info: topicName is null"); + NS_LOGI (TAG, "Info: topicName is null"); } - LOGD ("ConsumerService_getNativeTopicName - OUT"); + NS_LOGD ("ConsumerService_getNativeTopicName - OUT"); return topicName; } -OIC::Service::NSTopicsList *getNativeTopicsList(JNIEnv *env, jobject jTopicList) +std::shared_ptr getNativeTopicsList(JNIEnv *env, jobject jTopicList) { - LOGD ("ConsumerService_getNativeTopicsList - IN"); + NS_LOGD ("ConsumerService_getNativeTopicsList - IN"); jclass cls_topicList = env->GetObjectClass( jTopicList); if (cls_topicList == NULL) { - LOGE("Error: Class for Topic List is null"); + NS_LOGE ("Error: Class for Topic List is null"); return nullptr; } jfieldID fid_list = env->GetFieldID( cls_topicList, "mTopicsList", "Ljava/util/Vector;"); if (fid_list == NULL) { - LOGE("Error: jfieldID for Topic List is null"); + NS_LOGE ("Error: jfieldID for Topic List is null"); return nullptr; } jobject jobj = env->GetObjectField( jTopicList, fid_list); if (jobj == NULL) { - LOGE("Error: object of field Topic List is null"); + NS_LOGE ("Error: object of field Topic List is null"); return nullptr; } jclass cls_vec = env->FindClass("java/util/Vector"); if (cls_vec == NULL) { - LOGE("Error: Class for Vector not found"); + NS_LOGE ("Error: Class for Vector not found"); return nullptr; } jmethodID sizeMethod = env->GetMethodID(cls_vec, "size", "()I"); if (sizeMethod == NULL) { - LOGE("Error: MethodId for Vector Size not found"); + NS_LOGE ("Error: MethodId for Vector Size not found"); return nullptr; } int size = env->CallIntMethod(jobj, sizeMethod); jmethodID getMethod = env->GetMethodID(cls_vec, "get", "(I)Ljava/lang/Object;"); if (getMethod == NULL) { - LOGE("Error: MethodId for Vector get not found"); + NS_LOGE ("Error: MethodId for Vector get not found"); return nullptr; } - OIC::Service::NSTopicsList *nsTopicList = new OIC::Service::NSTopicsList(); + std::shared_ptr nsTopicList = + std::make_shared(); for (int index = 0; index < size; index++) { jobject topicObj = env->CallObjectMethod(jobj, getMethod, index); if (topicObj == NULL) { - LOGE("Error: object of field Topic is null"); + NS_LOGE ("Error: object of field Topic is null"); return nullptr; } const char *name = getNativeTopicName(env, topicObj); if (name == nullptr) { - LOGE("Error: Couldn't find topic Name"); + NS_LOGE ("Error: Couldn't find topic Name"); return nullptr; } std::string topicName(name); - OIC::Service::NSTopic::NSTopicState state; + OIC::Service::NSTopic::NSTopicState state = OIC::Service::NSTopic::NSTopicState::UNSUBSCRIBED; if (!getNativeTopicState(env, topicObj, state)) { return nullptr; @@ -348,149 +372,124 @@ OIC::Service::NSTopicsList *getNativeTopicsList(JNIEnv *env, jobject jTopicList) env->DeleteLocalRef(cls_vec); env->DeleteLocalRef(cls_topicList); - LOGD ("ConsumerService_getNativeTopicsList - OUT"); + NS_LOGD ("ConsumerService_getNativeTopicsList - OUT"); return nsTopicList; } -OIC::Service::NSProvider *getNativeProvider(JNIEnv *env, jobject jObj) +jobject getJavaProvider(JNIEnv *env, std::shared_ptr provider) { - LOGD ("ConsumerService_getNativeProvider - IN"); - jclass providerClass = env->GetObjectClass(jObj); - if (!providerClass) - { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); - return NULL; - } - jfieldID jproviderId = env->GetFieldID(providerClass, "mProviderId", "Ljava/lang/String;"); - if (!jproviderId) - { - ThrowNSException(NS_ERROR, "Failed to get providerId for Provider"); - return NULL; - } - jstring jprovider_id = (jstring) env->GetObjectField(jObj, jproviderId); - if (!jprovider_id) - { - ThrowNSException(NS_ERROR, "ProviderId cannot be null"); - return NULL; - } + NS_LOGD ("ConsumerService_getJavaProvider - IN"); + NS_LOGD ("ProviderId : %s\n", provider->getProviderId().c_str()); - const char *providerId = env->GetStringUTFChars(jprovider_id, 0); - LOGD ("ProviderId : %s\n", providerId); - - OIC::Service::NSProvider *provider = - OIC::Service::NSConsumerService::getInstance()->getProvider(std::string(providerId)); - if (provider == nullptr) + jstring jProviderId = env->NewStringUTF(provider->getProviderId().c_str()); + auto *objectHolder = JniSharedObjectHolder::create(provider); + if (!objectHolder) { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); + NS_LOGE ("Failed to create new Object Holder for Provider"); return NULL; } - env->ReleaseStringUTFChars(jprovider_id, providerId); - LOGD ("ConsumerService_getNativeProvider - OUT"); - return provider; -} - -jobject getJavaProvider(JNIEnv *env, OIC::Service::NSProvider *provider) -{ - LOGD ("ConsumerService_getJavaProvider - IN"); - LOGD ("ProviderId : %s\n", provider->getProviderId().c_str()); - - jstring jProviderId = env->NewStringUTF(provider->getProviderId().c_str()); - jlong pProvider = (long)provider; + jlong pProvider = (long)objectHolder; jclass cls_provider = (jclass) (env->NewLocalRef(g_cls_Provider)); if (!cls_provider) { - LOGE ("Failed to Get ObjectClass for Provider"); + NS_LOGE ("Failed to Get ObjectClass for Provider"); return NULL; } jmethodID mid_provider = env->GetMethodID( cls_provider, "", "(Ljava/lang/String;)V"); if (!mid_provider) { - LOGE ("Failed to Get MethodID for Provider"); + NS_LOGE ("Failed to Get MethodID for Provider"); return NULL; } jobject obj_provider = env->NewObject(cls_provider, mid_provider, jProviderId); if (!obj_provider) { - LOGE("Failed to create new Object for Provider"); + NS_LOGE ("Failed to create new Object for Provider"); return NULL; } jfieldID nativeHandle = env->GetFieldID(cls_provider, "mNativeHandle", "J"); if (!nativeHandle) { - LOGE("Failed to get nativeHandle for Provider"); + NS_LOGE ("Failed to get nativeHandle for Provider"); return NULL; } env->SetLongField(obj_provider, nativeHandle, pProvider); env->DeleteLocalRef(cls_provider); - LOGD ("ConsumerService_getJavaProvider - OUT"); + NS_LOGD ("ConsumerService_getJavaProvider - OUT"); return obj_provider; } jobject getJavaMessageType(JNIEnv *env, OIC::Service::NSMessage::NSMessageType type) { - LOGD ("ConsumerService_getJavaMessageType - IN"); + NS_LOGD ("ConsumerService_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 ("ConsumerService_getJavaMessageType - OUT"); - return NULL; + NS_LOGD ("ConsumerService_getJavaMessageType - OUT"); + return messageType; } -jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message) +jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage message) { - LOGD ("ConsumerService_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 ("ConsumerService_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( @@ -498,28 +497,21 @@ jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message) "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); if (!mid_message) { - LOGE ("Failed to Get MethodID for Message"); + NS_LOGE ("Failed to Get MethodID for Message"); 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"); + NS_LOGE ("Failed to Get Java Object 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); @@ -527,7 +519,7 @@ jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message) 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); @@ -535,7 +527,7 @@ jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message) 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); @@ -543,7 +535,7 @@ jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message) 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); @@ -551,26 +543,26 @@ jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message) 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, "", "(Ljava/lang/String;)V"); if (!mid_mediaContents) { - LOGE ("Failed to Get MethodID for MediaContents"); + NS_LOGE ("Failed to Get MethodID for MediaContents"); return NULL; } jobject obj_mediaContents = env->NewObject(cls_mediaContents, mid_mediaContents, @@ -580,86 +572,98 @@ jobject getJavaMessage(JNIEnv *env, OIC::Service::NSMessage *message) "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"); + NS_LOGD ("Reading OCRepresentation Object from Native"); - OC::OCRepresentation *ocRepresentation = new OC::OCRepresentation(message->getExtraInfo()); + OC::OCRepresentation *ocRepresentation = new OC::OCRepresentation(message.getExtraInfo()); jlong handle = reinterpret_cast(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 ("ConsumerService_getJavaMessage - OUT"); + NS_LOGD ("ConsumerService_getJavaMessage - OUT"); return obj_message; } -void onDiscoverProvider(OIC::Service::NSProvider *provider) +void onDiscoverProvider(std::shared_ptr provider) { - LOGD ("ConsumerService_onDiscoverProvider - IN"); + NS_LOGD ("ConsumerService_onDiscoverProvider - IN"); - jint envRet; + jint envRet = 0;; JNIEnv *env = GetJNIEnv(&envRet); - if (NULL == env) return ; + if (NULL == env) + { + return ; + } jobject jDiscoverListener = (jobject) env->NewLocalRef(g_obj_discoverListener); if (!jDiscoverListener) { - LOGE ("Failed to Get jDiscoverListener"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get jDiscoverListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jobject obj_provider = getJavaProvider(env, provider); if (!obj_provider) { - LOGE ("Failed to Get Provider Object"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get Provider Object"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jclass cls = env->GetObjectClass(jDiscoverListener); if (!cls) { - LOGE ("Failed to Get ObjectClass for jDiscoverListener"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get ObjectClass for jDiscoverListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jmethodID mid = env->GetMethodID( @@ -668,47 +672,65 @@ void onDiscoverProvider(OIC::Service::NSProvider *provider) "(Lorg/iotivity/service/ns/consumer/Provider;)V"); if (!mid) { - LOGE ("Failed to Get MethodID for onProviderDiscovered"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get MethodID for onProviderDiscovered"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } env->CallVoidMethod(jDiscoverListener, mid, obj_provider); env->DeleteLocalRef(jDiscoverListener); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); - LOGD ("ConsumerService_onDiscoverProvider - OUT"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } + NS_LOGD ("ConsumerService_onDiscoverProvider - OUT"); return ; } void onProviderState( OIC::Service::NSProviderState state) { - LOGD ("ConsumerService_onProviderState -IN"); + NS_LOGD ("ConsumerService_onProviderState -IN"); - jint envRet; + jint envRet = 0;; JNIEnv *env = GetJNIEnv(&envRet); - if (NULL == env) return ; + if (NULL == env) + { + return ; + } jobject jAcceptListener = (jobject) env->NewLocalRef(g_obj_acceptListener); if (!jAcceptListener) { - LOGE ("Failed to Get jAcceptListener"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get jAcceptListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jobject obj_state = getJavaProviderState(env, state); if (!obj_state) { - LOGE ("Failed to Get ProviderState Object"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get ProviderState Object"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jclass cls = env->GetObjectClass(jAcceptListener); if (!cls) { - LOGE ("Failed to Get ObjectClass for jAcceptListener"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get ObjectClass for jAcceptListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jmethodID mid = env->GetMethodID( @@ -717,47 +739,65 @@ void onProviderState( OIC::Service::NSProviderState state) "(Lorg/iotivity/service/ns/consumer/Provider$ProviderState;)V"); if (!mid) { - LOGE ("Failed to Get MethodID for onProviderState"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get MethodID for onProviderState"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } env->CallVoidMethod(jAcceptListener, mid, obj_state); env->DeleteLocalRef(jAcceptListener); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); - LOGD ("ConsumerService_onProviderState -OUT"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } + NS_LOGD ("ConsumerService_onProviderState -OUT"); return ; } -void onMessagePosted(OIC::Service::NSMessage *message) +void onMessagePosted(OIC::Service::NSMessage message) { - LOGD ("ConsumerService_onMessagePosted -IN"); + NS_LOGD ("ConsumerService_onMessagePosted -IN"); - jint envRet; + jint envRet = 0;; JNIEnv *env = GetJNIEnv(&envRet); - if (NULL == env) return ; + if (NULL == env) + { + return ; + } jobject jPostListener = (jobject) env->NewLocalRef(g_obj_postListener); if (!jPostListener) { - LOGE ("Failed to Get jPostListener"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get jPostListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jobject obj_message = getJavaMessage( env, message); if (!obj_message) { - LOGE ("Failed to Get Message Object"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get Message Object"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jclass cls = env->GetObjectClass(jPostListener); if (!cls) { - LOGE ("Failed to Get ObjectClass for jPostListener"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get ObjectClass for jPostListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jmethodID mid = env->GetMethodID( @@ -766,53 +806,71 @@ void onMessagePosted(OIC::Service::NSMessage *message) "(Lorg/iotivity/service/ns/common/Message;)V"); if (!mid) { - LOGE ("Failed to Get MethodID for onMessageReceived"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get MethodID for onMessageReceived"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } env->CallVoidMethod(jPostListener, mid, obj_message); env->DeleteLocalRef(jPostListener); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); - LOGD ("ConsumerService_onMessagePosted -OUT"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } + NS_LOGD ("ConsumerService_onMessagePosted -OUT"); return ; } -void onSyncInfoReceived(OIC::Service::NSSyncInfo *sync) +void onSyncInfoReceived(OIC::Service::NSSyncInfo sync) { - LOGD ("ConsumerService_onSyncInfoReceived - IN"); + NS_LOGD ("ConsumerService_onSyncInfoReceived - 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_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get jSyncListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } - LOGD ("Sync ID : %llu\n", sync->getMessageId()); - LOGD ("Sync ProviderId : %s\n", sync->getProviderId().c_str()); - LOGD ("Sync STATE : %d\n", (int) sync->getState()); + NS_LOGD ("Sync ID : %llu\n", sync.getMessageId()); + NS_LOGD ("Sync ProviderId : %s\n", sync.getProviderId().c_str()); + NS_LOGD ("Sync STATE : %d\n", (int) sync.getState()); - jlong jMessageId = (jlong) sync->getMessageId(); - jstring jProviderId = env->NewStringUTF(sync->getProviderId().c_str()); - jobject syncType = getJavaSyncType(env, sync->getState()); + jlong jMessageId = (jlong) 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_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get syncType for SyncInfo"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->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_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get ObjectClass for SyncInfo"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jmethodID mid_syncInfo = env->GetMethodID( @@ -821,8 +879,11 @@ void onSyncInfoReceived(OIC::Service::NSSyncInfo *sync) "(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_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get MethodID for SyncInfo"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } @@ -830,16 +891,22 @@ void onSyncInfoReceived(OIC::Service::NSSyncInfo *sync) jMessageId, jProviderId, syncType); if (!obj_syncInfo) { - LOGE ("Failed to Get Object for SyncInfo"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get Object for SyncInfo"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jclass cls = env->GetObjectClass(jSyncListener); if (!cls) { - LOGE ("Failed to Get ObjectClass for jSyncListener"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get ObjectClass for jSyncListener"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } jmethodID mid = env->GetMethodID( @@ -848,8 +915,11 @@ void onSyncInfoReceived(OIC::Service::NSSyncInfo *sync) "(Lorg/iotivity/service/ns/common/SyncInfo;)V"); if (!mid) { - LOGE ("Failed to Get MethodID for onSyncInfoReceived"); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); + NS_LOGE ("Failed to Get MethodID for onSyncInfoReceived"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } return ; } @@ -857,19 +927,22 @@ void onSyncInfoReceived(OIC::Service::NSSyncInfo *sync) env->DeleteLocalRef(jSyncListener); env->DeleteLocalRef(cls_SyncInfo); - if (JNI_EDETACHED == envRet) g_jvm_consumer->DetachCurrentThread(); - LOGD ("ConsumerService_onSyncInfoReceived - OUT"); + if (JNI_EDETACHED == envRet) + { + g_jvm_consumer->DetachCurrentThread(); + } + NS_LOGD ("ConsumerService_onSyncInfoReceived - OUT"); return ; } JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nativeStart (JNIEnv *env, jobject jObj, jobject jDiscoverListener) { - LOGD ("ConsumerService_StartConsumer - IN"); + NS_LOGD ("ConsumerService_StartConsumer - IN"); if (!jDiscoverListener) { - ThrowNSException(NS_ERROR, "Listener cannot be null"); - return ; + ThrowNSException(JNI_INVALID_VALUE, "Listener cannot be null"); + return; } if (g_obj_discoverListener != NULL) { @@ -877,8 +950,15 @@ JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nat } g_obj_discoverListener = (jobject) env->NewGlobalRef(jDiscoverListener); - OIC::Service::NSConsumerService::getInstance()->start(onDiscoverProvider); - LOGD ("ConsumerService_StartConsumer - OUT"); + OIC::Service::NSResult result = OIC::Service::NSConsumerService::getInstance()->start( + onDiscoverProvider); + + if (result != OIC::Service::NSResult::OK) + { + ThrowNSException((int) result, "Fail to start ConsumerService"); + return; + } + NS_LOGD ("ConsumerService_StartConsumer - OUT"); return; } @@ -886,7 +966,7 @@ JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nat JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nativeStop (JNIEnv *env, jobject jObj) { - LOGD ("ConsumerService_StopConsumer - IN"); + NS_LOGD ("ConsumerService_StopConsumer - IN"); env->DeleteGlobalRef(g_obj_postListener); env->DeleteGlobalRef(g_obj_syncListener); @@ -896,35 +976,87 @@ JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nat g_obj_syncListener = NULL; g_obj_discoverListener = NULL; g_obj_acceptListener = NULL; - OIC::Service::NSConsumerService::getInstance()->stop(); - LOGD ("ConsumerService_StopConsumer - OUT"); + OIC::Service::NSResult result = OIC::Service::NSConsumerService::getInstance()->stop(); + + if (result != OIC::Service::NSResult::OK) + { + ThrowNSException((int) result, "Fail to Stop ConsumerService"); + return; + } + NS_LOGD ("ConsumerService_StopConsumer - OUT"); return; } -JNIEXPORT jint JNICALL +JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nativeEnableRemoteService (JNIEnv *env, jobject jObj, jstring jServerAddress) { - LOGD ("ConsumerService_EnableRemoteService - IN"); + NS_LOGD ("ConsumerService_EnableRemoteService - IN"); if (!jServerAddress) { - ThrowNSException(NS_ERROR, "EnableRemoteService server address NULL"); - return (jint) OIC::Service::NSResult::ERROR; + ThrowNSException(JNI_INVALID_VALUE, "EnableRemoteService server address NULL"); + return; } const char *serverAddress = env->GetStringUTFChars(jServerAddress, 0); - OIC::Service::NSResult res = + OIC::Service::NSResult result = OIC::Service::NSConsumerService::getInstance()->enableRemoteService(std::string(serverAddress)); + + if (result != OIC::Service::NSResult::OK) + { + ThrowNSException((int) result, "Fail to EnableRemoteService"); + return; + } env->ReleaseStringUTFChars(jServerAddress, serverAddress); - LOGD ("ConsumerService_EnableRemoteService - OUT"); - return (jint) res; + NS_LOGD ("ConsumerService_EnableRemoteService - OUT"); + return; +} + +JNIEXPORT void JNICALL +Java_org_iotivity_service_ns_consumer_ConsumerService_nativeSubscribeMQService +(JNIEnv *env, jobject jObj, jstring jserverAddress, jstring jTopicName) +{ + NS_LOGD ("ConsumerService: 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::NSConsumerService::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 ("ConsumerService: nativeSubscribeMQService - OUT"); + return; } JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nativeRescanProvider (JNIEnv *env, jobject jObj) { - LOGD ("ConsumerService_RescanProvider - IN"); - OIC::Service::NSConsumerService::getInstance()->rescanProvider(); - LOGD ("ConsumerService_RescanProvider - OUT"); + NS_LOGD ("ConsumerService_RescanProvider - IN"); + OIC::Service::NSResult result = OIC::Service::NSConsumerService::getInstance()->rescanProvider(); + if (result != OIC::Service::NSResult::OK) + { + ThrowNSException((int) result, "Fail to RescanProvider"); + return; + } + NS_LOGD ("ConsumerService_RescanProvider - OUT"); return; } @@ -932,89 +1064,156 @@ JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_ConsumerService_nat JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSubscribe (JNIEnv *env, jobject jObj) { - LOGD ("Provider_Subscribe -IN"); + NS_LOGD ("Provider_Subscribe -IN"); + OIC::Service::NSResult result = OIC::Service::NSResult::ERROR; jclass providerClass = env->GetObjectClass(jObj); if (!providerClass) { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); return ; } jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); if (!nativeHandle) { - ThrowNSException(NS_ERROR, "Failed to get nativeHandle for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); return ; } jlong jProvider = env->GetLongField(jObj, nativeHandle); if (jProvider) { - LOGD ("calling subscribe on mNativeHandle"); - OIC::Service::NSProvider *provider = (OIC::Service::NSProvider *) (jProvider); - provider->subscribe(); + NS_LOGD ("calling subscribe on mNativeHandle"); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + try + { + result = objectHolder->get()->subscribe(); + } + catch (OIC::Service::NSException ex) + { + ThrowNSException(NATIVE_EXCEPTION, ex.what()); + return; + } } else { - OIC::Service::NSProvider *provider = getNativeProvider(env, jObj); - if (provider == nullptr) + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); + } + if (result != OIC::Service::NSResult::OK) + { + ThrowNSException((int) result, "Fail to Subscribe Provider"); + return; + } + NS_LOGD ("Provider_Subscribe -OUT"); + return; +} + +JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeUnsubscribe +(JNIEnv *env, jobject jObj) +{ + NS_LOGD ("Provider_UnSubscribe -IN"); + OIC::Service::NSResult result = OIC::Service::NSResult::ERROR; + jclass providerClass = env->GetObjectClass(jObj); + if (!providerClass) + { + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); + return ; + } + + jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); + if (!nativeHandle) + { + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); + return ; + } + jlong jProvider = env->GetLongField(jObj, nativeHandle); + if (jProvider) + { + NS_LOGD ("calling subscribe on mNativeHandle"); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + try + { + result = objectHolder->get()->unsubscribe(); + } + catch (OIC::Service::NSException ex) { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); + ThrowNSException(NATIVE_EXCEPTION, ex.what()); return; } - LOGD ("calling subscribe on ProviderID"); - provider->subscribe(); } - LOGD ("Provider_Subscribe -OUT"); + else + { + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); + } + if (result != OIC::Service::NSResult::OK) + { + ThrowNSException((int) result, "Fail to UnSubscribe Provider"); + return; + } + NS_LOGD ("Provider_UnSubscribe -OUT"); return; } JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSendSyncInfo (JNIEnv *env, jobject jObj, jlong jMessageId, jint jSyncType) { - LOGD ("Provider_SendSyncInfo - IN"); + NS_LOGD ("Provider_SendSyncInfo - IN"); + OIC::Service::NSResult result = OIC::Service::NSResult::ERROR; if (!jMessageId) { - ThrowNSException(NS_ERROR, "MessageId cannot be 0"); + ThrowNSException(JNI_INVALID_VALUE, "MessageId cannot be 0"); return ; } jclass providerClass = env->GetObjectClass(jObj); if (!providerClass) { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); return ; } jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); if (!nativeHandle) { - ThrowNSException(NS_ERROR, "Failed to get nativeHandle for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); return ; } uint64_t messageId = (uint64_t) jMessageId; - LOGD("!!!!!!jMessageId: %lld", jMessageId); - LOGD("!!!!!!messageId: %lld", messageId); + NS_LOGD ("!!!!!!jMessageId: %lld", jMessageId); + NS_LOGD ("!!!!!!messageId: %lld", messageId); jlong jProvider = env->GetLongField(jObj, nativeHandle); if (jProvider) { - LOGD ("calling SendSyncInfo on mNativeHandle"); - OIC::Service::NSProvider *provider = (OIC::Service::NSProvider *) (jProvider); - provider->sendSyncInfo(messageId, (OIC::Service::NSSyncInfo::NSSyncType)jSyncType); - } - else - { - OIC::Service::NSProvider *provider = getNativeProvider(env, jObj); - if (provider == nullptr) + NS_LOGD ("calling SendSyncInfo on mNativeHandle"); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + try { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); + result = objectHolder->get()->sendSyncInfo(messageId, + (OIC::Service::NSSyncInfo::NSSyncType)jSyncType); + } + catch (OIC::Service::NSException ex) + { + ThrowNSException(NATIVE_EXCEPTION, ex.what()); return; } - LOGD ("calling SendSyncInfo on ProviderID"); - provider->sendSyncInfo(messageId, (OIC::Service::NSSyncInfo::NSSyncType)jSyncType); } - LOGD ("Provider_SendSyncInfo - OUT"); + else + { + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); + } + if (result != OIC::Service::NSResult::OK) + { + ThrowNSException((int) result, "Fail to Send sync info"); + return; + } + NS_LOGD ("Provider_SendSyncInfo - OUT"); return; } @@ -1022,30 +1221,30 @@ JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSend JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSetListener (JNIEnv *env, jobject jObj, jobject jAcceptListener, jobject jPostListener, jobject jSyncListener) { - LOGD ("Provider_SetListener - IN"); + NS_LOGD ("Provider_SetListener - IN"); if (!jPostListener || !jSyncListener || !jAcceptListener) { - ThrowNSException(NS_ERROR, "Listener cannot be null"); + ThrowNSException(JNI_INVALID_VALUE, "Listener cannot be null"); return ; } jclass providerClass = env->GetObjectClass(jObj); if (!providerClass) { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); return ; } jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); if (!nativeHandle) { - ThrowNSException(NS_ERROR, "Failed to get nativeHandle for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); return ; } jlong jProvider = env->GetLongField(jObj, nativeHandle); if (jProvider) { - LOGD ("calling SetListener on mNativeHandle"); + NS_LOGD ("calling SetListener on mNativeHandle"); if (g_obj_acceptListener != NULL) { env->DeleteGlobalRef(g_obj_acceptListener); @@ -1062,234 +1261,248 @@ JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeSetL g_obj_postListener = (jobject) env->NewGlobalRef(jPostListener); g_obj_syncListener = (jobject) env->NewGlobalRef(jSyncListener); - OIC::Service::NSProvider *provider = (OIC::Service::NSProvider *) (jProvider); - provider->setListener(onProviderState, onMessagePosted, onSyncInfoReceived); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + objectHolder->get()->setListener(onProviderState, onMessagePosted, onSyncInfoReceived); } else { - OIC::Service::NSProvider *provider = getNativeProvider(env, jObj); - if (provider == nullptr) - { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); - return; - } - LOGD ("calling SetListener on ProviderID"); - if (g_obj_acceptListener != NULL) - { - env->DeleteGlobalRef(g_obj_acceptListener); - } - if (g_obj_postListener != NULL) - { - env->DeleteGlobalRef(g_obj_postListener); - } - if (g_obj_syncListener != NULL) - { - env->DeleteGlobalRef(g_obj_syncListener); - } - g_obj_acceptListener = (jobject) env->NewGlobalRef(jAcceptListener); - g_obj_postListener = (jobject) env->NewGlobalRef(jPostListener); - g_obj_syncListener = (jobject) env->NewGlobalRef(jSyncListener); - - provider->setListener(onProviderState, onMessagePosted, onSyncInfoReceived); + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); } - LOGD ("Provider_SetListener - OUT"); + NS_LOGD ("Provider_SetListener - OUT"); return; } JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeGetTopicList (JNIEnv *env, jobject jObj) { - LOGD("Provider_nativeGetTopicList - IN"); + NS_LOGD ("Provider_nativeGetTopicList - IN"); jclass providerClass = env->GetObjectClass(jObj); if (!providerClass) { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); return NULL; } jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); if (!nativeHandle) { - ThrowNSException(NS_ERROR, "Failed to get nativeHandle for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); return NULL; } jlong jProvider = env->GetLongField(jObj, nativeHandle); - OIC::Service::NSTopicsList *topicList; + std::shared_ptr topicList = nullptr; if (jProvider) { - LOGD ("calling subscribe on mNativeHandle"); - OIC::Service::NSProvider *provider = (OIC::Service::NSProvider *) (jProvider); - topicList = provider->getTopicList(); - } - else - { - OIC::Service::NSProvider *provider = getNativeProvider(env, jObj); - if (provider == nullptr) + NS_LOGD ("calling subscribe on mNativeHandle"); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + try { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); + topicList = objectHolder->get()->getTopicList(); + } + catch (OIC::Service::NSException ex) + { + ThrowNSException(NATIVE_EXCEPTION, ex.what()); return NULL; } - LOGD ("calling subscribe on ProviderID"); - topicList = provider->getTopicList(); + } + else + { + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); } 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("Provider_nativeGetTopicList - OUT"); + NS_LOGD ("Provider_nativeGetTopicList - OUT"); return obj_topicList; } -JNIEXPORT jint JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeUpdateTopicList +JNIEXPORT void JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeUpdateTopicList (JNIEnv *env, jobject jObj, jobject jTopicsList) { - LOGD("Provider_nativeUpdateTopicList -IN"); + NS_LOGD ("Provider_nativeUpdateTopicList -IN"); if (!jTopicsList) { - LOGI("Fail to update Interest Topics - Topic List is null"); - ThrowNSException(NS_ERROR, "TopicList cannot be null"); - return (jint) OIC::Service::NSResult::ERROR; + ThrowNSException(JNI_INVALID_VALUE, "TopicList cannot be null"); + return; } - OIC::Service::NSTopicsList *nsTopicsList = getNativeTopicsList(env, jTopicsList); + std::shared_ptr nsTopicsList = getNativeTopicsList(env, jTopicsList); if (nsTopicsList == nullptr) { - ThrowNSException(NS_ERROR, "NSTopicList cannot be created "); - return (jint) OIC::Service::NSResult::ERROR; + ThrowNSException(JNI_INVALID_VALUE, "NSTopicList cannot be created "); + return; } jclass providerClass = env->GetObjectClass(jObj); if (!providerClass) { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); - return (jint) OIC::Service::NSResult::ERROR; + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); + return; } jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); if (!nativeHandle) { - ThrowNSException(NS_ERROR, "Failed to get nativeHandle for Provider"); - return (jint) OIC::Service::NSResult::ERROR; + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); + return; } jlong jProvider = env->GetLongField(jObj, nativeHandle); - OIC::Service::NSResult result; + OIC::Service::NSResult result = OIC::Service::NSResult::ERROR; if (jProvider) { - LOGD ("calling subscribe on mNativeHandle"); - OIC::Service::NSProvider *provider = (OIC::Service::NSProvider *) (jProvider); - result = provider->updateTopicList(nsTopicsList); + NS_LOGD ("calling subscribe on mNativeHandle"); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + try + { + result = objectHolder->get()->updateTopicList(nsTopicsList); + } + catch (OIC::Service::NSException ex) + { + ThrowNSException(NATIVE_EXCEPTION, ex.what()); + return; + } } else { - OIC::Service::NSProvider *provider = getNativeProvider(env, jObj); - if (provider == nullptr) - { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); - return (jint) OIC::Service::NSResult::ERROR; - } - LOGD ("calling subscribe on ProviderID"); - result = provider->updateTopicList(nsTopicsList); + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); } if (result != OIC::Service::NSResult::OK) { - LOGI("Fail to Update Interest Topics"); + ThrowNSException((int) result, "Fail to Update Interest Topics"); + return; } - LOGD("Provider_nativeUpdateTopicList -OUT"); - return (jint) result; + NS_LOGD ("Provider_nativeUpdateTopicList -OUT"); + return; } JNIEXPORT jobject JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeGetProviderState (JNIEnv *env, jobject jObj) { - LOGD("Provider_nativeGetProviderState - IN"); + NS_LOGD ("Provider_nativeGetProviderState - IN"); jclass providerClass = env->GetObjectClass(jObj); if (!providerClass) { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); return NULL; } jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); if (!nativeHandle) { - ThrowNSException(NS_ERROR, "Failed to get nativeHandle for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); return NULL; } jlong jProvider = env->GetLongField(jObj, nativeHandle); - OIC::Service::NSProviderState state; + OIC::Service::NSProviderState state = OIC::Service::NSProviderState::DENY; if (jProvider) { - LOGD ("calling getProviderState on mNativeHandle"); - OIC::Service::NSProvider *provider = (OIC::Service::NSProvider *) (jProvider); - state = provider->getProviderState(); - } - else - { - OIC::Service::NSProvider *provider = getNativeProvider(env, jObj); - if (provider == nullptr) + NS_LOGD ("calling getProviderState on mNativeHandle"); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + try + { + state = objectHolder->get()->getProviderState(); + } + catch (OIC::Service::NSException ex) { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); + ThrowNSException(NATIVE_EXCEPTION, ex.what()); return NULL; } - LOGD ("calling getProviderState on ProviderID"); - state = provider->getProviderState(); + } + else + { + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); } jobject obj_state = getJavaProviderState(env, state); - LOGD("Provider_nativeGetProviderState - OUT"); + NS_LOGD ("Provider_nativeGetProviderState - OUT"); return obj_state; } JNIEXPORT jboolean JNICALL Java_org_iotivity_service_ns_consumer_Provider_nativeIsSubscribed (JNIEnv *env, jobject jObj) { - LOGD("nativeIsSubscribed - IN"); + NS_LOGD ("nativeIsSubscribed - IN"); jclass providerClass = env->GetObjectClass(jObj); if (!providerClass) { - ThrowNSException(NS_ERROR, "Failed to Get ObjectClass for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to Get ObjectClass for Provider"); return (jboolean)false; } jfieldID nativeHandle = env->GetFieldID(providerClass, "mNativeHandle", "J"); if (!nativeHandle) { - ThrowNSException(NS_ERROR, "Failed to get nativeHandle for Provider"); + ThrowNSException(JNI_INVALID_VALUE, "Failed to get nativeHandle for Provider"); return (jboolean)false; } jlong jProvider = env->GetLongField(jObj, nativeHandle); if (jProvider) { - LOGD ("calling isSubscribe on mNativeHandle"); - OIC::Service::NSProvider *provider = (OIC::Service::NSProvider *) (jProvider); - return (jboolean) provider->isSubscribed(); - } - else - { - OIC::Service::NSProvider *provider = getNativeProvider(env, jObj); - if (provider == nullptr) + NS_LOGD ("calling isSubscribe on mNativeHandle"); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(jProvider); + try + { + return (jboolean) objectHolder->get()->isSubscribed(); + } + catch (OIC::Service::NSException ex) { - ThrowNSException(NS_ERROR, "Provider with Given Id doesn't exist"); + ThrowNSException(NATIVE_EXCEPTION, ex.what()); return (jboolean)false; } - LOGD ("calling isSubscribe on ProviderID"); - return (jboolean) provider->isSubscribed(); + } + else + { + NS_LOGE ("Couldn't find Provider"); + ThrowNSException(JNI_NO_NATIVE_POINTER, "Fail to find native Provider"); } } +JNIEXPORT void JNICALL +Java_org_iotivity_service_ns_consumer_Provider_nativeDispose +(JNIEnv *env, jobject object) +{ + jclass cls_provider = (jclass) (env->NewLocalRef(g_cls_Provider)); + if (!cls_provider) + { + NS_LOGE ("Failed to Get ObjectClass for Provider"); + return; + } + jfieldID nativeHandle = env->GetFieldID(cls_provider, "mNativeHandle", "J"); + if (!nativeHandle) + { + NS_LOGE ("Failed to get nativeHandle for Provider"); + return; + } + jlong handle = env->GetLongField(object, nativeHandle); + JniSharedObjectHolder *objectHolder = + reinterpret_cast *>(handle); + delete objectHolder; + return; +} + // JNI OnLoad JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) { - LOGD("ConsumerService_JNI_OnLoad"); + NS_LOGD ("ConsumerService_JNI_OnLoad"); g_jvm_consumer = 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; } @@ -1297,13 +1510,13 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "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; } @@ -1311,13 +1524,13 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "org/iotivity/service/ns/consumer/Provider"); if (!localProvider) { - LOGE("Failed to get local Provider class"); + NS_LOGE ("Failed to get local Provider class"); return JNI_ERR; } g_cls_Provider = (jclass) (env->NewGlobalRef(localProvider)); if (!g_cls_Provider) { - LOGE("Failed to set Global Provider reference"); + NS_LOGE ("Failed to set Global Provider reference"); return JNI_ERR; } @@ -1325,13 +1538,13 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "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 NSSyncInfo reference"); + NS_LOGE ("Failed to set Global NSSyncInfo reference"); return JNI_ERR; } @@ -1339,13 +1552,13 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "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; } @@ -1353,26 +1566,26 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "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; } jclass localTopicState = env->FindClass( "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; } @@ -1380,13 +1593,13 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "org/iotivity/service/ns/common/Topic"); if (!localTopic) { - LOGE("Failed to get local TopicState enum"); + NS_LOGE ("Failed to get local TopicState enum"); 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; } @@ -1394,13 +1607,13 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "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; } @@ -1408,13 +1621,13 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "org/iotivity/service/ns/consumer/Provider$ProviderState"); if (!localProviderState) { - LOGE("Failed to get localProviderState Type class"); + NS_LOGE ("Failed to get localProviderState Type class"); return JNI_ERR; } g_cls_ProviderState = (jclass) (env->NewGlobalRef(localProviderState)); if (!g_cls_ProviderState) { - LOGE("Failed to set Global ProviderState Type reference"); + NS_LOGE ("Failed to set Global ProviderState Type reference"); return JNI_ERR; } @@ -1422,33 +1635,33 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) "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; } //OcRepresentation 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, "", "(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; } @@ -1469,12 +1682,12 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved) { - LOGI("ConsumerService_JNI_OnUnload"); - JNIEnv *env; + NS_LOGI ("ConsumerService_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 ; }