if target_os in ['linux']:
SConscript('scene-manager/SConscript')
- if target_os in ['linux']:
+ if target_os in ['linux','android']:
SConscript('notification/SConscript')
# Build simulator module
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 = ['../../resource/csdk/stack/include'])
notification_env.AppendUnique(CPPPATH = ['../../resource/csdk/connectivity/api'])
NSResult NSStartPresence()\r
{\r
OIC_LOG(INFO, DISCOVERY_TAG, "NSStartPresence()");\r
+ NS_LOG(INFO, "NSStartPresence()");\r
\r
if (OCStartPresence(0) != OC_STACK_OK)\r
{\r
OIC_LOG(INFO, DISCOVERY_TAG, "NSStartPresence() NS_ERROR");\r
+ NS_LOG(INFO, "NSStartPresence() NS_ERROR");\r
return NS_ERROR;\r
}\r
\r
OIC_LOG(INFO, DISCOVERY_TAG, "NSStartPresence() NS_OK");\r
+ NS_LOG(INFO, "NSStartPresence() NS_OK");\r
return NS_OK;\r
}\r
\r
NSResult NSStopPresence()\r
{\r
OIC_LOG(INFO, DISCOVERY_TAG, "NSStopPresence()");\r
+ NS_LOG(INFO, "NSStopPresence()");\r
\r
if (OCStopPresence() != OC_STACK_OK)\r
{\r
OIC_LOG(INFO, DISCOVERY_TAG, "NSStopPresence() NS_ERROR");\r
+ NS_LOG(INFO, "NSStopPresence() NS_ERROR");\r
return NS_ERROR;\r
}\r
\r
OIC_LOG(INFO, DISCOVERY_TAG, "NSStopPresence() NS_OK");\r
+ NS_LOG(INFO, "NSStopPresence() NS_OK");\r
return NS_OK;\r
}\r
\r
if (ptr == NULL)\r
{\r
OIC_LOG(INFO, DISCOVERY_TAG, "Create NSDiscoverySchedule");\r
+ NS_LOG(INFO, "Create NSDiscoverySchedule");\r
}\r
\r
while (NSIsRunning[DISCOVERY_SCHEDULER])\r
switch (node->taskType)\r
{\r
case TASK_START_PRESENCE:\r
+ NS_LOG(INFO, "CASE TASK_START_PRESENCE : ");\r
NSStartPresence();\r
break;\r
case TASK_STOP_PRESENCE:\r
+ NS_LOG(INFO, "CASE TASK_STOP_PRESENCE : ");\r
NSStopPresence();\r
break;\r
case TASK_REGISTER_RESOURCE:\r
+ NS_LOG(INFO, "CASE TASK_REGISTER_RESOURCE : ");\r
NSRegisterResource();\r
break;\r
default:\r
\r
void NSRegisterSubscribeRequestCb(NSSubscribeRequestCallback subscribeRequestCb)\r
{\r
+ NS_LOG(DEBUG, "NSRegisterSubscribeRequestCb - IN");\r
g_subscribeRequestCb = subscribeRequestCb;\r
+ NS_LOG(DEBUG, "NSRegisterSubscribeRequestCb - OUT");\r
}\r
\r
void NSRegisterSyncCb(NSSyncCallback syncCb)\r
{\r
+ NS_LOG(DEBUG, "NSRegisterSyncCb - IN");\r
g_syncCb = syncCb;\r
+ NS_LOG(DEBUG, "NSRegisterSyncCb - OUT");\r
}\r
\r
void NSSubscribeRequestCb(NSConsumer *consumer)\r
{\r
+ NS_LOG(DEBUG, "NSSubscribeRequestCb - IN");\r
g_subscribeRequestCb(consumer);\r
+ NS_LOG(DEBUG, "NSSubscribeRequestCb - OUT");\r
}\r
\r
void NSSyncCb(NSSync *sync)\r
{\r
+ NS_LOG(DEBUG, "NSSyncCb - IN");\r
g_syncCb(sync);\r
+ NS_LOG(DEBUG, "NSSyncCb - OUT");\r
}\r
\r
NSResult NSStartProvider(NSAccessPolicy policy, NSSubscribeRequestCallback subscribeRequestCb,\r
NSSyncCallback syncCb)\r
{\r
OIC_LOG(INFO, INTERFACE_TAG, "Notification Service Start Provider..");\r
-\r
+ NS_LOG(DEBUG, "NSStartProvider - IN");\r
NSSetSubscriptionAcceptPolicy(policy);\r
\r
if (!initProvider)\r
{\r
+ NS_LOG(DEBUG, "Init Provider");\r
initProvider = true;\r
\r
NSSetList();\r
NSPushQueue(DISCOVERY_SCHEDULER, TASK_START_PRESENCE, NULL);\r
NSPushQueue(DISCOVERY_SCHEDULER, TASK_REGISTER_RESOURCE, NULL);\r
\r
+ NS_LOG(DEBUG, "NSStartProvider - OUT");\r
+\r
return NS_OK;\r
}\r
\r
void NSSetList()\r
{\r
+ NS_LOG(DEBUG, "NSSetList - IN");\r
pthread_mutex_init(&NSCacheMutex, NULL);\r
NSInitSubscriptionList();\r
NSInitMessageList();\r
+ NS_LOG(DEBUG, "NSSetList - OUT");\r
}\r
\r
NSResult NSStopProvider()\r
{\r
+ NS_LOG(DEBUG, "NSStopProvider - IN");\r
NSRegisterSubscribeRequestCb((NSSubscribeRequestCallback)NULL);\r
NSRegisterSyncCb((NSSyncCallback)NULL);\r
initProvider = false;\r
+ NS_LOG(DEBUG, "NSStopProvider - OUT");\r
return NS_OK;\r
}\r
\r
NSResult NSSendNotification(NSMessage *msg)\r
{\r
OIC_LOG(INFO, INTERFACE_TAG, "Send Notification");\r
+ NS_LOG(DEBUG, "NSSendNotification - IN");\r
NSPushQueue(NOTIFICATION_SCHEDULER, TASK_SEND_NOTIFICATION, msg);\r
+ NS_LOG(DEBUG, "NSSendNotification - OUT");\r
return NS_OK;\r
}\r
\r
NSResult NSProviderReadCheck(NSMessage *msg)\r
{\r
OIC_LOG(INFO, INTERFACE_TAG, "Read Sync");\r
+ NS_LOG(DEBUG, "NSProviderReadCheck - IN");\r
NSPushQueue(NOTIFICATION_SCHEDULER, TASK_SEND_READ, msg);\r
+ NS_LOG(DEBUG, "NSProviderReadCheck - OUT");\r
return NS_OK;\r
}\r
\r
NSResult NSAccept(NSConsumer *consumer, bool accepted)\r
{\r
OIC_LOG(INFO, INTERFACE_TAG, "Response Acceptance");\r
+ NS_LOG(DEBUG, "NSAccept - IN");\r
\r
if(accepted)\r
{\r
+ NS_LOG(DEBUG, "accepted is true - ALLOW");\r
NSPushQueue(SUBSCRIPTION_SCHEDULER, TASK_SEND_ALLOW, consumer);\r
+\r
}\r
else\r
{\r
+ NS_LOG(DEBUG, "accepted is false - DENY");\r
NSPushQueue(SUBSCRIPTION_SCHEDULER, TASK_SEND_DENY, consumer);\r
}\r
\r
+ NS_LOG(DEBUG, "NSAccept - OUT");\r
return NS_OK;\r
}\r
\r
if (ptr == NULL)\r
{\r
OIC_LOG(INFO, INTERFACE_TAG, "Init NSResponseSchedule");\r
+ NS_LOG(DEBUG, "Create NSReponseSchedule");\r
}\r
\r
while (NSIsRunning[RESPONSE_SCHEDULER])\r
{\r
case TASK_CB_SUBSCRIPTION:\r
{\r
- printf("before - TASK_CB_SUBSCRIPTION :\n");\r
+ NS_LOG(DEBUG, "CASE TASK_CB_SUBSCRIPTION : ");\r
OCEntityHandlerRequest * request = (OCEntityHandlerRequest*)node->taskData;\r
NSConsumer consumer;\r
\r
consumer.mUserData = obId;\r
\r
NSSubscribeRequestCb(&consumer);\r
- printf("after - TASK_CB_SUBSCRIPTION :\n");\r
+\r
break;\r
}\r
case TASK_CB_SYNC:\r
{\r
+ NS_LOG(DEBUG, "CASE TASK_CB_SYNC : ");\r
NSSync * sync = (NSSync*)node->taskData;\r
NSSyncCb(sync);\r
break;\r
OCEntityHandlerRequest *entityHandlerRequest, void* callback)\r
{\r
OIC_LOG_V (INFO, LISTENER_TAG, "Inside entity handler - flags: 0x%x", flag);\r
+ NS_LOG(DEBUG, "NSEntityHandlerNotificationCb - IN");\r
\r
OCEntityHandlerResult ehResult = OC_EH_OK;\r
OCEntityHandlerResponse response =\r
if (OC_REST_GET == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_GET from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerNotificationCb - OC_REST_GET");\r
\r
NSPushQueue(SUBSCRIPTION_SCHEDULER, TASK_SEND_POLICY, (void *)entityHandlerRequest);\r
ehResult = OC_EH_OK;\r
else if (OC_REST_PUT == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_PUT from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerNotificationCb - OC_REST_PUT");\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_POST == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_POST from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerNotificationCb - OC_REST_POST");\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_DELETE == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_DELETE from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerNotificationCb - OC_REST_DELETE");\r
ehResult = OC_EH_OK;\r
}\r
else\r
}\r
\r
OCPayloadDestroy(response.payload);\r
+ NS_LOG(DEBUG, "NSEntityHandlerNotificationCb - OUT");\r
return ehResult;\r
}\r
\r
OCEntityHandlerRequest *entityHandlerRequest, void* callback)\r
{\r
OIC_LOG_V (INFO, LISTENER_TAG, "Inside entity handler - flags: 0x%x", flag);\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - IN");\r
\r
OCEntityHandlerResult ehResult = OC_EH_OK;\r
OCEntityHandlerResponse response =\r
if (OC_REST_GET == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_GET from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - OC_REST_GET");\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_PUT == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_PUT from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - OC_REST_PUT");\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_POST == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_POST from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - OC_REST_POST");\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_DELETE == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_DELETE from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - OC_REST_DELETE");\r
ehResult = OC_EH_OK;\r
}\r
else\r
if (flag & OC_OBSERVE_FLAG)\r
{\r
OIC_LOG(INFO, LISTENER_TAG, "Flag includes OC_OBSERVE_FLAG");\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - OC_OBSERVE_FLAG");\r
\r
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_OBSERVE_REGISTER from client");\r
-\r
- printf("NS_ register message observerID : %d\n", entityHandlerRequest->obsInfo.obsId);\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - OC_OBSERVE_REGISTER");\r
+ NS_LOG_V(DEBUG, "NSEntityHandlerMessageCb\n"\r
+ "Register message observerID : %d\n", entityHandlerRequest->obsInfo.obsId);\r
NSPushQueue(SUBSCRIPTION_SCHEDULER, TASK_RECV_SUBSCRIPTION, entityHandlerRequest);\r
-\r
}\r
}\r
\r
OCPayloadDestroy(response.payload);\r
+ NS_LOG(DEBUG, "NSEntityHandlerMessageCb - OUT");\r
return ehResult;\r
}\r
\r
OCEntityHandlerRequest *entityHandlerRequest, void* callback)\r
{\r
OIC_LOG_V (INFO, LISTENER_TAG, "Inside entity handler - flags: 0x%x", flag);\r
-\r
+ NS_LOG(DEBUG, "NSEntityHandlerSyncCb - IN");\r
OCEntityHandlerResult ehResult = OC_EH_OK;\r
OCEntityHandlerResponse response =\r
{ 0, 0, OC_EH_ERROR, 0, 0,\r
if (OC_REST_GET == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_GET from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerSyncCb - OC_REST_GET");\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_PUT == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_PUT from client");\r
+ NS_LOG(DEBUG, "NSEntityHandlerSyncCb - OC_REST_PUT");\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_POST == entityHandlerRequest->method)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_REST_POST from client");\r
-\r
- NSPushQueue(NOTIFICATION_SCHEDULER, TASK_SEND_READ, NSBuildOICNotificationSync(entityHandlerRequest->payload));\r
+ NS_LOG(DEBUG, "NSEntityHandlerSyncCb - OC_REST_POST");\r
+ NSPushQueue(NOTIFICATION_SCHEDULER, TASK_SEND_READ,\r
+ NSBuildOICNotificationSync(entityHandlerRequest->payload));\r
ehResult = OC_EH_OK;\r
}\r
else if (OC_REST_DELETE == entityHandlerRequest->method)\r
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "Received OC_OBSERVE_REGISTER from client");\r
- printf("NS_ register sync observerID : %d\n", entityHandlerRequest->obsInfo.obsId);\r
+ NS_LOG(DEBUG, "NSEntityHandlerSyncCb - OC_OBSERVE_REGISTER");\r
+ NS_LOG_V(DEBUG, "NSEntityHandlerSyncCb\n - "\r
+ "Register message observerID : %d\n", entityHandlerRequest->obsInfo.obsId);\r
NSPushQueue(SUBSCRIPTION_SCHEDULER, TASK_SYNC_SUBSCRIPTION, entityHandlerRequest);\r
}\r
}\r
\r
OCPayloadDestroy(response.payload);\r
+ NS_LOG(DEBUG, "NSEntityHandlerSyncCb - OUT");\r
return ehResult;\r
}\r
\r
(void)remote_address;\r
\r
OIC_LOG (INFO, LISTENER_TAG, "Connection State Changed");\r
+ NS_LOG(DEBUG, "NSProviderConnectionStateListener - IN");\r
\r
if (connected)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "CONNECTED");\r
+ NS_LOG(DEBUG, "CONNECTED");\r
\r
// Set Connection State\r
NSSetProviderConnectionState(CONNECTED);\r
// Start Presence\r
NSPushQueue(DISCOVERY_SCHEDULER, TASK_START_PRESENCE, NULL);\r
}\r
+\r
+ NS_LOG(DEBUG, "NSProviderConnectionStateListener - OUT");\r
}\r
\r
void NSProviderAdapterStateListener(CATransportAdapter_t adapter, bool enabled)\r
(void)adapter;\r
\r
OIC_LOG (INFO, LISTENER_TAG, "Adapter State Changed");\r
+ NS_LOG(DEBUG, "NSProviderAdapterStateListener - IN");\r
\r
if (enabled)\r
{\r
OIC_LOG (INFO, LISTENER_TAG, "CONNECTED");\r
+ NS_LOG(DEBUG, "CONNECTED");\r
\r
// Set Connection State\r
NSSetProviderConnectionState(CONNECTED);\r
// Start Presence\r
NSPushQueue(DISCOVERY_SCHEDULER, TASK_START_PRESENCE, NULL);\r
}\r
+\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
OIC_LOG_V(DEBUG, LISTENER_TAG, "Sync ID : %s", retSync->mMessageId);\r
OIC_LOG_V(DEBUG, LISTENER_TAG, "Sync State : %d", (int) retSync->mState);\r
\r
+ NS_LOG(DEBUG, "NSBuildOICNotificationSync - OUT");\r
+\r
return retSync;\r
}\r
\r
NSResult NSMakeTask(NSTaskType type, OCEntityHandlerRequest *request, NSTask * task)\r
{\r
+ NS_LOG(DEBUG, "NSMakeTask - IN");\r
+\r
task = (NSTask*) OICMalloc(sizeof(NSTask));\r
if (!task)\r
{\r
task->taskData = request;\r
task->nextTask = NULL;\r
\r
+ NS_LOG(DEBUG, "NSMakeTask - OUT");\r
return NS_OK;\r
}\r
\r
NSResult NSInitMessageList()
{
+ NS_LOG(DEBUG, "NSInitMessageList - IN");
+
messageList = NSCacheCreate();
messageList->cacheType = NS_PROVIDER_CACHE_MESSAGE;
+
+ NS_LOG(DEBUG, "NSInitMessageList - OUT");
return NS_OK;
}
NSResult NSGetMessagePayload(NSMessage *msg, OCRepPayload** msgPayload)
{
+ NS_LOG(DEBUG, "NSGetMessagePayload - IN");
+
*msgPayload = OCRepPayloadCreate();
if (!*msgPayload)
OCRepPayloadSetPropString(*msgPayload, NS_ATTRIBUTE_TITLE, msg->mTitle);
OCRepPayloadSetPropString(*msgPayload, NS_ATTRIBUTE_TEXT, msg->mContentText);
+ NS_LOG(DEBUG, "NSGetMessagePayload - OUT");
return NS_OK;
}
NSResult NSGetSyncPayload(NSSync *sync, OCRepPayload** syncPayload)
{
+ NS_LOG(DEBUG, "NSGetSyncPayload - IN");
+
*syncPayload = OCRepPayloadCreate();
if (!*syncPayload)
OCRepPayloadSetPropString(*syncPayload, NS_ATTRIBUTE_ID, sync->mMessageId);
OCRepPayloadSetPropInt(*syncPayload, NS_ATTRIBUTE_STATE, sync->mState);
+ NS_LOG(DEBUG, "NSGetSyncPayload - OUT");
return NS_OK;
}
NSResult NSSendMessage(NSMessage *msg)
{
OIC_LOG(DEBUG, NOTIFICATION_TAG, "Send Notification Message to consumer");
- int i;
- // Set Resource and get resource handle
+ NS_LOG(DEBUG, "NSSendMessage - IN");
+
OCResourceHandle rHandle;
- OCObservationId obArray[255] =
- { 0, };
- int obCount = 0;
+ OCObservationId obArray[255] = { 0, };
+ int obCount = 0, i;
+
if (NSPutMessageResource(msg, &rHandle) != NS_OK)
{
OIC_LOG(ERROR, NOTIFICATION_TAG, PCF("Fail to put notification resource"));
+ NS_LOG(DEBUG, "fail to Put notification resource");
return NS_ERROR;
}
if (consumerSubList->head == NULL)
{
- printf("printf - no observers (consumerSubList->head == NULL)\n");
OIC_LOG(ERROR, NOTIFICATION_TAG, PCF("no observers"));
+ NS_LOG(ERROR, "SubList->head is NULL, empty SubList");
return NS_ERROR;
}
OCRepPayload* payload;
- printf("printf - no observers - 1\n");
+
if (NSGetMessagePayload(msg, &payload) != NS_OK)
{
- printf("printf - no observers - 2\n");
OIC_LOG(ERROR, NOTIFICATION_TAG, PCF("Failed to allocate payload"));
+ NS_LOG(ERROR, "fail to Get message payload");
return NS_ERROR;
}
- printf("printf - no observers - 3\n");
NSCacheElement * it = consumerSubList->head;
- printf("printf - no observers - 4\n");
+
while (it)
{
- printf("printf - no observers - 5\n");
NSCacheSubData * subData = (NSCacheSubData *) it->data;
- printf("NS_ subData->id = %s\n", subData->id);
- printf("NS_ subData->messageId = %d\n", subData->messageObId);
- printf("NS_ subData->obID = %d\n", subData->syncObId);
- printf("NS_ subData->isWhite = %d\n", subData->isWhite);
+ NS_LOG_V(DEBUG, "subData->id = %s", subData->id);
+ NS_LOG_V(DEBUG, "subData->messageId = %d", subData->messageObId);
+ NS_LOG_V(DEBUG, "subData->obID = %d", subData->syncObId);
+ NS_LOG_V(DEBUG, "subData->isWhite = %d", subData->isWhite);
- printf("printf - no observers - 6\n");
if (subData->isWhite)
{
- printf("printf - no observers - 7\n");
obArray[obCount++] = subData->messageObId;
- printf("printf - no observers - 8\n");
}
it = it->next;
}
- printf("printf - no observers - 9\n");
+
+ NS_LOG_V(DEBUG, "observer Count = %d", obCount);
+
for (i = 0; i < obCount; ++i)
{
- printf("NS_ -------------------------------------------------------message\n");
- printf("NS_ whiteList->idList[%d] = %d\n", i, obArray[i]);
- printf("NS_ -------------------------------------------------------message\n");
+ NS_LOG(DEBUG, "-------------------------------------------------------message\n");
+ NS_LOG_V(DEBUG, "SubScription WhiteList[%d] = %d", i, obArray[i]);
+ NS_LOG(DEBUG, "-------------------------------------------------------message\n");
}
- printf("printf - no observers - 10\n");
OCStackResult ocstackResult = OCNotifyListOfObservers(rHandle, obArray, obCount, payload,
OC_LOW_QOS);
- printf("NS_ message ocstackResult = %d\n", ocstackResult);
+
+ NS_LOG_V(DEBUG, "Message ocstackResult = %d", ocstackResult);
if (ocstackResult != OC_STACK_OK)
{
- printf("printf - no observers - 11\n");
OIC_LOG(ERROR, NOTIFICATION_TAG, "fail to send message");
+ NS_LOG(ERROR, "fail to send message");
OCRepPayloadDestroy(payload);
return NS_ERROR;
-
}
- printf("printf - no observers - 12\n");
OCRepPayloadDestroy(payload);
+ NS_LOG(DEBUG, "NSSendMessage - OUT");
+
return NS_OK;
}
NSResult NSSendSync(NSSync *sync)
{
OIC_LOG(DEBUG, NOTIFICATION_TAG, "Send Notification Sync to consumer");
+ NS_LOG(DEBUG, "NSSendSync - IN");
OCObservationId obArray[255] = { 0, };
int obCount = 0;
}
- // Send sync to subscribers
-
OCRepPayload* payload;
if (NSGetSyncPayload(sync, &payload) != NS_OK)
{
return NS_ERROR;
}
- // Notify sync to subscribers
-
for (i = 0; i < obCount; ++i)
{
- printf("NS_ -------------------------------------------------------message\n");
- printf("NS_ whiteList->idList[%d] = %d\n", i, obArray[i]);
- printf("NS_ -------------------------------------------------------message\n");
+ NS_LOG(DEBUG, "-------------------------------------------------------message\n");
+ NS_LOG_V(DEBUG, "Sync WhiteList[%d] = %d", i, obArray[i]);
+ NS_LOG(DEBUG, "-------------------------------------------------------message\n");
}
OCStackResult ocstackResult = OCNotifyListOfObservers(rHandle, obArray,
obCount, payload, OC_LOW_QOS);
- printf("NS_ sync ocstackResult = %d\n", ocstackResult);
+ NS_LOG_V(DEBUG, "Sync ocstackResult = %d", ocstackResult);
+
if (ocstackResult != OC_STACK_OK)
{
OIC_LOG(ERROR, NOTIFICATION_TAG, "fail to send Sync");
return NS_ERROR;
}
+
OCRepPayloadDestroy(payload);
+ NS_LOG(DEBUG, "NSSendSync - OUT");
return NS_OK;
}
if (ptr == NULL)
{
OIC_LOG(DEBUG, NOTIFICATION_TAG, "Create NSNotifiactionSchedule");
+ NS_LOG(DEBUG, "Create NSNotifiactionSchedule");
}
while (NSIsRunning[NOTIFICATION_SCHEDULER])
{
case TASK_SEND_NOTIFICATION:
{
+ NS_LOG(DEBUG, "CASE TASK_SEND_NOTIFICATION : ");
NSMessage * nsMsg = node->taskData;
NSSendMessage(nsMsg);
break;
}
case TASK_SEND_READ:
+ NS_LOG(DEBUG, "CASE TASK_SEND_READ : ");
NSSendSync((NSSync*) node->taskData);
break;
case TASK_RECV_READ:
+ NS_LOG(DEBUG, "CASE TASK_RECV_READ : ");
NSSendSync((NSSync*) node->taskData);
NSPushQueue(RESPONSE_SCHEDULER, TASK_CB_SYNC, node->taskData);
break;
default:
OIC_LOG(ERROR, NOTIFICATION_TAG, "Unknown type message");
+ NS_LOG(ERROR, "Unknow type message");
break;
}
NSResult NSCreateResource(char *uri)
{
+ NS_LOG(DEBUG, "NSCreateResource - IN");
if (!uri)
{
OIC_LOG(ERROR, RESOURCE_TAG, "Resource URI cannot be NULL");
+ NS_LOG(NS_ERROR, "Resource URI cannot be NULL");
return NS_ERROR;
}
NSEntityHandlerNotificationCb, NULL, OC_DISCOVERABLE) != OC_STACK_OK)
{
OIC_LOG(ERROR, RESOURCE_TAG, PCF("Fail to Create Notification Resource"));
+ NS_LOG(NS_ERROR, "Fail to Create Notification Resource");
return NS_ERROR;
}
}
NSMessageUri, NSEntityHandlerMessageCb, NULL, OC_OBSERVABLE) != OC_STACK_OK)
{
OIC_LOG(ERROR, RESOURCE_TAG, PCF("Fail to Create Notification Message Resource"));
+ NS_LOG(NS_ERROR, "Fail to Create Notification Message Resource");
return NS_ERROR;
}
}
NSEntityHandlerSyncCb, NULL, OC_OBSERVABLE) != OC_STACK_OK)
{
OIC_LOG(ERROR, RESOURCE_TAG, PCF("Fail to Create Notification Sync Resource"));
+ NS_LOG(NS_ERROR, "Fail to Create Notification Sync Resource");
return NS_ERROR;
}
}
else
{
OIC_LOG(ERROR, RESOURCE_TAG, PCF("Fail to create resource with invalid URI"));
+ NS_LOG(DEBUG, "Fail to create resource with invalid URI");
return NS_ERROR;
}
+ NS_LOG(DEBUG, "NSCreateResource - OUT");
return NS_OK;
}
NSResult NSRegisterResource()
{
OIC_LOG(INFO, RESOURCE_TAG, "NSRegisterResource");
+ NS_LOG(DEBUG, "NSRegisterResource - IN");
if (NSCreateResource(NSSyncUri) != NS_OK)
{
OIC_LOG(ERROR, RESOURCE_TAG, PCF("Fail to register Sync Resource"));
+ NS_LOG(DEBUG, "Fail to register Sync Resource");
return NS_ERROR;
}
if (NSCreateResource(NSMessageUri) != NS_OK)
{
OIC_LOG(ERROR, RESOURCE_TAG, PCF("Fail to register Message Resource"));
+ NS_LOG(DEBUG, "Fail to register Message Resource");
return NS_ERROR;
}
if (NSCreateResource(NSUri) != NS_OK)
{
OIC_LOG(ERROR, RESOURCE_TAG, PCF("Fail to register Notification Resource"));
+ NS_LOG(DEBUG, "Fail to register Notification Resource");
return NS_ERROR;
}
+ NS_LOG(DEBUG, "NSRegisterResource - OUT");
return NS_OK;
}
NSResult NSPutNotificationResource(int accepter, OCResourceHandle * handle)
{
+ NS_LOG(DEBUG, "NSPutNotificationResource - IN");
+
NotificationResource.accepter = accepter;
NotificationResource.message_uri = NSMessageUri;
NotificationResource.sync_uri = NSSyncUri;
*handle = NotificationResource.handle;
+ NS_LOG(DEBUG, "NSPutNotificationResource - OUT");
return NS_OK;
}
NSResult NSPutMessageResource(NSMessage *msg, OCResourceHandle * handle)
{
OIC_LOG(INFO, RESOURCE_TAG, "Put notification message to Resource");
+ NS_LOG(DEBUG, "NSPutMessageResource - IN");
if(msg != NULL)
{
- printf("msg is not null\n");
+ NS_LOG(ERROR, "NSMessage is valid");
NotificationMessageResource.id = strdup(msg->mId);
NotificationMessageResource.title = strdup(msg->mTitle);
NotificationMessageResource.body = strdup(msg->mContentText);
}
else
{
- printf("msg is null\n");
+ NS_LOG(ERROR, "NSMessage is NULL");
}
*handle = NotificationMessageResource.handle;
+ NS_LOG(DEBUG, "NSPutMessageResource - OUT");
return NS_OK;
}
NSResult NSPutSyncResource(NSSync *sync, OCResourceHandle * handle)
{
OIC_LOG(INFO, RESOURCE_TAG, "Put notification sync to Resource");
+ NS_LOG(DEBUG, "NSPutSyncResource - IN");
- //should be implementation
(void) sync;
*handle = NotificationSyncResource.handle;
+ NS_LOG(DEBUG, "NSPutSyncResource - OUT");
return NS_OK;
}
bool NSInitScheduler()\r
{\r
OIC_LOG(INFO, SCHEDULER_TAG, "NSInitScheduler()");\r
+ NS_LOG(DEBUG, "NSInitScheduler - IN");\r
\r
int i = 0;\r
- // NsQsStopScheduler(ALL_SCHEDULER);\r
\r
for (i = 0; i < THREAD_COUNT; i++)\r
{\r
sem_init(&(NSSemaphore[i]), 0, 0);\r
}\r
\r
+ NS_LOG(DEBUG, "NSInitScheduler - OUT");\r
return true;\r
}\r
\r
{\r
case RESPONSE_SCHEDULER:\r
{\r
+ NS_LOG(DEBUG, "CASE RESPONSE_SCHEDULER :");\r
pthread_create(&NSThread[i], NULL, NSResponseSchedule, NULL);\r
}\r
break;\r
\r
case DISCOVERY_SCHEDULER:\r
{\r
+ NS_LOG(DEBUG, "CASE DISCOVERY_SCHEDULER :");\r
pthread_create(&NSThread[i], NULL, NSDiscoverySchedule, NULL);\r
}\r
break;\r
\r
case SUBSCRIPTION_SCHEDULER:\r
{\r
+ NS_LOG(DEBUG, "CASE SUBSCRIPTION_SCHEDULER :");\r
pthread_create(&NSThread[i], NULL, NSSubScriptionSchedule, NULL);\r
}\r
break;\r
\r
case NOTIFICATION_SCHEDULER:\r
{\r
+ NS_LOG(DEBUG, "CASE NOTIFICATION_SCHEDULER :");\r
pthread_create(&NSThread[i], NULL, NSNotificationSchedule, NULL);\r
}\r
break;\r
\r
bool NSStopScheduler()\r
{\r
+ NS_LOG(DEBUG, "NSStopScheduler - IN");\r
int i = 0;\r
\r
for (i = THREAD_COUNT - 1; i >= 0; --i)\r
pthread_mutex_unlock(&NSMutex[i]);\r
}\r
\r
+ NS_LOG(DEBUG, "NSStopScheduler - OUT");\r
+\r
return true;\r
}\r
\r
void NSPushQueue(NSSchedulerType schedulerType, NSTaskType taskType, void* data)\r
{\r
pthread_mutex_lock(&NSMutex[schedulerType]);\r
- // mutext Lock\r
+\r
+ NS_LOG(DEBUG, "NSPushQueue - IN");\r
+ NS_LOG_V(DEBUG, "NSSchedulerType = %d", schedulerType);\r
+ NS_LOG_V(DEBUG, "NSTaskType = %d", taskType);\r
+\r
if (NSHeadMsg[schedulerType] == NULL)\r
{\r
- printf("first schedule");\r
NSHeadMsg[schedulerType] = (NSTask*) malloc(sizeof(NSTask));\r
memset(NSHeadMsg[schedulerType], 0, sizeof(NSTask));\r
NSHeadMsg[schedulerType]->taskType = taskType;\r
}\r
else\r
{\r
- printf("after first schedule");\r
NSTask* newNode = (NSTask*) malloc(sizeof(NSTask));\r
memset(newNode, 0, sizeof(NSTask));\r
newNode->taskType = taskType;\r
}\r
\r
sem_post(&(NSSemaphore[schedulerType]));\r
+ NS_LOG(DEBUG, "NSPushQueue - OUT");\r
pthread_mutex_unlock(&NSMutex[schedulerType]);\r
-\r
- // mutext UnLock\r
}\r
\r
\r
NSResult NSInitSubscriptionList()\r
{\r
+ NS_LOG(DEBUG, "NSInitSubscriptionList - IN");\r
+\r
consumerSubList = NSCacheCreate();\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
{\r
+ NS_LOG(DEBUG, "NSSetSubscriptionAcceptPolicy - IN");\r
+\r
if (policy == NS_ACCEPTER_PROVIDER)\r
{\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Place Provider as a subscription accepter");\r
+ NS_LOG(DEBUG, "Place Provider as a subscription accepter");\r
}\r
else if (policy == NS_ACCEPTER_CONSUMER)\r
{\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Place Consumer as a subscription accepter");\r
+ NS_LOG(DEBUG, "Place Consumer as a subscription accepter");\r
}\r
\r
NSSubscriptionAccepter = policy;\r
\r
+ NS_LOG(DEBUG, "NSSetSubscriptionAcceptPolicy - OUT");\r
return NS_OK;\r
}\r
\r
NSResult NSSendAccessPolicyResponse(OCEntityHandlerRequest *entityHandlerRequest)\r
{\r
OIC_LOG(DEBUG, NOTIFICATION_TAG, "Send Notification Policy to consumer");\r
+ NS_LOG(DEBUG, "NSSendAccessPolicyResponse - IN");\r
\r
// put notification resource\r
OCResourceHandle notificationResourceHandle;\r
!= NS_OK)\r
{\r
OIC_LOG(ERROR, SUBSCRIPTION_TAG, PCF("Failed to put notification resource"));\r
+ NS_LOG(ERROR, "Fail to put notification resource");\r
return NS_ERROR;\r
}\r
\r
memset(response.resourceUri, 0, sizeof response.resourceUri);\r
\r
OCRepPayload* payload = OCRepPayloadCreate();\r
- //response.payload = OCRepPayloadCreate();\r
if (!payload)\r
{\r
OIC_LOG(ERROR, SUBSCRIPTION_TAG, PCF("Failed to allocate Payload"));\r
+ NS_LOG(ERROR, "payload is NULL");\r
return NS_ERROR;\r
}\r
\r
if (OCDoResponse(&response) != OC_STACK_OK)\r
{\r
OIC_LOG(ERROR, SUBSCRIPTION_TAG, PCF("Fail to send response"));\r
+ NS_LOG(ERROR, "Fail to AccessPolicy send response");\r
return NS_ERROR;\r
}\r
OCRepPayloadDestroy(payload);\r
\r
+ NS_LOG(DEBUG, "NSSendAccessPolicyResponse - OUT");\r
return NS_OK;\r
}\r
\r
{\r
\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Start to subscription process");\r
-\r
- printf("state = 0 \n");\r
-\r
- // write consumer info to cache\r
+ NS_LOG(DEBUG, "NSHandleSubscription - IN");\r
\r
if (resourceType == NS_RESOURCE_MESSAGE)\r
{\r
+ NS_LOG(DEBUG, "resourceType == NS_RESOURCE_MESSAGE");\r
NSCacheElement * element = (NSCacheElement *) OICMalloc(sizeof(NSCacheElement));\r
NSCacheSubData * subData = (NSCacheSubData *) OICMalloc(sizeof(NSCacheSubData));\r
\r
element->data = (void*) subData;\r
element->next = NULL;\r
\r
- printf("NS_ IP = %s in message ob\n", entityHandlerRequest->devAddr.addr);\r
- printf("NS_ IP2 = %s in message ob\n", subData->id);\r
- printf("NS_ message ob Id = %d\n", subData->messageObId);\r
-\r
if (NSCacheWrite(consumerSubList, element) != NS_OK)\r
{\r
- printf("Cache Write Error\n");\r
+ NS_LOG(DEBUG, "fail to write cache");\r
}\r
\r
if (NSGetSubscriptionAccepter() == NS_ACCEPTER_PROVIDER)\r
{\r
- // OCDevAddr --> NSConsumer\r
- printf("before NSGetSubscriptionAccepter() == NS_ACCEPTER_PROVIDER)\n");\r
+ NS_LOG(DEBUG, "NSGetSubscriptionAccepter == NS_ACCEPTER_PROVIDER");\r
NSAskAcceptanceToUser(entityHandlerRequest);\r
- printf("After NSGetSubscriptionAccepter() == NS_ACCEPTER_PROVIDER)\n");\r
}\r
else if (NSGetSubscriptionAccepter() == NS_ACCEPTER_CONSUMER)\r
{\r
- printf("state = 0 - 3\n");\r
+ NS_LOG(DEBUG, "NSGetSubscriptionAccepter == NS_ACCEPTER_CONSUMER");\r
NSSendSubscriptionResponse(entityHandlerRequest, true);\r
}\r
}\r
else if (resourceType == NS_RESOURCE_SYNC)\r
{\r
+ NS_LOG(DEBUG, "resourceType == NS_RESOURCE_SYNC");\r
NSCacheElement * element = (NSCacheElement *) OICMalloc(sizeof(NSCacheElement));\r
\r
NSCacheSubData * subData = (NSCacheSubData *) OICMalloc(sizeof(NSCacheSubData));\r
- printf("NS_ entityHandlerRequest->devAddr.addr = %s\n", entityHandlerRequest->devAddr.addr);\r
+\r
subData->id = OICStrdup(entityHandlerRequest->devAddr.addr);\r
subData->isWhite = false;\r
subData->syncObId = entityHandlerRequest->obsInfo.obsId;\r
element->data = (void*) subData;\r
element->next = NULL;\r
\r
- printf("NS_ sync ob Id = %d\n", subData->syncObId);\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
{\r
- printf("Cache Write Error\n");\r
+ NS_LOG(ERROR, "Fail to write cache");\r
}\r
}\r
+\r
+ NS_LOG(DEBUG, "NSHandleSubscription - OUT");\r
}\r
\r
void NSHandleUnsubscription(OCEntityHandlerRequest *entityHandlerRequest)\r
{\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Start to unsubscription process");\r
+ NS_LOG(DEBUG, "NSHandleUnsubscription - IN");\r
\r
NSCacheElement * element = (NSCacheElement *) OICMalloc(sizeof(NSCacheElement));\r
NSCacheSubData * subData = (NSCacheSubData *) OICMalloc(sizeof(NSCacheSubData));\r
element->data = (void*) subData;\r
element->next = NULL;\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
{\r
OIC_LOG(ERROR, SUBSCRIPTION_TAG, "fail to write consumer white list");\r
+ NS_LOG(ERROR, "fail to write consumer white list");\r
}\r
+\r
+ NS_LOG(DEBUG, "NSHandleUnsubscription - IN");\r
}\r
\r
void NSAskAcceptanceToUser(OCEntityHandlerRequest *entityHandlerRequest)\r
{\r
OIC_LOG(DEBUG, SUBSCRIPTION_TAG, "Ask for user to Allow or Deny");\r
+ NS_LOG(DEBUG, "NSAskAcceptanceToUser - IN");\r
\r
NSPushQueue(RESPONSE_SCHEDULER, TASK_CB_SUBSCRIPTION, entityHandlerRequest);\r
- // one queue is required for response callback to ask subscription allowance\r
+\r
+ NS_LOG(DEBUG, "NSAskAcceptanceToUser - OUT");\r
}\r
\r
NSResult NSSendResponse(const char * id, bool accepted)\r
{\r
+ NS_LOG(DEBUG, "NSSendResponse - IN");\r
\r
OCRepPayload* payload = OCRepPayloadCreate();\r
if (!payload)\r
{\r
OIC_LOG(ERROR, SUBSCRIPTION_TAG, PCF("Failed to allocate Payload"));\r
+ NS_LOG(ERROR, "fail to create playload");\r
return NS_ERROR;\r
}\r
\r
if (NSPutMessageResource(NULL, &rHandle) != NS_OK)\r
{\r
OIC_LOG(ERROR, NOTIFICATION_TAG, PCF("Fail to put notification resource"));\r
+ NS_LOG(ERROR, "Fail to put notification resource");\r
return NS_ERROR;\r
}\r
\r
\r
if(element == NULL)\r
{\r
- printf("NS_ NSSendResponse - element is NULL\n");\r
+ NS_LOG(ERROR, "element is NULL");\r
return NS_ERROR;\r
}\r
NSCacheSubData * subData = (NSCacheSubData*) element->data;\r
!= OC_STACK_OK)\r
{\r
OIC_LOG(ERROR, SUBSCRIPTION_TAG, "fail to send Acceptance");\r
+ NS_LOG(ERROR, "fail to send Acceptance");\r
OCRepPayloadDestroy(payload);\r
return NS_ERROR;\r
\r
}\r
OCRepPayloadDestroy(payload);\r
\r
+ NS_LOG(DEBUG, "NSSendResponse - OUT");\r
return NS_OK;\r
}\r
\r
NSResult NSSendSubscriptionResponse(OCEntityHandlerRequest *entityHandlerRequest, bool accepted)\r
{\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Send ACCEPT message to consumer");\r
+ NS_LOG(DEBUG, "NSSendSubscriptionResponse - IN");\r
\r
if (!entityHandlerRequest)\r
{\r
return OC_EH_ERROR;\r
}\r
\r
- // write consumer info to cache\r
-\r
- printf("accepted 1 \n");\r
if (accepted)\r
{\r
+ NS_LOG(DEBUG, "accepted is true");\r
NSCacheElement * element = (NSCacheElement *) OICMalloc(sizeof(NSCacheElement));\r
\r
NSCacheSubData * subData = (NSCacheSubData *) OICMalloc(sizeof(NSCacheSubData));\r
if (NSCacheWrite(consumerSubList, element) != NS_OK)\r
{\r
OIC_LOG(ERROR, SUBSCRIPTION_TAG, "fail to write consumer white list");\r
+ NS_LOG(ERROR, "fail to write consumer white list");\r
}\r
}\r
\r
NSSendResponse(entityHandlerRequest->devAddr.addr, accepted);\r
\r
+ NS_LOG(DEBUG, "NSSendSubscriptionResponse - OUT");\r
return NS_OK;\r
-\r
}\r
\r
void * NSSubScriptionSchedule(void *ptr)\r
if (ptr == NULL)\r
{\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Create NSSubscriptionSchedule");\r
+ NS_LOG(DEBUG, "Create NSSubScriptionSchedule");\r
}\r
\r
while (NSIsRunning[SUBSCRIPTION_SCHEDULER])\r
\r
switch (node->taskType)\r
{\r
-\r
case TASK_SEND_POLICY:\r
+ NS_LOG(DEBUG, "CASE TASK_SEND_POLICY : ");\r
NSSendAccessPolicyResponse((OCEntityHandlerRequest*) node->taskData);\r
break;\r
\r
case TASK_RECV_SUBSCRIPTION:\r
- printf("before TASK_RECV_SUBSCRIPTION:\n");\r
+ NS_LOG(DEBUG, "CASE TASK_RECV_SUBSCRIPTION : ");\r
NSHandleSubscription((OCEntityHandlerRequest*) node->taskData,\r
NS_RESOURCE_MESSAGE);\r
- printf("after TASK_RECV_SUBSCRIPTION:\n");\r
break;\r
\r
case TASK_RECV_UNSUBSCRIPTION:\r
-\r
+ NS_LOG(DEBUG, "CASE TASK_RECV_UNSUBSCRIPTION : ");\r
NSHandleUnsubscription((OCEntityHandlerRequest*) node->taskData);\r
break;\r
\r
case TASK_SEND_ALLOW:\r
{\r
+ NS_LOG(DEBUG, "CASE TASK_SEND_ALLOW : ");\r
NSConsumer * consumer = (NSConsumer *) node->taskData;\r
- int * pObId = (int *) consumer->mUserData;\r
\r
NSCacheSubData * subData = (NSCacheSubData *) OICMalloc(sizeof(NSCacheSubData));\r
subData->id = OICStrdup(consumer->mId);\r
subData->syncObId = 0;\r
\r
NSCacheUpdateSubScriptionState(consumerSubList, subData);\r
-\r
- printf("observer ID = %d\n", *pObId);\r
-\r
NSSendResponse(consumer->mId, true);\r
\r
break;\r
}\r
case TASK_SEND_DENY:\r
{\r
+ NS_LOG(DEBUG, "CASE TASK_SEND_DENY : ");\r
NSConsumer * consumer = (NSConsumer *) node->taskData;\r
int * pObId = (int *) consumer->mUserData;\r
\r
break;\r
}\r
case TASK_SYNC_SUBSCRIPTION:\r
+ NS_LOG(DEBUG, "CASE TASK_SYNC_SUBSCRIPTION : ");\r
NSHandleSubscription((OCEntityHandlerRequest*) node->taskData,\r
NS_RESOURCE_SYNC);\r
break;\r
void NSSetProviderConnectionState(NSConnectionState state)\r
{\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Change Connection State");\r
+ NS_LOG(DEBUG, "NSSetProviderConnectionState");\r
\r
NSProviderConnectionState = state;\r
}\r
NSConnectionState NSGetProviderConnectionState()\r
{\r
OIC_LOG(INFO, SUBSCRIPTION_TAG, "Change Connection State");\r
+ //NS_LOG(DEBUG, "NSGetProviderConnectionState");\r
\r
return NSProviderConnectionState;\r
}\r
#ifndef _NS_PROVIDER_SYSTEM__H_\r
#define _NS_PROVIDER_SYSTEM__H_\r
\r
+#include <string.h>\r
#include "logger.h"\r
#include "NSCommon.h"\r
#include "NSConstants.h"\r
\r
pthread_mutex_unlock(&NSCacheMutex);\r
\r
+ NS_LOG(DEBUG, "NSCacheCreate");\r
+\r
return newList;\r
}\r
\r
NSCacheElement * NSCacheRead(NSCacheList * list, const char * findId)\r
{\r
pthread_mutex_lock(&NSCacheMutex);\r
+\r
+ NS_LOG(DEBUG, "NSCacheRead - IN");\r
+\r
NSCacheElement * iter = list->head;\r
NSCacheElement * next = NULL;\r
NSCacheType type = list->cacheType;\r
\r
- printf("NS_ findId = %s\n", findId);\r
+\r
+ NS_LOG_V(DEBUG, "Find ID - %s", findId);\r
\r
while (iter)\r
{\r
next = iter->next;\r
\r
- printf("NS_ findId2 = %s\n", findId);\r
-\r
if (NSProviderCompareIdCacheData(type, iter->data, findId))\r
{\r
+ NS_LOG(DEBUG, "Found in Cache");\r
pthread_mutex_unlock(&NSCacheMutex);\r
return iter;\r
}\r
iter = next;\r
}\r
\r
+ NS_LOG(DEBUG, "Not found in Cache");\r
+ NS_LOG(DEBUG, "NSCacheRead - OUT");\r
pthread_mutex_unlock(&NSCacheMutex);\r
\r
return NULL;\r
}\r
\r
-NSResult NSCacheUpdateSubScriptionState(NSCacheList * list, NSCacheSubData * subData)\r
+NSResult NSCacheUpdateSubScriptionState(NSCacheList * list, NSCacheSubData * updateData)\r
{\r
pthread_mutex_lock(&NSCacheMutex);\r
\r
- printf("NS_ NSCacheUpdateSubScriptionState\n");\r
+ NS_LOG(DEBUG, "NSCacheUpdateSubScriptionState - IN");\r
\r
- if (subData == NULL)\r
+ if (updateData == NULL)\r
{\r
- printf("NS_ NSCacheWrite - newObj is NULL\n");\r
+ NS_LOG(DEBUG, "updateData is NULL");\r
pthread_mutex_unlock(&NSCacheMutex);\r
return NS_ERROR;\r
}\r
\r
- printf("NS_ findId0 - 0 = %s\n", subData->id);\r
pthread_mutex_unlock(&NSCacheMutex);\r
- NSCacheElement * it = NSCacheRead(list, subData->id);\r
+ NSCacheElement * it = NSCacheRead(list, updateData->id);\r
pthread_mutex_lock(&NSCacheMutex);\r
- printf("NS_ findId0 -1 = %s\n", subData->id);\r
+\r
if (it)\r
{\r
- printf("NS_ findId1 = %s\n", subData->id);\r
NSCacheSubData * itData = (NSCacheSubData *) it->data;\r
- printf("NS_ findId2 = %s\n", subData->id);\r
- if (strcmp(itData->id, subData->id) == 0)\r
+ if (strcmp(itData->id, updateData->id) == 0)\r
{\r
- printf("NS_ findId3_subdata_id = %s\n", subData->id);\r
- printf("NS_ findId3_subdata_messageobId = %d\n", subData->messageObId);\r
- printf("NS_ findId3_subdata_syncobId = %d\n", subData->syncObId);\r
- printf("NS_ findId3_subdata_isWhite = %d\n", subData->isWhite);\r
+ NS_LOG(DEBUG, "Update Data - IN");\r
+\r
+ NS_LOG_V(DEBUG, "currData_ID = %s", itData->id);\r
+ NS_LOG_V(DEBUG, "currData_MsgObID = %d", itData->messageObId);\r
+ NS_LOG_V(DEBUG, "currData_SyncObID = %d", itData->syncObId);\r
+ NS_LOG_V(DEBUG, "currData_IsWhite = %d", itData->isWhite);\r
\r
- printf("NS_ findId3_itdata_id = %s\n", itData->id);\r
- printf("NS_ findId3_itdata_messageobId = %d\n", itData->messageObId);\r
- printf("NS_ findId3_itdata_isWhite = %d\n", itData->isWhite);\r
+ NS_LOG(DEBUG,"");\r
\r
- itData->isWhite = subData->isWhite;\r
+ NS_LOG_V(DEBUG, "updateData_ID = %s", updateData->id);\r
+ NS_LOG_V(DEBUG, "updateData_MsgObID = %d", updateData->messageObId);\r
+ NS_LOG_V(DEBUG, "updateData_SyncObID = %d", updateData->syncObId);\r
+ NS_LOG_V(DEBUG, "updateData_IsWhite = %d", updateData->isWhite);\r
\r
- printf("_NS : PROVIDER_CACHE_SUBSCRIBER UPDATE\n");\r
+ itData->isWhite = updateData->isWhite;\r
\r
+ NS_LOG(DEBUG, "Update Data - OUT");\r
pthread_mutex_unlock(&NSCacheMutex);\r
return NS_OK;\r
-\r
}\r
}\r
+ else\r
+ {\r
+ NS_LOG(DEBUG, "Not Found Data");\r
+ }\r
+\r
+ NS_LOG(DEBUG, "NSCacheUpdateSubScriptionState - OUT");\r
pthread_mutex_unlock(&NSCacheMutex);\r
- return NS_OK;\r
+ return NS_ERROR;\r
}\r
\r
NSResult NSCacheWrite(NSCacheList * list, NSCacheElement * newObj)\r
\r
NSCacheType type = list->cacheType;\r
\r
- printf("NS_ NSCacheWrite\n");\r
+ NS_LOG(DEBUG, "NSCacheWrite - IN");\r
\r
if (newObj == NULL)\r
{\r
- printf("NS_ NSCacheWrite - newObj is NULL\n");\r
+ NS_LOG(DEBUG, "newObj is NULL - IN");\r
pthread_mutex_unlock(&NSCacheMutex);\r
return NS_ERROR;\r
}\r
\r
if (type == NS_PROVIDER_CACHE_SUBSCRIBER)\r
{\r
+ NS_LOG(DEBUG, "Type is SUBSCRIBER");\r
+\r
NSCacheSubData * subData = (NSCacheSubData *) newObj->data;\r
\r
- printf("NS_ findId0 - 0 = %s\n", subData->id);\r
pthread_mutex_unlock(&NSCacheMutex);\r
NSCacheElement * it = NSCacheRead(list, subData->id);\r
pthread_mutex_lock(&NSCacheMutex);\r
- printf("NS_ findId0 -1 = %s\n", subData->id);\r
+\r
if (it)\r
{\r
- printf("NS_ findId1 = %s\n", subData->id);\r
NSCacheSubData * itData = (NSCacheSubData *) it->data;\r
- printf("NS_ findId2 = %s\n", subData->id);\r
+\r
if (strcmp(itData->id, subData->id) == 0)\r
{\r
- printf("NS_ findId3_subdata_id = %s\n", subData->id);\r
- printf("NS_ findId3_subdata_messageobId = %d\n", subData->messageObId);\r
- printf("NS_ findId3_subdata_syncobId = %d\n", subData->syncObId);\r
- printf("NS_ findId3_subdata_isWhite = %d\n", subData->isWhite);\r
-\r
- printf("NS_ findId3_itdata_id = %s\n", itData->id);\r
- printf("NS_ findId3_itdata_messageobId = %d\n", itData->messageObId);\r
- printf("NS_ findId3_itdata_isWhite = %d\n", itData->isWhite);\r
+ NS_LOG(DEBUG, "Update Data - IN");\r
+\r
+ NS_LOG_V(DEBUG, "currData_ID = %s", itData->id);\r
+ NS_LOG_V(DEBUG, "currData_MsgObID = %d", itData->messageObId);\r
+ NS_LOG_V(DEBUG, "currData_SyncObID = %d", itData->syncObId);\r
+ NS_LOG_V(DEBUG, "currData_IsWhite = %d", itData->isWhite);\r
+\r
+ NS_LOG(DEBUG,"");\r
+\r
+ NS_LOG_V(DEBUG, "subData_ID = %s", subData->id);\r
+ NS_LOG_V(DEBUG, "subData_MsgObID = %d", subData->messageObId);\r
+ NS_LOG_V(DEBUG, "subData_SyncObID = %d", subData->syncObId);\r
+ NS_LOG_V(DEBUG, "subData_IsWhite = %d", subData->isWhite);\r
+\r
if (itData->messageObId == 0)\r
{\r
itData->messageObId = subData->messageObId;\r
itData->syncObId = subData->syncObId;\r
}\r
\r
- //itData->isWhite = subData->isWhite;\r
-\r
- printf("_NS : PROVIDER_CACHE_SUBSCRIBER UPDATE\n");\r
+ NS_LOG(DEBUG, "Update Data - OUT");\r
\r
pthread_mutex_unlock(&NSCacheMutex);\r
return NS_OK;\r
-\r
}\r
}\r
\r
}\r
else if (type == NS_PROVIDER_CACHE_MESSAGE)\r
{\r
+ NS_LOG(DEBUG, "Type is MESSAGE");\r
+\r
NSCacheMsgData * msgData = (NSCacheMsgData *) newObj->data;\r
\r
NSCacheElement * it = NSCacheRead(list, msgData->id);\r
{\r
\r
itData->messageType = msgData->messageType;\r
- printf("_NS : PROVIDER_CACHE_MESSAGE UPDATE\n");\r
+ NS_LOG(DEBUG, "Updated messageType");\r
pthread_mutex_unlock(&NSCacheMutex);\r
return NS_OK;\r
\r
}\r
}\r
\r
- printf("NS_ berfore list->head == NULL\n");\r
if (list->head == NULL)\r
{\r
+ NS_LOG(DEBUG, "list->head is NULL, Insert First Data");\r
list->head = list->tail = newObj;\r
- printf("NS_ list->head == NULL\n");\r
pthread_mutex_unlock(&NSCacheMutex);\r
return NS_OK;\r
}\r
\r
list->tail = list->tail->next = newObj;\r
- printf("NS_ list->head == not NULL\n");\r
+ NS_LOG(DEBUG, "list->head is not NULL");\r
pthread_mutex_unlock(&NSCacheMutex);\r
return NS_OK;\r
}\r
\r
bool NSProviderCompareIdCacheData(NSCacheType type, void * data, const char * id)\r
{\r
+ NS_LOG(DEBUG, "NSProviderCompareIdCacheData - IN");\r
+\r
if (data == NULL)\r
{\r
return false;\r
{\r
NSCacheSubData * subData = (NSCacheSubData *) data;\r
\r
- printf("NS_ subdata->id = %s\n", subData->id);\r
- printf("NS_ id = %s\n", id);\r
+\r
+ NS_LOG_V(DEBUG, "Data(subData) = [%s]", subData->id);\r
+ NS_LOG_V(DEBUG, "Data(compData) = [%s]", id);\r
\r
if (strcmp(subData->id, id) == 0)\r
{\r
+ NS_LOG(DEBUG, "SubData is Same");\r
return true;\r
}\r
+\r
+ NS_LOG(DEBUG, "Message Data is Not Same");\r
return false;\r
\r
}\r
\r
if (strcmp(msgData->id, id) == 0)\r
{\r
+ NS_LOG(DEBUG, "Message Data is Same");\r
return true;\r
}\r
\r
+ NS_LOG(DEBUG, "Message Data is Not Same");\r
return false;\r
}\r
\r
+ NS_LOG(DEBUG, "NSProviderCompareIdCacheData - OUT");\r
+\r
return false;\r
}\r
\r
projects / platform / upstream / iotivity.git / commitdiff