notification_env.AppendUnique(CPPPATH = ['include'])
notification_env.AppendUnique(CPPPATH = ['src/common'])
notification_env.AppendUnique(CPPPATH = ['src/provider'])
-notification_env.AppendUnique(CPPPATH = ['src/provider/cache/linux'])
notification_env.AppendUnique(CPPPATH = ['src/consumer'])
notification_env.AppendUnique(CPPPATH = ['../../resource/csdk/stack/include'])
notification_env.AppendUnique(CPPPATH = ['../../resource/csdk/connectivity/api'])
notification_env.AppendUnique(CPPPATH = ['src/provider/cache/linux'])
notification_env.AppendUnique(CPPPATH = ['src/consumer/cache/linux'])
-if target_os == 'android':
- notification_env.AppendUnique(CPPPATH = ['src/provider/cache/android'])
- notification_env.AppendUnique(CPPPATH = ['src/consumer/cache/android'])
+# [TO-DO] change to android DB.
+if target_os == 'android':
+ notification_env.AppendUnique(CPPPATH = ['src/provider/cache/linux'])
+ notification_env.AppendUnique(CPPPATH = ['src/consumer/cache/linux'])
notification_env.PrependUnique(LIBS = [
'octbstack',
if target_os == 'android':
notification_env.AppendUnique(CCFLAGS = ['-frtti', '-fexceptions'])
notification_env.AppendUnique(LIBS = ['gnustl_shared','log'])
- notification_env.AppendUnique(LINKFLAGS = ['-Wl,-soname,libnotification_provider.so'])
+ notification_env.AppendUnique(LINKFLAGS = ['-Wl,-soname,libnotification_provider.so'])
if not env.get('RELEASE'):
notification_env.AppendUnique(LIBS = ['log'])
msg->mContentText = OICStrdup(body);\r
msg->mSource = NULL;\r
\r
- NSSendNotification(msg);\r
+ NSSendMessage(msg);\r
\r
break;\r
\r
*/
typedef enum eAccessPolicy
{
+ NS_ACCESS_ALLOW = 0,
+ NS_ACCESS_DENY = 1,
NS_ACCEPTER_PROVIDER = 0,
NS_ACCEPTER_CONSUMER = 1,
* @param[in] message Notification message including id, title, contentText\r
* @return ::NS_OK or result code of NSResult\r
*/\r
-NSResult NSSendNotification(NSMessage *msg);\r
+NSResult NSSendMessage(NSMessage *msg);\r
\r
/**\r
* Send acceptance to consumer who subscribes the resource of notification message\r
* @param[in] message Notification message to synchronize the status\r
* @return ::NS_OK or result code of NSResult\r
*/\r
-NSResult NSProviderReadCheck(NSMessage *);\r
+NSResult NSReadCheck(NSMessage *);\r
\r
#ifdef __cplusplus\r
}\r
typedef enum eSchedulerType
{
- CALLBACK_SCHEDULER = 0,
+ INTERFACE_SCHEDULER = 0,
DISCOVERY_SCHEDULER = 1,
SUBSCRIPTION_SCHEDULER = 2,
NOTIFICATION_SCHEDULER = 3,
} NSSchedulerType;
-
typedef enum eTaskType
{
TASK_REGISTER_RESOURCE = 1000,
//\r
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
\r
-#ifndef _NS_CACHEADAPTER__H_\r
-#define _NS_CACHEADAPTER__H_\r
+#ifndef _NS_STORAGEADAPTER__H_\r
+#define _NS_STORAGEADAPTER__H_\r
\r
#include "logger.h"\r
#include <octypes.h>\r
#include "NSStructs.h"\r
#include "NSConstants.h"\r
\r
-NSCacheList * NSCacheCreate();\r
-NSCacheElement * NSCacheRead(NSCacheList * list, const char * findId);\r
-NSResult NSCacheWrite(NSCacheList * list, NSCacheElement * newObj);\r
-NSResult NSCacheDelete(NSCacheList * list, const char * delId);\r
-NSResult NSCacheDestroy(NSCacheList * list);\r
+NSCacheList * NSStorageCreate();\r
+NSCacheElement * NSStorageRead(NSCacheList * list, const char * findId);\r
+NSResult NSStorageWrite(NSCacheList * list, NSCacheElement * newObj);\r
+NSResult NSStorageDelete(NSCacheList * list, const char * delId);\r
+NSResult NSStorageDestroy(NSCacheList * list);\r
\r
-#endif /* _NS_CACHEADAPTER__H_ */\r
+#endif /* _NS_STORAGEADAPTER__H_ */\r
if (obj->mSourceId)
{
+ NS_LOG_V(DEBUG, "obj->mSourceid = %s", obj->mSourceId);
OICFree(obj->mSourceId);
obj->mSourceId = NULL;
}
newMsg->mSourceId = OICStrdup(copyMsg->mSourceId);
}
+ newMsg->mState = copyMsg->mState;
+
return newMsg;
}
return newMsg;
}
+
+void NSDuplicateSetPropertyString(OCRepPayload** msgPayload, const char * name,
+ const char * copyString)
+{
+ if(copyString)
+ {
+ OCRepPayloadSetPropString(*msgPayload, name, copyString);
+ }
+ else
+ {
+ OCRepPayloadSetNull(*msgPayload, name);
+ }
+}
+
+
+NSSync * NSGetSyncInfo(OCPayload * payload)
+{
+ NS_LOG(DEBUG, "NSBuildOICNotificationSync - IN");
+
+ if(!payload)
+ {
+ return NULL;
+ }
+ NSSync * retSync = (NSSync *)OICMalloc(sizeof(NSSync));
+ if (!retSync)
+ {
+ return NULL;
+ }
+
+ retSync->mMessageId = NULL;
+ retSync->mState = Notification_Read;
+
+ OCRepPayload * repPayload = (OCRepPayload *)payload;
+ if (!OCRepPayloadGetPropString(repPayload, NS_ATTRIBUTE_ID, &retSync->mMessageId))
+ {
+ OICFree(retSync);
+ return NULL;
+ }
+ if (!OCRepPayloadGetPropString(repPayload, NS_ATTRIBUTE_SOURCE, &retSync->mSourceId))
+ {
+ OICFree(retSync);
+ return NULL;
+ }
+ int64_t state;
+ if (!OCRepPayloadGetPropInt(repPayload, NS_ATTRIBUTE_STATE, & state))
+ {
+ OICFree(retSync->mMessageId);
+ OICFree(retSync);
+ return NULL;
+ }
+
+ retSync->mState = (NSSyncTypes) state;
+
+ NS_LOG_V(DEBUG, "Sync ID : %s", retSync->mMessageId);
+ NS_LOG_V(DEBUG, "Sync State : %d", (int) retSync->mState);
+
+ NS_LOG(DEBUG, "NSBuildOICNotificationSync - OUT");
+
+ return retSync;
+}
\r
NSResult NSFreeSync(NSSync *);\r
NSSync * NSDuplicateSync(NSSync *);\r
+NSSync * NSGetSyncInfo(OCPayload * payload);\r
\r
NSResult NSFreeConsumer(NSConsumer *);\r
NSConsumer * NSDuplicateConsumer(NSConsumer *);\r
\r
+void NSDuplicateSetPropertyString(OCRepPayload **, const char *, const char *);\r
+\r
+\r
+\r
#endif /* _NS_UTIL__H_ */\r
int type = (task->taskType == TASK_SEND_READ) ? 0 : 1;
OCRepPayloadSetPropString(payload, "ID", (char *) nsConsumer->mId);
+ OCRepPayloadSetPropString(payload, "SOURCE", (char *) nsConsumer->mSource);
OCRepPayloadSetPropInt(payload, "STATE", type);
// TODO fix param for uri
cache = *(NSGetCacheList());
if (!cache)
{
- NSCacheDestroy(cache);
+ NSStorageDestroy(cache);
}
}
obj->data = (NSCacheData *) noti;
obj->next = NULL;
- if (NS_OK != NSCacheWrite(cache, obj))
+ if (NS_OK != NSStorageWrite(cache, obj))
{
NS_LOG(ERROR, "Cache write fail");
return NS_ERROR;
if (!*(NSGetCacheList()))
{
NS_LOG(DEBUG, "Cache Init");
- cache = NSCacheCreate();
+ cache = NSStorageCreate();
cache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
if (!cache)
{
#endif // __cplusplus
#include "NSStructs.h"
-#include "NSCacheAdapter.h"
+#include "../common/NSStorageAdapter.h"
#include "NSConsumerNotification.h"
void NSDestroyCacheList();
*(NSGetCacheMutex()) = mutex;
}
-NSCacheList * NSCacheCreate()
+NSCacheList * NSStorageCreate()
{
pthread_mutex_t * mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(mutex, NULL);
return newList;
}
-NSCacheElement * NSCacheRead(NSCacheList * list, const char * findId)
+NSCacheElement * NSStorageRead(NSCacheList * list, const char * findId)
{
pthread_mutex_t * mutex = NSGetCacheMutex();
return NULL;
}
-NSResult NSCacheWrite(NSCacheList * list, NSCacheElement * newObj)
+NSResult NSStorageWrite(NSCacheList * list, NSCacheElement * newObj)
{
pthread_mutex_t * mutex = NSGetCacheMutex();
return NS_ERROR;
}
-NSResult NSCacheDelete(NSCacheList * list, const char * delId)
+NSResult NSStorageDelete(NSCacheList * list, const char * delId)
{
pthread_mutex_t * mutex = NSGetCacheMutex();
NSMessage_consumer * newMsgObj = (NSMessage_consumer *) newObj->data;
pthread_mutex_unlock(mutex);
- NSCacheElement * it = NSCacheRead(list, newMsgObj->mId);
+ NSCacheElement * it = NSStorageRead(list, newMsgObj->mId);
pthread_mutex_lock(mutex);
if (it)
return NS_OK;
}
-NSResult NSCacheDestroy(NSCacheList * list)
+NSResult NSStorageDestroy(NSCacheList * list)
{
pthread_mutex_t * mutex = NSGetCacheMutex();
#include <stdlib.h>
#include <stdbool.h>
#include <pthread.h>
-#include "NSCacheAdapter.h"
+#include "NSStorageAdapter.h"
#include "NSConsumerCommon.h"
#include "NSProviderInterface.h"\r
#include "NSProviderScheduler.h"\r
#include "NSProviderListener.h"\r
-#include "NSCacheAdapter.h"\r
#include "NSProviderSubscription.h"\r
#include "NSProviderNotification.h"\r
+#include "NSStorageAdapter.h"\r
#include "NSProviderMemoryCache.h"\r
#include "oic_malloc.h"\r
#include "oic_string.h"\r
{\r
NS_LOG(DEBUG, "Init Provider");\r
initProvider = true;\r
- NSSetSubscriptionAcceptPolicy(policy);\r
+ NSSetSubscriptionAccessPolicy(policy);\r
NSRegisterSubscribeRequestCb(subscribeRequestCb);\r
NSRegisterSyncCb(syncCb);\r
CARegisterNetworkMonitorHandler(NSProviderAdapterStateListener,\r
NSRegisterSubscribeRequestCb((NSSubscribeRequestCallback)NULL);\r
NSRegisterSyncCb((NSSyncCallback)NULL);\r
NSStopScheduler();\r
- NSCacheDestroy(consumerSubList);\r
- NSCacheDestroy(messageList);\r
+ NSStorageDestroy(consumerSubList);\r
+ NSStorageDestroy(messageList);\r
\r
initProvider = false;\r
}\r
return NS_OK;\r
}\r
\r
-NSResult NSSendNotification(NSMessage *msg)\r
+NSResult NSSendMessage(NSMessage *msg)\r
{\r
NS_LOG(DEBUG, "NSSendNotification - IN");\r
\r
return NS_OK;\r
}\r
\r
-NSResult NSProviderReadCheck(NSMessage *msg)\r
+NSResult NSReadCheck(NSMessage *msg)\r
{\r
NS_LOG(DEBUG, "NSProviderReadCheck - IN");\r
\r
return NS_OK;\r
}\r
\r
-void * NSCallbackSchedule(void * ptr)\r
+void * NSInterfaceSchedule(void * ptr)\r
{\r
if (ptr == NULL)\r
{\r
NS_LOG(DEBUG, "Create NSReponseSchedule");\r
}\r
\r
- while (NSIsRunning[CALLBACK_SCHEDULER])\r
+ while (NSIsRunning[INTERFACE_SCHEDULER])\r
{\r
- sem_wait(&NSSemaphore[CALLBACK_SCHEDULER]);\r
- pthread_mutex_lock(&NSMutex[CALLBACK_SCHEDULER]);\r
+ sem_wait(&NSSemaphore[INTERFACE_SCHEDULER]);\r
+ pthread_mutex_lock(&NSMutex[INTERFACE_SCHEDULER]);\r
\r
- if (NSHeadMsg[CALLBACK_SCHEDULER] != NULL)\r
+ if (NSHeadMsg[INTERFACE_SCHEDULER] != NULL)\r
{\r
- NSTask *node = NSHeadMsg[CALLBACK_SCHEDULER];\r
- NSHeadMsg[CALLBACK_SCHEDULER] = node->nextTask;\r
+ NSTask *node = NSHeadMsg[INTERFACE_SCHEDULER];\r
+ NSHeadMsg[INTERFACE_SCHEDULER] = node->nextTask;\r
\r
switch (node->taskType)\r
{\r
{\r
NS_LOG(DEBUG, "CASE TASK_CB_SYNC : ");\r
NSSync * sync = (NSSync*)node->taskData;\r
- NSSyncCb(sync);\r
+ NSSyncCb(NSDuplicateSync(sync));\r
+ NSFreeSync(sync);\r
break;\r
}\r
default:\r
OICFree(node);\r
}\r
\r
- pthread_mutex_unlock(&NSMutex[CALLBACK_SCHEDULER]);\r
+ pthread_mutex_unlock(&NSMutex[INTERFACE_SCHEDULER]);\r
\r
}\r
\r
NS_LOG(DEBUG, "NSEntityHandlerSyncCb - OC_REST_POST");\r
\r
NSPushQueue(NOTIFICATION_SCHEDULER, TASK_RECV_READ,\r
- NSBuildOICNotificationSync(entityHandlerRequest->payload));\r
+ NSGetSyncInfo(entityHandlerRequest->payload));\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_DELETE == entityHandlerRequest->method)\r
NS_LOG(DEBUG, "NSProviderAdapterStateListener - OUT");\r
}\r
\r
-NSSync * NSBuildOICNotificationSync(OCPayload * payload)\r
-{\r
- NS_LOG(DEBUG, "NSBuildOICNotificationSync - IN");\r
-\r
- if(!payload)\r
- {\r
- return NULL;\r
- }\r
- NSSync * retSync = (NSSync *)OICMalloc(sizeof(NSSync));\r
- if (!retSync)\r
- {\r
- return NULL;\r
- }\r
-\r
- retSync->mMessageId = NULL;\r
- retSync->mState = Notification_Read;\r
-\r
- OCRepPayload * repPayload = (OCRepPayload *)payload;\r
- if (!OCRepPayloadGetPropString(repPayload, NS_ATTRIBUTE_ID, &retSync->mMessageId))\r
- {\r
- OICFree(retSync);\r
- return NULL;\r
- }\r
- int64_t state;\r
- if (!OCRepPayloadGetPropInt(repPayload, NS_ATTRIBUTE_STATE, & state))\r
- {\r
- OICFree(retSync->mMessageId);\r
- OICFree(retSync);\r
- return NULL;\r
- }\r
-\r
- retSync->mState = (NSSyncTypes) state;\r
-\r
- NS_LOG_V(DEBUG, "Sync ID : %s", retSync->mMessageId);\r
- NS_LOG_V(DEBUG, "Sync State : %d", (int) retSync->mState);\r
-\r
- NS_LOG(DEBUG, "NSBuildOICNotificationSync - OUT");\r
-\r
- return retSync;\r
-}\r
-\r
#include "oic_string.h"\r
#include "oic_malloc.h"\r
#include "NSUtil.h"\r
+#include "NSStorageAdapter.h"\r
\r
OCEntityHandlerResult NSEntityHandlerNotificationCb(OCEntityHandlerFlag flag,\r
OCEntityHandlerRequest *entityHandlerRequest, void* callback);\r
\r
NSResult NSMakeTask(NSTaskType type, OCEntityHandlerRequest *request, NSTask * task);\r
\r
-NSSync * NSBuildOICNotificationSync(OCPayload * payload);\r
-\r
#endif /* _NS_PROVIDER_LISTENER__H_ */\r
{
NS_LOG(DEBUG, "NSInitMessageList - IN");
- messageList = NSCacheCreate();
+ messageList = NSStorageCreate();
messageList->cacheType = NS_PROVIDER_CACHE_MESSAGE;
NS_LOG(DEBUG, "NSInitMessageList - OUT");
return NS_OK;
}
-NSResult NSGetMessagePayload(NSMessage *msg, OCRepPayload** msgPayload)
+NSResult NSSetMessagePayload(NSMessage *msg, OCRepPayload** msgPayload)
{
- NS_LOG(DEBUG, "NSGetMessagePayload - IN");
+ NS_LOG(DEBUG, "NSSetMessagePayload - IN");
*msgPayload = OCRepPayloadCreate();
}
OCRepPayloadSetUri(*msgPayload, NS_COLLECTION_MESSAGE_URI);
- if(msg->mId)
- OCRepPayloadSetPropString(*msgPayload, NS_ATTRIBUTE_ID, msg->mId);
- if(msg->mTitle)
- OCRepPayloadSetPropString(*msgPayload, NS_ATTRIBUTE_TITLE, msg->mTitle);
- if(msg->mContentText)
- OCRepPayloadSetPropString(*msgPayload, NS_ATTRIBUTE_TEXT, msg->mContentText);
- if(msg->mSource)
- OCRepPayloadSetPropString(*msgPayload, NS_ATTRIBUTE_SOURCE, msg->mSource);
-
- NS_LOG(DEBUG, "NSGetMessagePayload - OUT");
+
+ NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_ID, msg->mId);
+ NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_TITLE, msg->mTitle);
+ NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_TEXT, msg->mContentText);
+ NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_SOURCE, msg->mSource);
+
+ NS_LOG(DEBUG, "NSSetMessagePayload - OUT");
return NS_OK;
}
-NSResult NSGetSyncPayload(NSSync *sync, OCRepPayload** syncPayload)
+NSResult NSSetSyncPayload(NSSync *sync, OCRepPayload** syncPayload)
{
- NS_LOG(DEBUG, "NSGetSyncPayload - IN");
+ NS_LOG(DEBUG, "NSSetSyncPayload - IN");
*syncPayload = OCRepPayloadCreate();
}
OCRepPayloadSetUri(*syncPayload, NS_COLLECTION_SYNC_URI);
- if(sync->mMessageId)
- {
- OCRepPayloadSetPropString(*syncPayload, NS_ATTRIBUTE_ID, sync->mMessageId);
- OCRepPayloadSetPropInt(*syncPayload, NS_ATTRIBUTE_STATE, sync->mState);
- }
- NS_LOG(DEBUG, "NSGetSyncPayload - OUT");
+ NSDuplicateSetPropertyString(syncPayload, NS_ATTRIBUTE_ID, sync->mMessageId);
+ NSDuplicateSetPropertyString(syncPayload, NS_ATTRIBUTE_SOURCE, sync->mSourceId);
+
+ OCRepPayloadSetPropInt(*syncPayload, NS_ATTRIBUTE_STATE, sync->mState);
+
+ NS_LOG(DEBUG, "NSSetSyncPayload - OUT");
return NS_OK;
}
-NSResult NSSendMessage(NSMessage *msg)
+NSResult NSSendNotification(NSMessage *msg)
{
NS_LOG(DEBUG, "NSSendMessage - IN");
OCRepPayload* payload;
- if (NSGetMessagePayload(msg, &payload) != NS_OK)
+ if (NSSetMessagePayload(msg, &payload) != NS_OK)
{
NS_LOG(ERROR, "fail to Get message payload");
return NS_ERROR;
}
OCRepPayload* payload;
- if (NSGetSyncPayload(sync, &payload) != NS_OK)
+ if (NSSetSyncPayload(sync, &payload) != NS_OK)
{
NS_LOG(ERROR, "Failed to allocate payload");
return NS_ERROR;
case TASK_SEND_NOTIFICATION:
{
NS_LOG(DEBUG, "CASE TASK_SEND_NOTIFICATION : ");
- NSSendMessage((NSMessage *)node->taskData);
+ NSSendNotification((NSMessage *)node->taskData);
break;
}
case TASK_SEND_READ:
NS_LOG(DEBUG, "CASE TASK_SEND_READ : ");
NSSendSync((NSSync*) node->taskData);
+ NSFreeSync((NSSync*) node->taskData);
break;
case TASK_RECV_READ:
NS_LOG(DEBUG, "CASE TASK_RECV_READ : ");
NSSendSync((NSSync*) node->taskData);
- NSPushQueue(CALLBACK_SCHEDULER, TASK_CB_SYNC, node->taskData);
+ NSPushQueue(INTERFACE_SCHEDULER, TASK_CB_SYNC, node->taskData);
break;
default:
#define _NS_PROVIDER_NOTIFICATION_H_\r
\r
#include <ocstack.h>\r
-#include "NSCacheAdapter.h"\r
#include "logger.h"\r
#include "NSProviderScheduler.h"\r
#include "NSProviderListener.h"\r
NSTask* NSHeadMsg[THREAD_COUNT];\r
NSTask* NSTailMsg[THREAD_COUNT];\r
\r
-void * NSCallbackSchedule(void *ptr);\r
+void * NSInterfaceSchedule(void *ptr);\r
void * NSDiscoverySchedule(void *ptr);\r
void * NSSubScriptionSchedule(void *ptr);\r
void * NSNotificationSchedule(void *ptr);\r
\r
switch (i)\r
{\r
- case CALLBACK_SCHEDULER:\r
+ case INTERFACE_SCHEDULER:\r
{\r
NS_LOG(DEBUG, "CASE RESPONSE_SCHEDULER :");\r
- pthread_create(&NSThread[i], NULL, NSCallbackSchedule, NULL);\r
+ pthread_create(&NSThread[i], NULL, NSInterfaceSchedule, NULL);\r
}\r
break;\r
\r
{\r
NS_LOG(DEBUG, "NSFreeData - IN");\r
\r
- if (type == CALLBACK_SCHEDULER)\r
+ if (type == INTERFACE_SCHEDULER)\r
{\r
switch (task->taskType)\r
{\r
{\r
NS_LOG(DEBUG, "NSInitSubscriptionList - IN");\r
\r
- consumerSubList = NSCacheCreate();\r
+ consumerSubList = NSStorageCreate();\r
consumerSubList->cacheType = NS_PROVIDER_CACHE_SUBSCRIBER;\r
\r
NS_LOG(DEBUG, "NSInitSubscriptionList - OUT");\r
return NS_OK;\r
}\r
\r
-NSResult NSSetSubscriptionAcceptPolicy(NSAccessPolicy policy)\r
+NSResult NSSetSubscriptionAccessPolicy(NSAccessPolicy access)\r
{\r
NS_LOG(DEBUG, "NSSetSubscriptionAcceptPolicy - IN");\r
\r
- if (policy == NS_ACCEPTER_PROVIDER)\r
+ if (access == NS_ACCESS_ALLOW)\r
{\r
NS_LOG(DEBUG, "Place Provider as a subscription accepter");\r
}\r
- else if (policy == NS_ACCEPTER_CONSUMER)\r
+ else if (access == NS_ACCESS_DENY)\r
{\r
NS_LOG(DEBUG, "Place Consumer as a subscription accepter");\r
}\r
\r
- NSSubscriptionAccepter = policy;\r
+ NSSubscriptionAccess = access;\r
\r
NS_LOG(DEBUG, "NSSetSubscriptionAcceptPolicy - OUT");\r
return NS_OK;\r
\r
int NSGetSubscriptionAccepter()\r
{\r
- return NSSubscriptionAccepter;\r
+ return NSSubscriptionAccess;\r
}\r
\r
NSResult NSSendAccessPolicyResponse(OCEntityHandlerRequest *entityHandlerRequest)\r
NS_LOG_V(DEBUG, "SubList IP[ID] = [%s]", subData->id);\r
NS_LOG_V(DEBUG, "SubList message observation ID = [%d]", subData->messageObId);\r
\r
- if (NSCacheWrite(consumerSubList, element) != NS_OK)\r
+ if (NSStorageWrite(consumerSubList, element) != NS_OK)\r
{\r
NS_LOG(DEBUG, "fail to write cache");\r
}\r
NS_LOG_V(DEBUG, "SubList IP[ID] = [%s]", subData->id);\r
NS_LOG_V(DEBUG, "SubList sync observation ID = [%d]", subData->syncObId);\r
\r
- if (NSCacheWrite(consumerSubList, element) != NS_OK)\r
+ if (NSStorageWrite(consumerSubList, element) != NS_OK)\r
{\r
NS_LOG(ERROR, "Fail to write cache");\r
}\r
NS_LOG_V(DEBUG, "SubList IP[ID] = [%s]", subData->id);\r
NS_LOG_V(DEBUG, "SubList observation ID = [%d]", subData->syncObId);\r
\r
- if (NSCacheWrite(consumerSubList, element) != NS_OK)\r
+ if (NSStorageWrite(consumerSubList, element) != NS_OK)\r
{\r
NS_LOG(ERROR, "fail to write consumer white list");\r
}\r
{\r
NS_LOG(DEBUG, "NSAskAcceptanceToUser - IN");\r
\r
- NSPushQueue(CALLBACK_SCHEDULER, TASK_CB_SUBSCRIPTION, entityHandlerRequest);\r
+ NSPushQueue(INTERFACE_SCHEDULER, TASK_CB_SUBSCRIPTION, entityHandlerRequest);\r
\r
NS_LOG(DEBUG, "NSAskAcceptanceToUser - OUT");\r
}\r
OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_ID, "0000-0000-0000-0000");\r
OCRepPayloadSetPropBool(payload, NS_ATTRIBUTE_ACCPETANCE, accepted);\r
\r
- NSCacheElement * element = NSCacheRead(consumerSubList, id);\r
+ NSCacheElement * element = NSStorageRead(consumerSubList, id);\r
\r
if(element == NULL)\r
{\r
element->data = (void*) subData;\r
element->next = NULL;\r
\r
- if (NSCacheWrite(consumerSubList, element) != NS_OK)\r
+ if (NSStorageWrite(consumerSubList, element) != NS_OK)\r
{\r
NS_LOG(ERROR, "fail to write consumer white list");\r
}\r
#include "NSConstants.h"\r
#include "NSProviderScheduler.h"\r
#include "NSProviderResource.h"\r
-#include "NSCacheAdapter.h"\r
#include "NSProviderMemoryCache.h"\r
#include "oic_string.h"\r
+#include "oic_malloc.h"\r
\r
-NSAccessPolicy NSSubscriptionAccepter;\r
+NSAccessPolicy NSSubscriptionAccess;\r
NSCacheList * consumerSubList;\r
\r
NSResult NSInitSubscriptionList();\r
-NSResult NSSetSubscriptionAcceptPolicy(NSAccessPolicy policy);\r
+NSResult NSSetSubscriptionAccessPolicy(NSAccessPolicy policy);\r
int NSGetSubscriptionAccepter();\r
NSResult NSSendAccessPolicyResponse(OCEntityHandlerRequest *entityHandlerRequest);\r
void NSHandleSubscription(OCEntityHandlerRequest *entityHandlerRequest, NSResourceType resourceType);\r
// limitations under the License.\r
//\r
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
+\r
#include "NSProviderMemoryCache.h"\r
\r
-NSCacheList * NSCacheCreate()\r
+NSCacheList * NSStorageCreate()\r
{\r
pthread_mutex_lock(&NSCacheMutex);\r
NSCacheList * newList = (NSCacheList *) OICMalloc(sizeof(NSCacheList));\r
return newList;\r
}\r
\r
-NSCacheElement * NSCacheRead(NSCacheList * list, const char * findId)\r
+NSCacheElement * NSStorageRead(NSCacheList * list, const char * findId)\r
{\r
pthread_mutex_lock(&NSCacheMutex);\r
\r
}\r
\r
pthread_mutex_unlock(&NSCacheMutex);\r
- NSCacheElement * it = NSCacheRead(list, id);\r
+ NSCacheElement * it = NSStorageRead(list, id);\r
pthread_mutex_lock(&NSCacheMutex);\r
\r
if (it)\r
return NS_ERROR;\r
}\r
\r
-NSResult NSCacheWrite(NSCacheList * list, NSCacheElement * newObj)\r
+NSResult NSStorageWrite(NSCacheList * list, NSCacheElement * newObj)\r
{\r
pthread_mutex_lock(&NSCacheMutex);\r
\r
NSCacheSubData * subData = (NSCacheSubData *) newObj->data;\r
\r
pthread_mutex_unlock(&NSCacheMutex);\r
- NSCacheElement * it = NSCacheRead(list, subData->id);\r
+ NSCacheElement * it = NSStorageRead(list, subData->id);\r
pthread_mutex_lock(&NSCacheMutex);\r
\r
if (it)\r
\r
NSCacheMsgData * msgData = (NSCacheMsgData *) newObj->data;\r
\r
- NSCacheElement * it = NSCacheRead(list, msgData->id);\r
+ NSCacheElement * it = NSStorageRead(list, msgData->id);\r
if (it)\r
{\r
NSCacheMsgData * itData = (NSCacheMsgData *) it->data;\r
return NS_OK;\r
}\r
\r
-NSResult NSCacheDelete(NSCacheList * list, const char * delId)\r
+NSResult NSStorageDelete(NSCacheList * list, const char * delId)\r
{\r
pthread_mutex_lock(&NSCacheMutex);\r
NSCacheElement * prev = list->head;\r
return NS_OK;\r
}\r
\r
-NSResult NSCacheDestroy(NSCacheList * list)\r
+NSResult NSStorageDestroy(NSCacheList * list)\r
{\r
NSCacheElement * iter = list->head;\r
NSCacheElement * next = NULL;\r
#ifndef _NS_PROVIDER_CACHEADAPTER__H_\r
#define _NS_PROVIDER_CACHEADAPTER__H_\r
\r
-#include <stdbool.h>\r
-#include <octypes.h>\r
#include <pthread.h>\r
-#include "logger.h"\r
-#include "ocstack.h"\r
-#include "ocpayload.h"\r
-#include "NSStructs.h"\r
+#include <stdbool.h>\r
+#include <string.h>\r
+\r
+#include "NSCommon.h"\r
#include "NSConstants.h"\r
-#include "NSCacheAdapter.h"\r
+#include "NSStructs.h"\r
#include "oic_malloc.h"\r
#include "oic_string.h"\r
+#include "NSStorageAdapter.h"\r
#include "NSUtil.h"\r
\r
NSResult NSProviderDeleteCacheData(NSCacheType, void *);\r
msg->mId = strdup(std::string("NeverCallNotifyOnConsumerByAcceptIsFalse").c_str());
msg->mTitle = strdup(std::string("Title").c_str());
msg->mContentText = strdup(std::string("ContentText").c_str());
- NSSendNotification(msg);
+ NSSendMessage(msg);
{
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);
msg->mId = strdup(std::string("ExpectCallNotifyOnConsumerByAcceptIsTrue").c_str());
msg->mTitle = strdup(std::string("Title").c_str());
msg->mContentText = strdup(std::string("ContentText").c_str());
- NSSendNotification(msg);
+ NSSendMessage(msg);
{
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);