- Modify name of the internal member values (ex> _addr->i_addr).
- Modify data type for message ID & message TTL (uint64_t: %ld->%llu).
- Modify storage(NSMessage/NSProvider) logic
- Remove unnecessary task logic (TASK_RECV_READ/TASK_RECV_DISMISS).
- Remove unnecessary comments & Modify typo
. patch#1: initial commit
. patch#2: modify typo
. patch#3: remove tab
. patch#4: update review comment
Change-Id: Iedafc2c6f605656d38b5e5354f1d57b6827566ca
Signed-off-by: YounghyunJoo <yh_.joo@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/9117
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>
void onNotificationPosted(NSMessage * notification)
{
- printf("id : %ld\n", notification->messageId);
+ printf("id : %llu\n", notification->messageId);
printf("title : %s\n", notification->title);
printf("content : %s\n", notification->contentText);
printf("source : %s\n", notification->sourceName);
void onNotificationSync(NSSyncInfo * sync)
{
- printf("Sync ID : %ld\n", sync->messageId);
+ printf("Sync ID : %llu\n", sync->messageId);
printf("Sync STATE : %d\n", sync->state);
}
OICFree(providerId);
NS_LOG_V(DEBUG, "Provider ID : %s", retSync->providerId);
- NS_LOG_V(DEBUG, "Sync ID : %ld", retSync->messageId);
+ NS_LOG_V(DEBUG, "Sync ID : %llu", retSync->messageId);
NS_LOG_V(DEBUG, "Sync State : %d", (int) retSync->state);
NS_LOG(DEBUG, "NSGetSyncInfo - OUT");
NS_VERIFY_NOT_NULL(newMsg, NULL);
OICStrcpy(newMsg->providerId, NS_DEVICE_ID_LENGTH, msg->providerId);
- newMsg->_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
+ newMsg->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newMsg, NULL, OICFree(newMsg));
- memcpy(newMsg->_addr, msg->_addr, sizeof(OCDevAddr));
+ memcpy(newMsg->i_addr, msg->i_addr, sizeof(OCDevAddr));
newMsg->messageId = msg->messageId;
newMsg->title = OICStrdup(msg->title);
NSOICFree(msg->title);
NSOICFree(msg->contentText);
NSOICFree(msg->sourceName);
- NSOICFree(msg->_addr);
+ NSOICFree(msg->i_addr);
NSOICFree(msg);
}
NS_VERIFY_NOT_NULL(newProv, NULL);
OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
- newProv->_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
+ newProv->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, OICFree(newProv));
- memcpy(newProv->_addr, prov->_addr, sizeof(OCDevAddr));
+ memcpy(newProv->i_addr, prov->i_addr, sizeof(OCDevAddr));
newProv->messageUri = OICStrdup(prov->messageUri);
newProv->syncUri = OICStrdup(prov->syncUri);
- newProv->messageHandle = prov->messageHandle;
- newProv->syncHandle = prov->syncHandle;
+ newProv->i_messageHandle = prov->i_messageHandle;
+ newProv->i_syncHandle = prov->i_syncHandle;
newProv->accessPolicy = prov->accessPolicy;
return newProv;
{
NSOICFree(prov->messageUri);
NSOICFree(prov->syncUri);
- NSOICFree(prov->messageHandle);
- NSOICFree(prov->syncHandle);
- NSOICFree(prov->_addr);
+ NSOICFree(prov->i_messageHandle);
+ NSOICFree(prov->i_syncHandle);
+ NSOICFree(prov->i_addr);
NSOICFree(prov);
}
char * messageUri;
char * syncUri;
- OCDoHandle messageHandle;
- OCDoHandle syncHandle;
- OCDevAddr * _addr;
+ OCDoHandle i_messageHandle;
+ OCDoHandle i_syncHandle;
+ OCDevAddr * i_addr;
NSAccessPolicy accessPolicy;
} NSProvider_internal;
char providerId[NS_DEVICE_ID_LENGTH];
NSSyncType state;
- OCDevAddr * _addr;
+ OCDevAddr * i_addr;
} NSSyncInfo_internal;
typedef struct
char * sourceName;
NSMediaContents mediaContents;
- OCDevAddr * _addr;
- //NSConsumerMessageTypes messageTypes;
- NSSyncType _messageTypes;
+ OCDevAddr * i_addr;
+ NSSyncType i_messageTypes;
} NSMessage_consumer;
bool NSIsStartedConsumer();
NS_LOG(DEBUG, "subscribe message");
NS_LOG_V(DEBUG, "subscribe query : %s", query);
- OCStackResult ret = NSInvokeRequest(&(provider_internal->messageHandle),
- OC_REST_OBSERVE, provider_internal->_addr,
+ OCStackResult ret = NSInvokeRequest(&(provider_internal->i_messageHandle),
+ OC_REST_OBSERVE, provider_internal->i_addr,
query, NULL, NSConsumerMessageListener, NULL);
NS_VERIFY_STACK_OK(ret, NS_ERROR);
NSOICFree(query);
NS_LOG(DEBUG, "subscribe sync");
NS_LOG_V(DEBUG, "subscribe query : %s", query);
- ret = NSInvokeRequest(&(provider_internal->syncHandle),
- OC_REST_OBSERVE, provider_internal->_addr,
+ ret = NSInvokeRequest(&(provider_internal->i_syncHandle),
+ OC_REST_OBSERVE, provider_internal->i_addr,
query, NULL, NSConsumerSyncInfoListener, NULL);
NS_VERIFY_STACK_OK(ret, NS_ERROR);
NSOICFree(query);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(retMsg, NULL, NSGetMessagePostClean(pId, addr));
NSOICFree(pId);
- retMsg->_addr = addr;
- retMsg->_messageTypes = NS_SYNC_UNREAD;
+ retMsg->i_addr = addr;
+ retMsg->i_messageTypes = NS_SYNC_UNREAD;
NS_LOG(DEBUG, "get msg optional field");
OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TITLE, &retMsg->title);
OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_DATETIME, &retMsg->dateTime);
OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_TTL, (int64_t *)&retMsg->ttl);
- NS_LOG_V(DEBUG, "Msg Address : %s", retMsg->_addr->addr);
- NS_LOG_V(DEBUG, "Msg ID : %ld", retMsg->messageId);
+ NS_LOG_V(DEBUG, "Msg Address : %s", retMsg->i_addr->addr);
+ NS_LOG_V(DEBUG, "Msg ID : %llu", retMsg->messageId);
NS_LOG_V(DEBUG, "Msg Title : %s", retMsg->title);
NS_LOG_V(DEBUG, "Msg Content : %s", retMsg->contentText);
NS_LOG_V(DEBUG, "Msg Source : %s", retMsg->sourceName);
NS_LOG_V(DEBUG, "Msg Type : %d", retMsg->type);
NS_LOG_V(DEBUG, "Msg Date : %s", retMsg->dateTime);
- NS_LOG_V(DEBUG, "Msg ttl : %ld", retMsg->ttl);
+ NS_LOG_V(DEBUG, "Msg ttl : %llu", retMsg->ttl);
return retMsg;
}
NSSyncInfo * retSync = NSCreateSyncInfo_consumer(id, pId, (NSSyncType)state);
NS_VERIFY_NOT_NULL(retSync, NULL);
- NS_LOG_V(DEBUG, "Sync ID : %ld", retSync->messageId);
+ NS_LOG_V(DEBUG, "Sync ID : %llu", retSync->messageId);
NS_LOG_V(DEBUG, "Sync State : %d", (int) retSync->state);
NS_LOG_V(DEBUG, "Sync Provider ID : %s", retSync->providerId);
retMsg->type = NS_MESSAGE_INFO;
retMsg->dateTime = NULL;
retMsg->ttl = 0;
- retMsg->_addr = NULL;
+ retMsg->i_addr = NULL;
return retMsg;
}
{
// TODO find target OCDevAddr using provider Id.
NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)task->taskData;
- OCDevAddr * addr = syncInfo->_addr;
+ OCDevAddr * addr = syncInfo->i_addr;
OCStackResult ret = NSSendSyncInfo((NSSyncInfo *)(task->taskData), addr);
NS_VERIFY_STACK_OK_V(ret);
- NSOICFree(syncInfo->_addr);
+ NSOICFree(syncInfo->i_addr);
NSOICFree(syncInfo);
}
else if (task->taskType == TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL)
{
NSProvider_internal * provider = (NSProvider_internal *)task->taskData;
- OCCancel(provider->messageHandle, NS_QOS, NULL, 0);
- OCCancel(provider->syncHandle, NS_QOS, NULL, 0);
+ OCCancel(provider->i_messageHandle, NS_QOS, NULL, 0);
+ OCCancel(provider->i_syncHandle, NS_QOS, NULL, 0);
}
else
{
NSOICFree(provider->messageUri);
NSOICFree(provider->syncUri);
- provider->messageHandle = NULL;
- provider->syncHandle = NULL;
- NSOICFree(provider->_addr);
+ provider->i_messageHandle = NULL;
+ provider->i_syncHandle = NULL;
+ NSOICFree(provider->i_addr);
NSOICFree(provider);
}
newProvider->messageUri = messageUri;
newProvider->syncUri = syncUri;
newProvider->accessPolicy = (NSAccessPolicy)accepter;
- newProvider->_addr = addr;
- newProvider->messageHandle = NULL;
- newProvider->syncHandle = NULL;
+ newProvider->i_addr = addr;
+ newProvider->i_messageHandle = NULL;
+ newProvider->i_syncHandle = NULL;
return newProvider;
}
}
}
-NSResult NSMessageCacheUpdate(NSCacheList * cache, NSMessage_consumer * msg, NSSyncType type)
+NSMessage_consumer * NSMessageCacheFind(const char * messageId)
{
+ NS_VERIFY_NOT_NULL(messageId, NULL);
+
+ NSCacheList * MessageCache = *(NSGetMessageCacheList());
+ if (!MessageCache)
+ {
+ NS_LOG(DEBUG, "Message Cache Init");
+ MessageCache = NSStorageCreate();
+ NS_VERIFY_NOT_NULL(MessageCache, NULL);
+
+ MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
+ NSSetMessageCacheList(MessageCache);
+ }
+
+ NSMessage_consumer * retMsg = NSStorageRead(MessageCache, messageId);
+
+ return retMsg;
+}
+
+NSProvider_internal * NSProviderCacheFind(const char * providerId)
+{
+ NS_VERIFY_NOT_NULL(providerId, NULL);
+
+ NSCacheList * ProviderCache = *(NSGetProviderCacheList());
+ if (!ProviderCache)
+ {
+ NS_LOG(DEBUG, "Provider Cache Init");
+ ProviderCache = NSStorageCreate();
+ NS_VERIFY_NOT_NULL(ProviderCache, NULL);
+
+ ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
+ NSSetMessageCacheList(ProviderCache);
+ }
+
+ NSProvider_internal * retMsg = NSStorageRead(ProviderCache, providerId);
+
+ return retMsg;
+}
+
+
+NSResult NSMessageCacheUpdate(NSMessage_consumer * msg, NSSyncType type)
+{
+ NSCacheList * MessageCache = *(NSGetMessageCacheList());
+ if (!MessageCache)
+ {
+ NS_LOG(DEBUG, "Message Cache Init");
+ MessageCache = NSStorageCreate();
+ NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);
+
+ MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
+ NSSetMessageCacheList(MessageCache);
+ }
+
NS_VERIFY_NOT_NULL(msg, NS_ERROR);
msg->type = type;
obj->next = NULL;
NS_LOG(DEBUG, "try to write to storage");
- NSResult ret = NSStorageWrite(cache, obj);
+ NSResult ret = NSStorageWrite(MessageCache, obj);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
NS_ERROR, NSRemoveMessage(msg));
- //NSRemoveMessage(msg);
NSOICFree(obj);
return NS_OK;
}
-NSResult NSProviderCacheUpdate(NSCacheList * cache, NSProvider_internal * provider)
+NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
{
+ NSCacheList * ProviderCache = *(NSGetProviderCacheList());
+ if (!ProviderCache)
+ {
+ NS_LOG(DEBUG, "Provider Cache Init");
+ ProviderCache = NSStorageCreate();
+ NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
+
+ ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
+ NSSetProviderCacheList(ProviderCache);
+ }
+
NS_VERIFY_NOT_NULL(provider, NS_ERROR);
NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
obj->next = NULL;
NS_LOG(DEBUG, "try to write to storage");
- NSResult ret = NSStorageWrite(cache, obj);
+ NSResult ret = NSStorageWrite(ProviderCache, obj);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
NS_ERROR, NSRemoveProvider(provider));
- //NSRemoveProvider(provider);
NSOICFree(obj);
return NS_OK;
void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
{
- // TODO need to check for discovered provider is new and store provider.[DONE]
NS_VERIFY_NOT_NULL_V(provider);
- NSCacheList * cache = *(NSGetProviderCacheList());
- NSCacheElement * cacheElement = NSStorageRead(cache, provider->providerId);
- if (cacheElement)
- {
- NS_LOG_V (ERROR, "Provider is already discovered - ProviderID[%s]", provider->providerId);
- return ;
- }
- else
- {
- NS_LOG (ERROR, "New provider is discovered");
- NSResult ret = NSProviderCacheUpdate(cache, provider);
- NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
- }
+ NSCacheElement * cacheElement = NSProviderCacheFind(provider->providerId);
+ NS_VERIFY_NOT_NULL_V(cacheElement);
+
+ NS_LOG (ERROR, "New provider is discovered");
+ NSResult ret = NSProviderCacheUpdate(provider);
+ NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
+
if (provider->accessPolicy == NS_ACCESS_DENY)
{
{
NS_VERIFY_NOT_NULL_V(msg);
- // TODO change to find provider using pId. [DONE]
- NSCacheList * cache = *(NSGetProviderCacheList());
- NSCacheElement * cacheElement = NSStorageRead(cache, msg->providerId);
- NS_VERIFY_NOT_NULL_V (cacheElement);
+ NSCacheElement * cacheElement = NSMessageCacheFind(msg->providerId);
+ NS_VERIFY_NOT_NULL_V(cacheElement);
NSProvider * provider = (NSProvider *) cacheElement->data;
void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
{
NS_VERIFY_NOT_NULL_V(msg);
- // TODO store message to cache [DONE]
- NSCacheList * cache = *(NSGetMessageCacheList());
- NSResult ret = NSMessageCacheUpdate(cache, msg, NS_SYNC_UNREAD);
+
+ NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
NSMessagePost((NSMessage *) msg);
{
NS_VERIFY_NOT_NULL_V(sync);
- // TODO need to check for provider is available. [DONE]
- NSCacheList * providerCache = *(NSGetProviderCacheList());
- NSCacheElement * providerCacheElement = NSStorageRead(providerCache, sync->providerId);
- NS_VERIFY_NOT_NULL_V (providerCacheElement);
+ NSCacheElement * providerCacheElement = NSProviderCacheFind(sync->providerId);
+ NS_VERIFY_NOT_NULL_V(providerCacheElement);
- // TODO need to update msg list. [DONE]
char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
- snprintf(msgId, NS_DEVICE_ID_LENGTH, "%ld", sync->messageId);
+ snprintf(msgId, NS_DEVICE_ID_LENGTH, "%llu", sync->messageId);
- NSCacheList * messageCache = *(NSGetMessageCacheList());
- NSCacheElement * messageCacheElement = NSStorageRead(messageCache, msgId);
+ NSCacheElement * messageCacheElement = NSMessageCacheFind(msgId);
NS_VERIFY_NOT_NULL_V (messageCacheElement);
NSMessage_consumer * msg = (NSMessage_consumer *) messageCacheElement->data;
- NSResult ret = NSMessageCacheUpdate(messageCache, msg, sync->state);
+ NSResult ret = NSMessageCacheUpdate(msg, sync->state);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
NSNotificationSync(sync);
{
NS_VERIFY_NOT_NULL_V(sync);
- // TODO need to check for provider is available. [DONE]
- NSCacheList * providerCache = *(NSGetProviderCacheList());
- NSCacheElement * providerCacheElement = NSStorageRead(providerCache, sync->providerId);
+ NSCacheElement * providerCacheElement = NSProviderCacheFind(sync->providerId);
NS_VERIFY_NOT_NULL_V (providerCacheElement);
NSProvider_internal * provider = (NSProvider_internal *) providerCacheElement->data;
NS_VERIFY_NOT_NULL_V (provider);
OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
syncInfo->messageId = sync->messageId;
syncInfo->state = sync->state;
- syncInfo->_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo->_addr, NSOICFree(syncInfo));
- memcpy(syncInfo->_addr, provider->_addr, sizeof(OCDevAddr));
+ syncInfo->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo->i_addr, NSOICFree(syncInfo));
+ memcpy(syncInfo->i_addr, provider->i_addr, sizeof(OCDevAddr));
NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
{
NS_VERIFY_NOT_NULL_V(task);
- NSCacheList * MessageCache = *(NSGetMessageCacheList());
- if (!MessageCache)
- {
- NS_LOG(DEBUG, "Cache Init");
- MessageCache = NSStorageCreate();
- NS_VERIFY_NOT_NULL_V(MessageCache);
-
- MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
- NSSetMessageCacheList(MessageCache);
- }
-
- NSCacheList * ProviderCache = *(NSGetProviderCacheList());
- if (!ProviderCache)
- {
- NS_LOG(DEBUG, "Cache Init");
- ProviderCache = NSStorageCreate();
- NS_VERIFY_NOT_NULL_V(ProviderCache);
-
- ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
- NSSetProviderCacheList(ProviderCache);
- }
-
NSResult ret = NS_ERROR;
NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
switch (task->taskType)
}
case TASK_CONSUMER_PROVIDER_DISCOVERED:
{
- NS_LOG(DEBUG, "Receive New Provider is discovdered.");
+ NS_LOG(DEBUG, "Receive New Provider is discovered.");
NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
break;
}
NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
break;
}
- case TASK_RECV_READ:
- {
- NS_LOG(DEBUG, "Receive Read Notification");
-
- ret = NSMessageCacheUpdate(MessageCache, task, NS_SYNC_READ);
- NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
- break;
- }
- case TASK_RECV_DISMISS:
- {
- NS_LOG(DEBUG, "Receive Dismiss Notification");
-
- ret = NSMessageCacheUpdate(MessageCache, task, NS_SYNC_DELETED);
- NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
- break;
- }
default :
{
NS_LOG(ERROR, "Unknown TASK Type");
case TASK_CONSUMER_REQ_SUBSCRIBE:
case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
case TASK_SEND_SYNCINFO:
- case TASK_SEND_READ:
- case TASK_SEND_DISMISS:
{
NSConsumerCommunicationTaskProcessing(task);
break;
}
- case TASK_RECV_READ:
- case TASK_RECV_DISMISS:
case TASK_RECV_SYNCINFO:
case TASK_CONSUMER_RECV_MESSAGE:
case TASK_CONSUMER_PROVIDER_DISCOVERED:
pthread_mutex_unlock(mutex);
char msgId[NS_DEVICE_ID_LENGTH] = {0, };
- snprintf(msgId, NS_DEVICE_ID_LENGTH, "%ld", newMsgObj->messageId);
+ snprintf(msgId, NS_DEVICE_ID_LENGTH, "%llu", newMsgObj->messageId);
NSCacheElement * it = NSStorageRead(list, msgId);
pthread_mutex_lock(mutex);
NSMessage_consumer * msg = (NSMessage_consumer *) data;
char msgId[NS_DEVICE_ID_LENGTH] = {0, };
- snprintf(msgId, NS_DEVICE_ID_LENGTH, "%ld", msg->messageId);
+ snprintf(msgId, NS_DEVICE_ID_LENGTH, "%llu", msg->messageId);
if (!strcmp(msgId, id))
{
return true;