\r
NSMessage &NSMessage::operator=(const NSMessage &msg)\r
{\r
- m_messageId = msg.getMessageId();\r
- m_providerId = msg.getProviderId();\r
+ this->m_messageId = msg.getMessageId();\r
+ this->m_providerId = msg.getProviderId();\r
\r
- m_type = msg.getType();\r
- m_time = msg.getTime();\r
- m_ttl = msg.getTTL();\r
- m_title = msg.getTitle();\r
- m_contentText = msg.getContentText();\r
- m_sourceName = msg.getSourceName();\r
+ this->m_type = msg.getType();\r
+ this->m_time = msg.getTime();\r
+ this->m_ttl = msg.getTTL();\r
+ this->m_title = msg.getTitle();\r
+ this->m_contentText = msg.getContentText();\r
+ this->m_sourceName = msg.getSourceName();\r
\r
if (msg.getMediaContents() != nullptr)\r
- m_mediaContents = new NSMediaContents(msg.getMediaContents()->getIconImage());\r
+ this->m_mediaContents = new NSMediaContents(msg.getMediaContents()->getIconImage());\r
else\r
- m_mediaContents = new NSMediaContents();\r
- m_topic = msg.getTopic();\r
+ this->m_mediaContents = new NSMediaContents();\r
+ this->m_topic = msg.getTopic();\r
return *this;\r
}\r
\r
{
for (auto it : topicsList.getTopicsList())
{
- addTopic(it->getTopicName(), it->getState());
+ this->addTopic(it->getTopicName(), it->getState());
}
return *this;
}
ALLOW = 1,
DENY = 2,
TOPIC = 3,
- DISCOVERED = 11,
STOPPED = 12
};
+
+ /**
+ * NSProviderSubscribedState of notification service
+ */
+ enum class NSProviderSubscribedState
+ {
+ DENY = 0,
+ DISCOVERED = 1,
+ SUBSCRIBED = 2
+ };
}
}
#endif /* _NS_UTILS_H_ */
* Constructor of NSProvider.\r
*/\r
NSProvider(): m_topicList(new NSTopicsList()), m_state(NSProviderState::DENY),\r
+ m_subscribedState(NSProviderSubscribedState::DENY),\r
m_stateCb(NULL), m_messageCb(NULL), m_syncInfoCb(NULL) {}\r
\r
/**\r
*/\r
NSProvider(const std::string &providerId) : m_providerId(providerId),\r
m_topicList(new NSTopicsList()), m_state(NSProviderState::DENY),\r
+ m_subscribedState(NSProviderSubscribedState::DENY),\r
m_stateCb(NULL), m_messageCb(NULL), m_syncInfoCb(NULL) {}\r
\r
/**\r
*/\r
NSProvider(const std::string &providerId, NSTopicsList *topicList) : m_providerId(\r
providerId), m_topicList(topicList), m_state(NSProviderState::DENY),\r
+ m_subscribedState(NSProviderSubscribedState::DENY),\r
m_stateCb(NULL), m_messageCb(NULL), m_syncInfoCb(NULL) {}\r
\r
/**\r
NSProviderState getProviderState() const;\r
\r
/**\r
+ * This method is for getting SubscribedState from the Notification service provider.\r
+ *\r
+ * @return subscribedState as NSProviderSubscribedState.\r
+ */\r
+ NSProviderSubscribedState getProviderSubscribedState() const;\r
+\r
+ /**\r
* This method is for requesting subscription of Notification service.\r
*\r
*/\r
*/\r
void setProviderState(const NSProviderState &providerState);\r
\r
+ /**\r
+ * This method is for setting subscribedState for the Notification service provider.\r
+ *\r
+ * @param subscribedState as NSProviderSubscribedState.\r
+ */\r
+ void setProviderSubscribedState(const NSProviderSubscribedState &subscribedState);\r
+\r
private:\r
::NSProvider *getNSProvider();\r
\r
std::string m_providerId;\r
NSTopicsList *m_topicList;\r
NSProviderState m_state;\r
+ NSProviderSubscribedState m_subscribedState;\r
\r
ProviderStateCallback m_stateCb;\r
MessageReceivedCallback m_messageCb;\r
nsProvider->setTopicList(new NSTopicsList(topicLL));\r
if (state == NS_DISCOVERED)\r
{\r
+ nsProvider->setProviderSubscribedState(NSProviderSubscribedState::DISCOVERED);\r
if (discoveredCallback != NULL)\r
{\r
NS_LOG(DEBUG, "initiating the Discovered callback : NS_DISCOVERED, policy false");\r
}\r
else if (state == NS_ALLOW)\r
{\r
+ nsProvider->setProviderSubscribedState(NSProviderSubscribedState::SUBSCRIBED);\r
if (discoveredCallback != NULL)\r
{\r
NS_LOG(DEBUG, "initiating the Discovered callback : NS_ALLOW, policy true");\r
delete nsProvider;\r
if (state == NS_ALLOW)\r
{\r
+ oldProvider->setProviderSubscribedState(NSProviderSubscribedState::SUBSCRIBED);\r
if (changeCallback != NULL)\r
{\r
NS_LOG(DEBUG, "initiating the callback for Response : NS_ALLOW");\r
}\r
else if (state == NS_DENY)\r
{\r
+ oldProvider->setProviderSubscribedState(NSProviderSubscribedState::DENY);\r
NSConsumerService::getInstance()->getAcceptedProviders().remove(oldProvider);\r
if (changeCallback != NULL)\r
{\r
}\r
else if (state == NS_STOPPED)\r
{\r
+ oldProvider->setProviderSubscribedState(NSProviderSubscribedState::DENY);\r
+ NSConsumerService::getInstance()->getAcceptedProviders().remove(oldProvider);\r
NS_LOG(DEBUG, "initiating the State callback : NS_STOPPED");\r
if (changeCallback != NULL)\r
{\r
- NS_LOG(DEBUG, "initiating the callback for Response : NS_TOPIC");\r
+ NS_LOG(DEBUG, "initiating the callback for Response : NS_STOPPED");\r
changeCallback((NSProviderState)state);\r
}\r
}\r
{\r
NS_LOG(DEBUG, "stop - IN");\r
NSStopConsumer();\r
+ for (auto it : getAcceptedProviders())\r
+ {\r
+ delete it;\r
+ }\r
+ getAcceptedProviders().clear();\r
NS_LOG(DEBUG, "stop - OUT");\r
return;\r
}\r
m_messageCb = NULL;\r
m_syncInfoCb = NULL;\r
m_state = NSProviderState::DENY;\r
+ m_subscribedState = NSProviderSubscribedState::DENY;\r
+\r
m_topicList = new NSTopicsList();\r
\r
if (provider != nullptr)\r
NSProvider::NSProvider(const NSProvider &provider)\r
{\r
m_providerId = provider.getProviderId();\r
+ m_topicList = new NSTopicsList();\r
auto topicsList = provider.getTopicList();\r
if (topicsList != nullptr)\r
{\r
setListener(provider.getProviderStateReceivedCb(), provider.getMessageReceivedCb(),\r
provider.getSyncInfoReceivedCb());\r
setProviderState(provider.getProviderState());\r
+ setProviderSubscribedState(provider.getProviderSubscribedState());\r
}\r
\r
NSProvider &NSProvider::operator=(const NSProvider &provider)\r
{\r
- m_providerId = provider.getProviderId();\r
+ this->m_providerId = provider.getProviderId();\r
+ this->m_topicList = new NSTopicsList();\r
auto topicsList = provider.getTopicList();\r
if (topicsList != nullptr)\r
{\r
for (auto it : topicsList->getTopicsList())\r
{\r
- getTopicList()->addTopic(it->getTopicName(), it->getState());\r
+ this->getTopicList()->addTopic(it->getTopicName(), it->getState());\r
}\r
}\r
- setListener(provider.getProviderStateReceivedCb(), provider.getMessageReceivedCb(),\r
- provider.getSyncInfoReceivedCb());\r
- setProviderState(provider.getProviderState());\r
+ this->setListener(provider.getProviderStateReceivedCb(), provider.getMessageReceivedCb(),\r
+ provider.getSyncInfoReceivedCb());\r
+ this->setProviderState(provider.getProviderState());\r
+ this->setProviderSubscribedState(provider.getProviderSubscribedState());\r
return *this;\r
}\r
\r
return m_state;\r
}\r
\r
+ NSProviderSubscribedState NSProvider::getProviderSubscribedState() const\r
+ {\r
+ NS_LOG_V(DEBUG, "getProviderSubscribedState state : %d", (int)m_subscribedState);\r
+ return m_subscribedState;\r
+ }\r
+\r
void NSProvider::subscribe()\r
{\r
NS_LOG(DEBUG, "Subscribe - IN");\r
bool NSProvider::isSubscribed()\r
{\r
NS_LOG(DEBUG, "isSubscribed - IN");\r
- auto state = getProviderState();\r
- NS_LOG_V(DEBUG, "state : %d", (int)state);\r
- if ((state == NSProviderState::ALLOW) || (state == NSProviderState::TOPIC) )\r
+ NS_LOG_V(DEBUG, "Subscribed state : %d", (int)getProviderSubscribedState());\r
+ if (getProviderSubscribedState() == NSProviderSubscribedState::SUBSCRIBED)\r
return true;\r
return false;\r
}\r
{\r
m_state = providerState;\r
}\r
+\r
+ void NSProvider::setProviderSubscribedState(const NSProviderSubscribedState &subscribedState)\r
+ {\r
+ m_subscribedState = subscribedState;\r
+ }\r
}\r
}\r
std::cout << "topic : " << notification->getTopic() << std::endl;\r
\r
auto provider = NSConsumerService::getInstance()->getProvider(notification->getProviderId());\r
- provider->sendSyncInfo(notification->getMessageId(),\r
- OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ);\r
+ if (provider != nullptr)\r
+ provider->sendSyncInfo(notification->getMessageId(),\r
+ OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ);\r
}\r
\r
void onNotificationSyncCb(OIC::Service::NSSyncInfo *sync)\r
{\r
std::cout << "SendMessage" << std::endl;\r
\r
+ std::string dummy;\r
std::string title;\r
std::string body;\r
std::string topic;\r
std::cout << "id : " << ++id << std::endl;\r
std::cout << "title : ";\r
\r
- std::cin >> title;\r
+ std::getline(std::cin, dummy);\r
+ std::getline(std::cin, title);\r
\r
std::cout << "body : ";\r
- std::cin >> body;\r
+ std::getline(std::cin, body);\r
\r
std::cout << "topic : ";\r
- std::cin >> topic;\r
+ std::getline(std::cin, topic);\r
\r
std::cout << "app - mTitle : " << title << std::endl;\r
std::cout << "app - mContentText : " << body << std::endl;\r
notification_sample_env.AppendUnique(CPPPATH = ['../../src/provider'])
notification_sample_env.AppendUnique(CPPDEFINES = ['WITH_CLOUD'])
- CONSUMER_CLOUD = File('cloud_connector.c')
- notification_sample_consumer_src = ['notificationconsumer.c', CONSUMER_CLOUD]
- PROVIDER_CLOUD = File('cloud_connector.c')
- notification_sample_provider_src = ['notificationprovider.c', PROVIDER_CLOUD]
+ providerCloudConnectorObj = notification_sample_env.Object('cloud_connector.c')
+ consumerCloudConnectorObj = notification_sample_env.Object('cloud_connector.c')
+
+ #PROVIDER_CLOUD = File('cloud_connector.c')
+ #notification_sample_provider_src = ['notificationprovider.c', PROVIDER_CLOUD]
+ notification_sample_provider_src = ['notificationprovider.c', providerCloudConnectorObj]
+ #CONSUMER_CLOUD = File('cloud_connector.c')
+ #notification_sample_consumer_src = ['notificationconsumer.c', CONSUMER_CLOUD]
+ notification_sample_consumer_src = ['notificationconsumer.c', consumerCloudConnectorObj]
if env.get('WITH_TCP') == True:
notification_sample_env.AppendUnique(CPPDEFINES = ['WITH_TCP'])
notification_sample_consumer_env.AppendUnique(LIBS = 'libnotification_consumer')
notificationconsumer = notification_sample_consumer_env.Program('notificationconsumer', notification_sample_consumer_src)
i_notificationprovider = notification_sample_consumer_env.Install(env.get('BUILD_DIR'), notificationconsumer)
+
+if env.get('WITH_CLOUD') == True:
+ Export('providerCloudConnectorObj')
+ Export('consumerCloudConnectorObj')
if (response == NS_DISCOVERED)
{
printf("notification resource discovered\n");
- printf("subscribe result %d\n", NSSubscribe(provider));
+ printf("subscribe result %d\n", NSSubscribe(provider->providerId));
printf("startSubscribing\n");
}
}
}
+void input(char * buffer)
+{
+ char ch;
+ int i = 0;
+
+ while( (ch = getchar()) != '\n' && i < 100)
+ buffer[i++] = ch;
+
+ buffer[i] = '\0';
+}
+
int main()
{
int num;
printf("input : ");
- scanf("%d", &num);
- fflush(stdin);
- scanf("%c", &dummy);
- fflush(stdin);
+ if(scanf("%d", &num) > 0)
+ {
+ fflush(stdin);
+ if(scanf("%c", &dummy) > 0)
+ {
+ fflush(stdin);
+ printf("\n");
+ }
+ }
switch (num)
{
case 3:
{
printf("NSSendNotification()");
- char title[100];
- char body[100];
- char topic[100];
+ char title[100] = {'\0',};
+ char body[100] = {'\0',};
+ char topic[100] = {'\0',};
printf("id : %d\n", ++id);
printf("title : ");
- gets(title);
+ input(title);
printf("body : ");
- gets(body);
+ input(body);
printf("topic : ");
- gets(topic);
+ input(topic);
printf("app - mTitle : %s \n", title);
printf("app - mContentText : %s \n", body);
TASK_DELETE_TOPIC = 11002,
TASK_SUBSCRIBE_TOPIC = 11003,
TASK_UNSUBSCRIBE_TOPIC = 11004,
- TASK_POST_TOPIC = 11005
+ TASK_POST_TOPIC = 11005,
+ TASK_GET_TOPICS = 11006,
+ TAST_GET_CONSUMER_TOPICS = 11007
} NSTaskType;
NSOICFree(prov);
}
-NSSyncInfo_internal * NSCopySyncInfo(NSSyncInfo_internal * syncInfo)
-{
- NS_VERIFY_NOT_NULL(syncInfo, NULL);
-
- NSProviderConnectionInfo * connections = NSCopyProviderConnections(syncInfo->connection);
- NS_VERIFY_NOT_NULL(connections, NULL);
-
- NSSyncInfo_internal * newSyncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newSyncInfo, NULL, NSRemoveConnections(connections));
-
- OICStrcpy(newSyncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, syncInfo->providerId);
- newSyncInfo->messageId = syncInfo->messageId;
- newSyncInfo->state = syncInfo->state;
- newSyncInfo->connection = connections;
-
- return newSyncInfo;
-}
-
-void NSRemoveSyncInfo(NSSyncInfo_internal * syncInfo)
-{
- NS_VERIFY_NOT_NULL_V(syncInfo);
-
- NSRemoveConnections(syncInfo->connection);
-
- NSOICFree(syncInfo);
-}
-
OCStackResult NSInvokeRequest(OCDoHandle * handle,
OCMethod method, const OCDevAddr * addr,
const char * queryUrl, OCPayload * payload,
void NSRemoveProvider_internal(NSProvider_internal *);
void NSRemoveProvider(NSProvider *);
-NSSyncInfo_internal * NSCopySyncInfo(NSSyncInfo_internal *);
-void NSRemoveSyncInfo(NSSyncInfo_internal *);
-
NSTopicLL * NSCopyTopicNode(NSTopicLL *);
void NSRemoveTopicNode(NSTopicLL *);
NSResult NSInsertTopicNode(NSTopicLL *, NSTopicLL *);
NS_LOG(DEBUG, "create NSProvider");
NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
+ OCRepPayloadPropType accepterType = OCREP_PROP_BOOL;
+
OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
while (payload)
{
NS_LOG_V(DEBUG, "Payload Key : %s", payload->values->name);
+ NS_LOG_V(DEBUG, "Payload Type : %d", (int) payload->values->type);
+ if (!strcmp(payload->values->name, NS_ATTRIBUTE_POLICY))
+ {
+ accepterType = payload->values->type;
+ }
payload = payload->next;
}
char * messageUri = NULL;
char * syncUri = NULL;
char * topicUri = NULL;
- int64_t accepter = 0;
+ bool bAccepter = 0;
+ int16_t iAccepter = 0;
NSProviderConnectionInfo * connection = NULL;
NS_LOG(DEBUG, "get information of accepter");
- bool getResult = OCRepPayloadGetPropBool(payload, NS_ATTRIBUTE_POLICY, & accepter);
+ bool getResult = false;
+ if (accepterType == OCREP_PROP_BOOL)
+ {
+ getResult = OCRepPayloadGetPropBool(payload, NS_ATTRIBUTE_POLICY, & bAccepter);
+ }
+ else if (accepterType == OCREP_PROP_INT)
+ {
+ getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_POLICY, (int64_t*) & iAccepter);
+ }
NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
NS_LOG(DEBUG, "get provider ID");
{
newProvider->topicUri = topicUri;
}
- newProvider->accessPolicy = (NSSelector)accepter;
+ if (accepterType == OCREP_PROP_BOOL)
+ {
+ newProvider->accessPolicy = (NSSelector)bAccepter;
+ }
+ else if (accepterType == OCREP_PROP_INT)
+ {
+ newProvider->accessPolicy = (NSSelector)iAccepter;
+ }
+
newProvider->connection = connection;
newProvider->topicLL = NULL;
newProvider->state = NS_DISCOVERED;
#include "cautilinterface.h"
#include "NSProviderSystem.h"
#include "oic_time.h"
+#include <pthread.h>
bool initProvider = false;
pthread_mutex_t nsInitMutex;
+pthread_cond_t nstopicCond;
void initializeMutex()
{
nsInitMutex = initMutex;
}
+void NSInitialize()
+{
+ NS_LOG(DEBUG, "NSSetList - IN");
+
+ pthread_mutexattr_init(&NSCacheMutexAttr);
+ pthread_mutexattr_settype(&NSCacheMutexAttr, PTHREAD_MUTEX_RECURSIVE);
+ pthread_mutex_init(&NSCacheMutex, &NSCacheMutexAttr);
+ pthread_cond_init(&nstopicCond, NULL);
+
+ NSInitSubscriptionList();
+ NSInitTopicList();
+ NS_LOG(DEBUG, "NSSetList - OUT");
+}
+
+void NSDeinitailize()
+{
+ NSStorageDestroy(consumerSubList);
+ NSStorageDestroy(consumerTopicList);
+ NSStorageDestroy(registeredTopicList);
+
+ pthread_mutex_destroy(&NSCacheMutex);
+ pthread_mutexattr_destroy(&NSCacheMutexAttr);
+ pthread_cond_destroy(&nstopicCond);
+}
+
NSResult NSStartProvider(NSProviderConfig config)
{
NS_LOG(DEBUG, "NSStartProvider - IN");
CARegisterNetworkMonitorHandler((CAAdapterStateChangedCB)NSProviderAdapterStateListener,
(CAConnectionStateChangedCB)NSProviderConnectionStateListener);
- NSSetList();
+ NSInitialize();
NSInitScheduler();
NSStartScheduler();
return NS_OK;
}
-void NSSetList()
-{
- NS_LOG(DEBUG, "NSSetList - IN");
-
- pthread_mutexattr_init(&NSCacheMutexAttr);
- pthread_mutexattr_settype(&NSCacheMutexAttr, PTHREAD_MUTEX_RECURSIVE);
- pthread_mutex_init(&NSCacheMutex, &NSCacheMutexAttr);
-
- NSInitSubscriptionList();
- NSInitTopicList();
- NS_LOG(DEBUG, "NSSetList - OUT");
-}
-
-void NSDestroyList()
-{
- NSStorageDestroy(consumerSubList);
- NSStorageDestroy(consumerTopicList);
- NSStorageDestroy(registeredTopicList);
-
- pthread_mutex_destroy(&NSCacheMutex);
- pthread_mutexattr_destroy(&NSCacheMutexAttr);
-}
-
NSResult NSStopProvider()
{
NS_LOG(DEBUG, "NSStopProvider - IN");
NSRegisterSubscribeRequestCb((NSSubscribeRequestCallback)NULL);
NSRegisterSyncCb((NSProviderSyncInfoCallback)NULL);
NSStopScheduler();
- NSDestroyList();
+ NSDeinitailize();
initProvider = false;
}
return NULL;
}
- NSTopicLL * topics = NSProviderGetConsumerTopicsCacheData(registeredTopicList,
- consumerTopicList, consumerId);
+ NSTopicSynchronization topics;
+ topics.consumerId = OICStrdup(consumerId);
+ topics.topics = NULL;
+ topics.condition = nstopicCond;
+
+ NSPushQueue(TOPIC_SCHEDULER, TAST_GET_CONSUMER_TOPICS, &topics);
+ pthread_cond_wait(&topics.condition, &nsInitMutex);
+ OICFree(topics.consumerId);
pthread_mutex_unlock(&nsInitMutex);
- return topics;
+ NS_LOG(DEBUG, "NSProviderGetConsumerTopics - OUT");
+ return topics.topics;
}
NSTopicLL * NSProviderGetTopics()
NS_LOG(DEBUG, "NSProviderGetTopics - IN");
pthread_mutex_lock(&nsInitMutex);
- NSTopicLL * topics = NSProviderGetTopicsCacheData(registeredTopicList);
+ NSTopicSynchronization topics;
+ topics.consumerId = NULL;
+ topics.topics = NULL;
+ topics.condition = nstopicCond;
+
+ NSPushQueue(TOPIC_SCHEDULER, TASK_GET_TOPICS, &topics);
+ pthread_cond_wait(&topics.condition, &nsInitMutex);
pthread_mutex_unlock(&nsInitMutex);
NS_LOG(DEBUG, "NSProviderGetTopics - OUT");
-
- return topics;
+ return topics.topics;
}
NSResult NSProviderRegisterTopic(const char * topicName)
#include "NSProviderTopic.h"\r
#include "oic_string.h"\r
#include "oic_malloc.h"\r
+#include <pthread.h>\r
\r
NSResult NSSendTopicUpdation();\r
\r
}\r
}\r
\r
- if(!topics)\r
- {\r
- NS_LOG(DEBUG, "topicList is NULL");\r
- return NS_ERROR;\r
- }\r
-\r
// make response for the Get Request\r
OCEntityHandlerResponse response;\r
response.numSendVendorSpecificHeaderOptions = 0;\r
return NS_ERROR;\r
}\r
\r
- size_t dimensionSize = (size_t)NSProviderGetTopicListSize(topics);\r
-\r
- NS_LOG_V(DEBUG, "dimensionSize = %d", dimensionSize);\r
-\r
- if(!dimensionSize)\r
+ OCRepPayloadSetUri(payload, NS_COLLECTION_TOPIC_URI);\r
+ if(id)\r
{\r
- return NS_ERROR;\r
+ OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_CONSUMER_ID, id);\r
}\r
+ OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID,\r
+ NSGetProviderInfo()->providerId);\r
\r
- OCRepPayload** payloadTopicArray = (OCRepPayload **) OICMalloc(\r
- sizeof(OCRepPayload *) * dimensionSize);\r
+ if(topics)\r
+ {\r
+ NS_LOG(DEBUG, "topicList is NULL");\r
+ size_t dimensionSize = (size_t)NSProviderGetTopicListSize(topics);\r
\r
- size_t dimensions[3] = {dimensionSize, 0, 0};\r
+ NS_LOG_V(DEBUG, "dimensionSize = %d", (int)dimensionSize);\r
\r
- for (int i = 0; i < (int)dimensionSize; i++)\r
- {\r
- NS_LOG_V(DEBUG, "topicName = %s", topics->topicName);\r
- NS_LOG_V(DEBUG, "topicState = %d",(int) topics->state);\r
+ if(!dimensionSize)\r
+ {\r
+ return NS_ERROR;\r
+ }\r
\r
- payloadTopicArray[i] = OCRepPayloadCreate();\r
- OCRepPayloadSetPropString(payloadTopicArray[i], NS_ATTRIBUTE_TOPIC_NAME, topics->topicName);\r
- OCRepPayloadSetPropInt(payloadTopicArray[i], NS_ATTRIBUTE_TOPIC_SELECTION,\r
- (int)topics->state);\r
+ OCRepPayload** payloadTopicArray = (OCRepPayload **) OICMalloc(\r
+ sizeof(OCRepPayload *) * dimensionSize);\r
\r
- topics = topics->next;\r
- }\r
+ size_t dimensions[3] = {dimensionSize, 0, 0};\r
\r
- OCRepPayloadSetUri(payload, NS_COLLECTION_TOPIC_URI);\r
- if(id)\r
+ for (int i = 0; i < (int)dimensionSize; i++)\r
+ {\r
+ NS_LOG_V(DEBUG, "topicName = %s", topics->topicName);\r
+ NS_LOG_V(DEBUG, "topicState = %d",(int) topics->state);\r
+\r
+ payloadTopicArray[i] = OCRepPayloadCreate();\r
+ OCRepPayloadSetPropString(payloadTopicArray[i], NS_ATTRIBUTE_TOPIC_NAME,\r
+ topics->topicName);\r
+ OCRepPayloadSetPropInt(payloadTopicArray[i], NS_ATTRIBUTE_TOPIC_SELECTION,\r
+ (int)topics->state);\r
+\r
+ topics = topics->next;\r
+ }\r
+\r
+\r
+ OCRepPayloadSetPropObjectArray(payload, NS_ATTRIBUTE_TOPIC_LIST,\r
+ (const OCRepPayload**)(payloadTopicArray), dimensions);\r
+ }\r
+ else\r
{\r
- OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_CONSUMER_ID, id);\r
+ size_t dimensions[3] = {0, 0, 0};\r
+\r
+ OCRepPayloadSetPropObjectArrayAsOwner(payload, NS_ATTRIBUTE_TOPIC_LIST,\r
+ (OCRepPayload **) NULL, dimensions);\r
}\r
- OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID,\r
- NSGetProviderInfo()->providerId);\r
- OCRepPayloadSetPropObjectArray(payload, NS_ATTRIBUTE_TOPIC_LIST,\r
- (const OCRepPayload**)(payloadTopicArray), dimensions);\r
\r
response.requestHandle = entityHandlerRequest->requestHandle;\r
response.resourceHandle = entityHandlerRequest->resource;\r
NSFreeOCEntityHandlerRequest((OCEntityHandlerRequest*) node->taskData);\r
}\r
break;\r
+ case TASK_GET_TOPICS:\r
+ {\r
+ NS_LOG(DEBUG, "TASK_GET_TOPICS : ");\r
+ NSTopicSynchronization * topicData = (NSTopicSynchronization *) node->taskData;\r
+ NSTopicLL * topics = NSProviderGetTopicsCacheData(registeredTopicList);\r
+ topicData->topics = topics;\r
+ pthread_cond_signal(&topicData->condition);\r
+ }\r
+ break;\r
+ case TAST_GET_CONSUMER_TOPICS:\r
+ {\r
+ NS_LOG(DEBUG, "TASK_GET_CONSUMER_TOPICS : ");\r
+ NSTopicSynchronization * topicData = (NSTopicSynchronization *) node->taskData;\r
+ NSTopicLL * topics = NSProviderGetConsumerTopicsCacheData(registeredTopicList,\r
+ consumerTopicList, topicData->consumerId);\r
+ topicData->topics = topics;\r
+ pthread_cond_signal(&topicData->condition);\r
+ }\r
+ break;\r
default:\r
break;\r
}\r
#include "NSProviderResource.h"\r
#include "NSProviderSubscription.h"\r
\r
+typedef struct {\r
+ pthread_cond_t condition;\r
+ char * consumerId;\r
+ NSTopicLL * topics;\r
+} NSTopicSynchronization;\r
+\r
NSCacheList * consumerTopicList;\r
NSCacheList * registeredTopicList;\r
\r
};
+TEST_F(NotificationConsumerTest, StartConsumerNegativeNonSetChangedCB)
+{
+ cfg.changedCb = NULL;
+ cfg.messageCb = NSNotificationReceivedCallbackEmpty;
+ cfg.syncInfoCb = NSSyncCallbackEmpty;
+
+ EXPECT_EQ(NS_ERROR, NSStartConsumer(cfg));
+ std::unique_lock< std::mutex > lock{ mutexForCondition };
+ responseCon.wait_for(lock, g_waitForResponse);
+}
+
+TEST_F(NotificationConsumerTest, StartConsumerNegativeNonSetNotiReceiveCB)
+{
+ cfg.changedCb = NSProviderChangedCallback;
+ cfg.messageCb = NULL;
+ cfg.syncInfoCb = NSSyncCallbackEmpty;
+
+ EXPECT_EQ(NS_ERROR, NSStartConsumer(cfg));
+ std::unique_lock< std::mutex > lock{ mutexForCondition };
+ responseCon.wait_for(lock, g_waitForResponse);
+}
+
+TEST_F(NotificationConsumerTest, StartConsumerNegativeNonSetSyncCB)
+{
+ cfg.changedCb = NSProviderChangedCallback;
+ cfg.messageCb = NSNotificationReceivedCallbackEmpty;
+ cfg.syncInfoCb = NULL;
+
+ EXPECT_EQ(NS_ERROR, NSStartConsumer(cfg));
+ std::unique_lock< std::mutex > lock{ mutexForCondition };
+ responseCon.wait_for(lock, g_waitForResponse);
+}
+
TEST_F(NotificationConsumerTest, StartConsumerPositive)
{
+ cfg.changedCb = NSProviderChangedCallback;
+ cfg.messageCb = NSNotificationReceivedCallbackEmpty;
+ cfg.syncInfoCb = NSSyncCallbackEmpty;
+
EXPECT_EQ(NS_OK, NSStartConsumer(cfg));
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);
EXPECT_EQ(NSStopConsumer(), NS_OK);
}
+TEST_F(NotificationConsumerTest, StopConsumerNegative)
+{
+ EXPECT_EQ(NSStopConsumer(), NS_ERROR);
+}
+
TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenStartedConsumerFirst)
{
- mocks.ExpectCallFunc(NSProviderChangedCallback).Do(
- [this](NSProvider *, NSProviderState)
+ NSProviderState revState = NS_STOPPED;
+ mocks.OnCallFunc(NSProviderChangedCallback).Do(
+ [this, & revState](NSProvider *, NSProviderState state)
{
std::cout << "Call Discovered" << std::endl;
+ revState = state;
responseCon.notify_all();
});
NSStopConsumer();
g_providerSimul.deleteNotificationResource();
+
+ EXPECT_EQ(NS_DISCOVERED, revState);
}
TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenStartedConsumerAfter)
responseCon.wait_for(lock, g_waitForResponse);
}
- mocks.ExpectCallFunc(NSProviderChangedCallback).Do(
- [this](NSProvider * provider, NSProviderState)
+ NSProviderState revState = NS_STOPPED;
+ mocks.OnCallFunc(NSProviderChangedCallback).Do(
+ [this, & revState](NSProvider * provider, NSProviderState state)
{
std::cout << "Call Discovered" << std::endl;
+
g_provider = provider;
+ revState = state;
responseCon.notify_all();
});
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);
+ EXPECT_EQ(NS_DISCOVERED, revState);
}
TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenRescan)
{
g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_CONSUMER);
- mocks.ExpectCallFunc(NSProviderChangedCallback).Do(
- [this](NSProvider * provider, NSProviderState)
+ NSProviderState revState = NS_STOPPED;
+ mocks.OnCallFunc(NSProviderChangedCallback).Do(
+ [this, &revState](NSProvider * provider, NSProviderState state)
{
std::cout << "Call Discovered" << std::endl;
+ revState = state;
g_provider = provider;
std::cout << g_provider->providerId << std::endl;
responseCon.notify_all();
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);
-// NSStopConsumer();
+ EXPECT_EQ(NS_DISCOVERED, revState);
}
TEST_F(NotificationConsumerTest, ExpectSubscribeSuccess)
{
-// mocks.ExpectCallFunc(NSSubscriptionAcceptedCallback).Do(
-// [](NSProvider * )
-// {
-// std::cout << "Income Accepted subscription : " << std::endl;
-// });
+ NSProviderState revState = NS_DENY;
+ mocks.OnCallFunc(NSProviderChangedCallback).Do(
+ [this, & revState](NSProvider * , NSProviderState state)
+ {
+ std::cout << "Income Changed Callback : " << state << std::endl;
+ revState = state;
+ responseCon.notify_all();
+ });
NSResult ret = NSSubscribe(g_provider->providerId);
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);
+ EXPECT_EQ(NS_ALLOW, revState);
EXPECT_EQ(NS_OK, ret);
}
std::string msg = "msg";
mocks.ExpectCallFunc(NSNotificationReceivedCallbackEmpty).Do(
- [](NSMessage * message)
+ [this](NSMessage * message)
{
std::cout << "Income Notification : " << message->messageId << std::endl;
});
NSStopConsumer();
}
+TEST_F(NotificationConsumerTest, ExpectReceiveSubAllowWithAccepterisProvider)
+{
+ g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_PROVIDER);
+ NSProviderState revState = NS_DENY;
+
+ mocks.OnCallFunc(NSProviderChangedCallback).Do(
+ [this, & revState](NSProvider * , NSProviderState state)
+ {
+ std::cout << "Income Changed Callback : " << state << std::endl;
+ revState = state;
+ responseCon.notify_all();
+ });
+
+ NSStartConsumer(cfg);
+ std::unique_lock< std::mutex > lock{ mutexForCondition };
+ responseCon.wait_for(lock, g_waitForResponse);
+
+ EXPECT_EQ(NS_ALLOW, revState);
+}
+
TEST_F(NotificationConsumerTest, ExpectReceiveNotificationWithAccepterisProvider)
{
uint64_t id = 11;
std::string title = "title";
std::string msg = "msg";
+ uint64_t revId = 1;
- g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_PROVIDER);
-
- NSStartConsumer(cfg);
- {
- std::unique_lock< std::mutex > lock{ mutexForCondition };
- responseCon.wait_for(lock, g_waitForResponse);
- }
-
- mocks.ExpectCallFunc(NSNotificationReceivedCallbackEmpty).Do(
- [](NSMessage * message)
+ mocks.OnCallFunc(NSNotificationReceivedCallbackEmpty).Do(
+ [this, & id, & revId](NSMessage * message)
{
std::cout << "Income Notification : " << message->messageId << std::endl;
+ revId = message->messageId;
});
g_providerSimul.notifyMessage(id, title, msg);
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);
-// g_providerSimul.deleteNotificationResource();
-// NSStopConsumer();
+ EXPECT_EQ(id, revId);
}
TEST_F(NotificationConsumerTest, ExpectCallbackReadCheckWhenProviderNotifySync)
uint64_t id = 12;
std::string title = "title";
std::string msg = "msg";
-
NSSyncType type = NS_SYNC_DELETED;
mocks.OnCallFunc(NSNotificationReceivedCallbackEmpty).Do(
- [](NSMessage * message)
+ [this](NSMessage * message)
{
std::cout << "Income Notification : " << message->messageId << std::endl;
});
- mocks.ExpectCallFunc(NSSyncCallbackEmpty).Do(
- [& type](NSSyncInfo * sync)
+ mocks.OnCallFunc(NSSyncCallbackEmpty).Do(
+ [& type, this](NSSyncInfo * sync)
{
std::cout << "Income SyncInfo : " << sync->messageId
<< ", State : " << sync->state << std::endl;
type = sync->state;
-
});
g_providerSimul.notifyMessage(id, title, msg);
responseCon.wait_for(lock, g_waitForResponse);
}
-// g_providerSimul.deleteNotificationResource();
-// NSStopConsumer();
-
EXPECT_EQ(NS_SYNC_READ, type);
}
uint64_t id = 13;
std::string title = "title";
std::string msg = "msg";
-
NSSyncType type = NS_SYNC_READ;
mocks.OnCallFunc(NSNotificationReceivedCallbackEmpty).Do(
- [](NSMessage * message)
+ [this](NSMessage * message)
{
std::cout << "Income Notification : " << message->messageId << std::endl;
});
- mocks.ExpectCallFunc(NSSyncCallbackEmpty).Do(
- [& type](NSSyncInfo * sync)
+ mocks.OnCallFunc(NSSyncCallbackEmpty).Do(
+ [& type, this](NSSyncInfo * sync)
{
std::cout << "Income Notification : " << sync->messageId
<< ", State : " << sync->state << std::endl;
type = sync->state;
-
});
g_providerSimul.notifyMessage(id, title, msg);
responseCon.wait_for(lock, g_waitForResponse);
}
-// g_providerSimul.deleteNotificationResource();
-// NSStopConsumer();
-
EXPECT_EQ(NS_SYNC_DELETED, type);
}
uint64_t id = 14;
std::string title = "title";
std::string msg = "msg";
-
NSSyncType type = NS_SYNC_DELETED;
mocks.OnCallFunc(NSNotificationReceivedCallbackEmpty).Do(
- [](NSMessage * message)
+ [this](NSMessage * message)
{
std::cout << "Income Notification : " << message->messageId << std::endl;
NSConsumerSendSyncInfo(message->providerId, message->messageId, NS_SYNC_READ);
responseCon.wait_for(lock, g_waitForResponse);
});
- mocks.ExpectCallFunc(NSSyncCallbackEmpty).Do(
- [& type](NSSyncInfo * sync)
+ mocks.OnCallFunc(NSSyncCallbackEmpty).Do(
+ [& type, this](NSSyncInfo * sync)
{
std::cout << "Income Notification : " << sync->messageId
<< ", State : " << sync->state << std::endl;
type = sync->state;
-
});
g_providerSimul.notifyMessage(id, title, msg);
responseCon.wait_for(lock, g_waitForResponse);
}
-// g_providerSimul.deleteNotificationResource();
-// NSStopConsumer();
-
EXPECT_EQ(NS_SYNC_READ, type);
}
uint64_t id = 15;
std::string title = "title";
std::string msg = "msg";
-
- NSSyncType type = NS_SYNC_READ;
+ NSSyncType state = NS_SYNC_READ;
mocks.OnCallFunc(NSNotificationReceivedCallbackEmpty).Do(
- [](NSMessage * message)
+ [this](NSMessage * message)
{
std::cout << "Income Notification : " << message->messageId << std::endl;
NSConsumerSendSyncInfo(message->providerId, message->messageId, NS_SYNC_DELETED);
responseCon.wait_for(lock, g_waitForResponse);
});
- mocks.ExpectCallFunc(NSSyncCallbackEmpty).Do(
- [& type](NSSyncInfo * sync)
+ mocks.OnCallFunc(NSSyncCallbackEmpty).Do(
+ [& state, this](NSSyncInfo * sync)
{
std::cout << "Income Notification : " << sync->messageId
<< ", State : " << sync->state << std::endl;
- type = sync->state;
-
+ state = sync->state;
});
g_providerSimul.notifyMessage(id, title, msg);
responseCon.wait_for(lock, g_waitForResponse);
}
+ EXPECT_EQ(NS_SYNC_DELETED, state);
+// g_providerSimul.deleteNotificationResource();
+// NSStopConsumer();
+}
+
+TEST_F(NotificationConsumerTest, ExpectCallbackDeletedProvider)
+{
+ NSProviderState type = NS_ALLOW;
+ mocks.OnCallFunc(NSProviderChangedCallback).Do(
+ [& type, this](NSProvider * , NSProviderState state)
+ {
+ std::cout << "Income Changed Callback : " << state << std::endl;
+ //EXPECT_EQ(state, NS_STOPPED);
+ type = state;
+ responseCon.notify_all();
+ });
+
g_providerSimul.deleteNotificationResource();
- NSStopConsumer();
- EXPECT_EQ(NS_SYNC_DELETED, type);
+ std::unique_lock< std::mutex > lock{ mutexForCondition };
+ responseCon.wait_for(lock, g_waitForResponse);
+
+ EXPECT_EQ(type, NS_STOPPED);
+ NSStopConsumer();
}
//TEST_F(NotificationConsumerTest, ExpectUnsubscribeSuccess)
std::string msgUri = m_notificationUri + m_messageUri;
std::string syncUri = m_notificationUri + m_syncUri;
std::string providerId = "123456789012345678901234567890123456";
- rep.setValue("ACCEPTER", m_accepter);
+ rep.setValue("ACCEPTER", (bool) m_accepter);
rep.setValue("MESSAGE_URI", msgUri);
rep.setValue("SYNC_URI", syncUri);
rep.setValue("PROVIDER_ID", providerId);
NSProviderRegisterTopic(str.c_str());
NSProviderRegisterTopic(str2.c_str());
- std::unique_lock< std::mutex > lock{ mutexForCondition };
- responseCon.wait_for(lock, std::chrono::milliseconds(1000));
-
bool isSame = true;
NSTopicLL * topics = NSProviderGetTopics();
NSProviderRegisterTopic(str2.c_str());
NSProviderUnregisterTopic(str2.c_str());
- std::unique_lock< std::mutex > lock{ mutexForCondition };
- responseCon.wait_for(lock, std::chrono::milliseconds(1000));
-
bool isSame = true;
NSTopicLL * topics = NSProviderGetTopics();
projects / contrib / iotivity.git / commitdiff