notification_consumer_src = [
env.Glob('src/consumer/*.c'), env.Glob('src/common/*.c')]
-providersdk = notification_env.SharedLibrary('notification_provider', notification_provider_src)
-notification_env.InstallTarget(providersdk, 'libnotification_provider')
-notification_env.UserInstallTargetLib(providersdk, 'libnotification_provider')
+#providersdk = notification_env.SharedLibrary('notification_provider', notification_provider_src)
+#notification_env.InstallTarget(providersdk, 'libnotification_provider')
+#notification_env.UserInstallTargetLib(providersdk, 'libnotification_provider')
consumersdk = notification_env.SharedLibrary('notification_consumer', notification_consumer_src)
notification_env.InstallTarget(consumersdk, 'libnotification_consumer')
notification_env.UserInstallTargetLib(consumersdk, 'libnotification_consumer')
-providersdk = notification_env.StaticLibrary('notification_provider', notification_provider_src)
-notification_env.InstallTarget(providersdk, 'libnotification_provider')
-notification_env.UserInstallTargetLib(providersdk, 'libnotification_provider')
+#providersdk = notification_env.StaticLibrary('notification_provider', notification_provider_src)
+#notification_env.InstallTarget(providersdk, 'libnotification_provider')
+#notification_env.UserInstallTargetLib(providersdk, 'libnotification_provider')
consumersdk = notification_env.StaticLibrary('notification_consumer', notification_consumer_src)
notification_env.InstallTarget(consumersdk, 'libnotification_consumer')
notification_env.UserInstallTargetLib(consumersdk, 'libnotification_consumer')
-notification_env.UserInstallTargetHeader('include/NSProviderInterface.h',\
- 'service/notification', 'NSProviderInterface.h')
+#notification_env.UserInstallTargetHeader('include/NSProviderInterface.h',\
+# 'service/notification', 'NSProviderInterface.h')
notification_env.UserInstallTargetHeader('include/NSConsumerInterface.h',\
'service/notification', 'NSConsumerInterface.h')
# SConscript('unittest/SConscript')
# Go to build sample apps
-SConscript('examples/SConscript')
+#SConscript('examples/SConscript')
# Go to build jni
-if target_os == 'android':
- SConscript('android/SConscript')
+#if target_os == 'android':
+# SConscript('android/SConscript')
# Go to build c++ wrapper
-SConscript('cpp-wrapper/SConscript')
+#SConscript('cpp-wrapper/SConscript')
NSTopicState state;
struct _nsTopic * next;
-} NSTopics;
+} NSTopicLL;
typedef struct
{
- NSTopics * head;
- NSTopics * tail;
+ NSTopicLL * head;
+ NSTopicLL * tail;
//TODO: decide struct fields
char consumerId[NS_UUID_STRING_SIZE];
- NSTopics ** topics;
+ NSTopicLL ** topics;
} NSTopicList;
typedef struct
{
char providerId[NS_UUID_STRING_SIZE];
- NSTopicList * topicList;
+ NSTopicLL * topicLL;
} NSProvider;
NSMessage * NSConsumerGetMessage(uint64_t messageId);
/**
- * Request NSTopicList that is subscribed from provider
+ * Request NSTopic list that is subscribed from provider
* @param[in] provider the provider that user wants to get
* @return NSResult
*/
NSResult NSConsumerGetInterestTopics(NSProvider * provider);
/**
- * Select Topics that is wanted to subscribe from provider
+ * Select Topic list that is wanted to subscribe from provider
* @param[in] provider the provider that user wants to set
* @return NSResult
*/
* @param[in] consumerid the id of consumer which topic list is subscribed for\r
* @return :: Topic list\r
*/\r
-NSTopics * NSProviderGetConsumerTopics(char *consumerId);\r
+NSTopicLL * NSProviderGetConsumerTopics(char *consumerId);\r
\r
/**\r
* Request topics list already registered by provider user\r
* @return :: Topic list\r
*/\r
-NSTopics * NSProviderGetTopics();\r
+NSTopicLL * NSProviderGetTopics();\r
\r
#ifdef __cplusplus\r
}\r
+
//******************************************************************
//
// Copyright 2016 Samsung Electronics All Rights Reserved.
return retInfo;
}
-void NSRemoveProviderTopicList(NSTopicList * topicList, size_t dimensionSize)
+void NSRemoveTopicNode(NSTopicLL * topicNode)
+{
+ NS_VERIFY_NOT_NULL_V(topicNode);
+
+ NSOICFree(topicNode->topicName);
+ topicNode->next = NULL;
+
+ NSOICFree(topicNode);
+}
+
+NSTopicLL * NSCopyTopicNode(NSTopicLL * topicNode)
+{
+ NS_VERIFY_NOT_NULL(topicNode, NULL);
+
+ NSTopicLL * newTopicNode = (NSTopicLL *)OICMalloc(sizeof(NSTopicLL));
+ NS_VERIFY_NOT_NULL(newTopicNode, NULL);
+
+ newTopicNode->topicName = OICStrdup(topicNode->topicName);
+ newTopicNode->state = topicNode->state;
+ newTopicNode->next = NULL;
+
+ return newTopicNode;
+}
+
+NSResult NSInsertTopicNode(NSTopicLL * topicHead, NSTopicLL * topicNode)
{
- NS_VERIFY_NOT_NULL_V(topicList);
+ NS_VERIFY_NOT_NULL(topicHead, NS_ERROR);
+ NS_VERIFY_NOT_NULL(topicNode, NS_ERROR);
+
+ NSTopicLL * iter = topicHead;
- for (int i = -1; i < (int)dimensionSize; i++)
+ while (iter)
{
- NSOICFree(topicList->topics[i]);
+ iter = (NSTopicLL *) iter->next;
}
- NSOICFree(topicList);
+
+ iter->next = topicNode;
+ topicNode->next = NULL;
+
+ return NS_OK;
}
-NSTopicList * NSCopyProviderTopicList(NSTopicList * topicList, size_t dimensionSize)
+void NSRemoveTopicLL(NSTopicLL * topicHead)
{
- NS_VERIFY_NOT_NULL(topicList, NULL);
+ NS_VERIFY_NOT_NULL_V(topicHead);
+
+ NSTopicLL * iter = topicHead;
- NSTopicList * newTopicList = (NSTopicList *)OICMalloc(sizeof(NSTopicList));
- NS_VERIFY_NOT_NULL(newTopicList, NULL);
+ while (iter)
+ {
+ NSRemoveTopicNode(iter);
- OICStrcpy(newTopicList->consumerId, NS_DEVICE_ID_LENGTH, topicList->consumerId);
+ iter = (NSTopicLL *) iter->next;
+ }
- newTopicList->topics = (NSTopics **) OICMalloc(sizeof(NSTopics *)*dimensionSize);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicList->topics,
- NULL, NSRemoveProviderTopicList(newTopicList, -1));
+ NSOICFree(topicHead);
+}
+
+NSTopicLL * NSCopyTopicLL(NSTopicLL * topicHead)
+{
+ NS_VERIFY_NOT_NULL(topicHead, NULL);
- for (int i = 0; i < (int)dimensionSize; i++)
+ NSTopicLL * iter = topicHead;
+
+ NSTopicLL * newTopicHead = NSCopyTopicNode(iter);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicHead, NULL, NSRemoveTopicLL(newTopicHead));
+
+ iter = (NSTopicLL *) iter->next;
+
+ while (iter)
{
- newTopicList->topics[i] = (NSTopics *) OICMalloc(sizeof(NSTopics));
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicList->topics[i],
- NULL, NSRemoveProviderTopicList(newTopicList, i));
+ NSTopicLL * newTopicNode = NSCopyTopicNode(iter);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicNode, NULL, NSRemoveTopicLL(newTopicHead));
- newTopicList->topics[i]->topicName = OICStrdup(topicList->topics[i]->topicName);
- newTopicList->topics[i]->state = topicList->topics[i]->state;
+ NSResult ret = NSInsertTopicNode(newTopicHead, newTopicNode);
+ NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(NSOCResultToSuccess(ret),
+ NULL, NSRemoveTopicLL(newTopicHead));
+
+ iter = (NSTopicLL *) iter->next;
}
- return newTopicList;
+ return newTopicHead;
}
void NSCopyProviderPostClean(
NSProvider_internal * newProv = (NSProvider_internal *) OICMalloc(sizeof(NSProvider_internal));
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, NSRemoveConnections(connections));
- newProv->topicList = NULL;
- newProv->topicListSize = 0;
+ newProv->topicLL = NULL;
- if (prov->topicList)
+ if (prov->topicLL)
{
- NSTopicList * topicList = NSCopyProviderTopicList(prov->topicList, prov->topicListSize);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicList, NULL,
+ NSTopicLL * newTopicLL = NSCopyTopicLL(prov->topicLL);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicLL, NULL,
NSCopyProviderPostClean(connections, newProv));
- newProv->topicList = topicList;
- newProv->topicListSize = prov->topicListSize;
+ newProv->topicLL = newTopicLL;
}
newProv->connection = connections;
NSOICFree(prov->syncUri);
NSOICFree(prov->topicUri);
NSRemoveConnections(prov->connection);
- NSRemoveProviderTopicList(prov->topicList, prov->topicListSize);
+ if (prov->topicLL)
+ {
+ NSRemoveTopicLL(prov->topicLL);
+ }
NSOICFree(prov);
}
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#ifndef _NS_CONSUMER_CONSTANTS_H_
-#define _NS_CONSUMER_CONSTANTS_H_
+#ifndef _NS_CONSUMER_COMMON_H_
+#define _NS_CONSUMER_COMMON_H_
#ifdef __cplusplus
extern "C" {
{
char providerId[NS_DEVICE_ID_LENGTH];
+ NSTopicLL * topicLL;
+
char * messageUri;
char * syncUri;
char * topicUri;
NSProviderConnectionInfo * connection;
- NSTopicList * topicList;
- size_t topicListSize;
-
} NSProvider_internal;
typedef struct
NSMessage * NSCopyMessage(NSMessage *);
void NSRemoveMessage(NSMessage *);
-NSProviderConnectionInfo * NSCreateProviderConnections(OCDevAddr * inAddr);
-NSProviderConnectionInfo * NSCopyProviderConnections(NSProviderConnectionInfo * conn);
-void NSRemoveConnections(NSProviderConnectionInfo * connections);
+NSProviderConnectionInfo * NSCreateProviderConnections(OCDevAddr *);
+NSProviderConnectionInfo * NSCopyProviderConnections(NSProviderConnectionInfo *);
+void NSRemoveConnections(NSProviderConnectionInfo *);
NSProvider_internal * NSCopyProvider(NSProvider_internal *);
void NSRemoveProvider(NSProvider_internal *);
NSSyncInfo_internal * NSCopySyncInfo(NSSyncInfo_internal *);
void NSRemoveSyncInfo(NSSyncInfo_internal *);
-NSTopicList * NSCopyProviderTopicList(NSTopicList * topicList, size_t dimensionSize);
-void NSRemoveProviderTopicList(NSTopicList * topicList, size_t dimensionSize);
+NSTopicLL * NSCopyTopicNode(NSTopicLL *);
+void NSRemoveTopicNode(NSTopicLL *);
+NSResult NSInsertTopicNode(NSTopicLL *, NSTopicLL *);
+
+NSTopicLL * NSCopyTopicLL(NSTopicLL *);
+void NSRemoveTopicLL(NSTopicLL *);
OCStackResult NSInvokeRequest(OCDoHandle * handle,
OCMethod method, const OCDevAddr * addr,
}
#endif // __cplusplus
-#endif // _NS_CONSUMER_CONSTANTS_H_
+#endif // _NS_CONSUMER_COMMON_H_
connections = connections->next;
}
}
- /* TODO next commit, modify code.
- else if (task->taskType == TASK_CONSUMER_REQ_TOPIC_LIST)
- {
- NSProvider_internal * provider = (NSProvider_internal *)task->taskData;
-
- NSProviderConnectionInfo * connections = provider->connection;
- NS_VERIFY_NOT_NULL_V(connections);
-
- char * topicUri = OICStrdup(provider->topicUri);
-
- OCConnectivityType type = CT_DEFAULT;
- if (connections->addr->adapter == OC_ADAPTER_TCP)
- {
- type = CT_ADAPTER_TCP;
- if (connections->isCloudConnection == true)
- {
- topicUri = NSGetCloudUri(provider->providerId, topicUri);
- }
- }
-
- OCStackResult ret = NSInvokeRequest(NULL, OC_REST_GET, connections->addr,
- topicUri, NULL, NSIntrospectTopic, (void *) provider, type);
- NS_VERIFY_STACK_SUCCESS_V(NSOCResultToSuccess(ret));
- NSOICFree(topicUri);
- }
- else if (task->taskType == TASK_CONSUMER_GET_TOPIC_LIST)
+ else if (task->taskType == TASK_CONSUMER_REQ_TOPIC_LIST
+ || task->taskType == TASK_CONSUMER_GET_TOPIC_LIST)
{
NSProvider_internal * provider = (NSProvider_internal *)task->taskData;
NS_LOG(DEBUG, "get topic query");
char * query = NULL;
- query = NSMakeRequestUriWithConsumerId(topicUri);
+ if (task->taskType == TASK_CONSUMER_REQ_TOPIC_LIST)
+ {
+ query = OICStrdup(topicUri);
+ }
+ else if (task->taskType == TASK_CONSUMER_GET_TOPIC_LIST)
+ {
+ query = NSMakeRequestUriWithConsumerId(topicUri);
+ }
NS_VERIFY_NOT_NULL_V(query);
NS_LOG_V(DEBUG, "topic query : %s", query);
OCStackResult ret = NSInvokeRequest(NULL, OC_REST_GET, connections->addr,
- query, NULL, NSIntrospectTopic, NULL, type);
+ query, NULL, NSIntrospectTopic, (void *) provider, type);
NS_VERIFY_STACK_SUCCESS_V(NSOCResultToSuccess(ret));
+
NSOICFree(query);
NSOICFree(topicUri);
}
OCRepPayload * payload = OCRepPayloadCreate();
NS_VERIFY_NOT_NULL_V(payload);
- OCRepPayload ** topicPayload = (OCRepPayload **) OICMalloc(
- sizeof(OCRepPayload *)*provider->topicListSize);
- NS_VERIFY_NOT_NULL_V(topicPayload);
+
+ NSTopicLL * topicLL = provider->topicLL;
+ NSTopicLL * iter = topicLL;
+ int topicLLSize = 0;
+ while (iter)
+ {
+ topicLLSize ++;
+ iter = (NSTopicLL *) iter->next;
+ }
OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_CONSUMER_ID, *NSGetConsumerId());
- NSTopic ** topic = provider->topicList->topics;
+ iter = topicLL;
+ int iterSize = 0;
- for (int i = 0; i < (int)provider->topicListSize; i++)
+ OCRepPayload ** topicPayload = NULL;
+ if (topicLLSize > 0)
{
- topicPayload[i] = OCRepPayloadCreate();
- OCRepPayloadSetPropString(topicPayload[i], NS_ATTRIBUTE_TOPIC_NAME, topic[i]->topicName);
- OCRepPayloadSetPropInt(topicPayload[i], NS_ATTRIBUTE_TOPIC_SELECTION, topic[i]->state);
- }
+ topicPayload = (OCRepPayload **) OICMalloc(sizeof(OCRepPayload *)*topicLLSize);
+ NS_VERIFY_NOT_NULL_V(topicPayload);
- size_t dimensions[3] = {provider->topicListSize, 0, 0};
- OCRepPayloadSetPropObjectArray(payload, NS_ATTRIBUTE_TOPIC_LIST, (const OCRepPayload **)topicPayload, dimensions);
+ while (iter || iterSize < topicLLSize)
+ {
+ topicPayload[iterSize] = OCRepPayloadCreate();
+ OCRepPayloadSetPropString(topicPayload[iterSize], NS_ATTRIBUTE_TOPIC_NAME,
+ iter->topicName);
+ OCRepPayloadSetPropInt(topicPayload[iterSize], NS_ATTRIBUTE_TOPIC_SELECTION,
+ iter->state);
+ iterSize++;
+ iter = iter->next;
+ }
+ size_t dimensions[3] = {topicLLSize, 0, 0};
+ OCRepPayloadSetPropObjectArrayAsOwner(payload, NS_ATTRIBUTE_TOPIC_LIST,
+ topicPayload, dimensions);
+ }
+ else
+ {
+ OCRepPayloadSetNull(payload, NS_ATTRIBUTE_TOPIC_LIST);
+ }
char * topicUri = OICStrdup(provider->topicUri);
NS_VERIFY_NOT_NULL_V(query);
NS_LOG_V(DEBUG, "topic query : %s", query);
- OCStackResult ret = NSInvokeRequest(NULL, OC_REST_GET, connections->addr,
+ OCStackResult ret = NSInvokeRequest(NULL, OC_REST_POST, connections->addr,
query, (OCPayload*)payload, NSConsumerCheckPostResult, NULL, type);
NS_VERIFY_STACK_SUCCESS_V(NSOCResultToSuccess(ret));
+
NSOICFree(query);
NSOICFree(topicUri);
- }*/
+ }
else
{
NS_LOG(ERROR, "Unknown type message");
NSOICFree(task);
}
-void NSGetTopicPostClean(
- char * cId, NSTopicList * tList, size_t dSize)
+NSTopicLL * NSGetTopicLL(OCClientResponse * clientResponse)
{
- /* TODO next commit, modify code.
- NSOICFree(cId);
- NSRemoveProviderTopicList(tList, dSize);
- */
-}
-
-NSTopicList * NSGetTopic(OCClientResponse * clientResponse, size_t * topicListSize)
-{
- /* TODO next commit, modify code.
- NS_LOG(DEBUG, "create NSTopic");
+ NS_LOG(DEBUG, "create NSTopicLL");
NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
payload = (OCRepPayload *)clientResponse->payload;
char * consumerId = NULL;
- OCRepPayload ** topicListPayload = NULL;
- NSTopicList * topicList = (NSTopicList *) OICMalloc(sizeof(NSTopicList));
- NS_VERIFY_NOT_NULL(topicList, NULL);
+ OCRepPayload ** topicLLPayload = NULL;
NS_LOG(DEBUG, "get information of consumerId");
- bool getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_CONSUMER_ID, & consumerId); // is NULL possible? (initial getting)
- NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
- OICStrcpy(topicList->consumerId, NS_DEVICE_ID_LENGTH, consumerId);
+ bool getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_CONSUMER_ID, & consumerId);
+ NSOICFree(consumerId);
OCRepPayloadValue * payloadValue = NULL;
payloadValue = NSPayloadFindValue(payload, NS_ATTRIBUTE_TOPIC_LIST);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(payloadValue, NULL, NSOICFree(consumerId));
+ NS_VERIFY_NOT_NULL(payloadValue, NULL);
size_t dimensionSize = calcDimTotal(payloadValue->arr.dimensions);
- size_t dimensions[3] = {dimensionSize, 0, 0};
- *topicListSize = dimensionSize;
- NS_LOG(DEBUG, "get information of topicList(OCRepPayload)");
- getResult = OCRepPayloadGetPropObjectArray(payload, NS_ATTRIBUTE_TOPIC_LIST,
- & topicListPayload, dimensions);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL,
- NULL, NSOICFree(consumerId));
+ if (dimensionSize == 0 || payloadValue->type == OCREP_PROP_NULL ||
+ payloadValue->arr.objArray == NULL)
+ {
+ NS_LOG(DEBUG, "No TopicLL");
+ return NULL;
+ }
- topicList->topics = (NSTopic **) OICMalloc(sizeof(NSTopic *)*dimensionSize);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicList->topics,
- NULL, NSGetTopicPostClean(consumerId, topicList, -1));
+ topicLLPayload = payloadValue->arr.objArray;
+ NSTopicLL * topicLL = NULL;
for (int i = 0; i < (int)dimensionSize; i++)
{
char * topicName = NULL;
int64_t state = 0;
- topicList->topics[i] = (NSTopic *) OICMalloc(sizeof(NSTopic));
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicList->topics[i],
- NULL, NSGetTopicPostClean(consumerId, topicList, i));
+ NSTopicLL * topicNode = (NSTopicLL *) OICMalloc(sizeof(NSTopicLL));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicNode, NULL, NSRemoveTopicLL(topicLL));
+
+ NS_LOG(DEBUG, "get topic selection");
+ getResult = OCRepPayloadGetPropInt(topicLLPayload[i],
+ NS_ATTRIBUTE_TOPIC_SELECTION, & state);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL,
+ NULL, NSRemoveTopicLL(topicLL));
NS_LOG(DEBUG, "get topic name");
- getResult = OCRepPayloadGetPropString(topicListPayload[i], NS_ATTRIBUTE_TOPIC_NAME, &topicName);
+ getResult = OCRepPayloadGetPropString(topicLLPayload[i],
+ NS_ATTRIBUTE_TOPIC_NAME, & topicName);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL,
- NULL, NSGetTopicPostClean(consumerId, topicList, i));
+ NULL, NSRemoveTopicLL(topicLL));
+ topicNode->topicName = topicName;
+ topicNode->state = state;
- NS_LOG(DEBUG, "get topic selection");
- getResult = OCRepPayloadGetPropInt(topicListPayload[i], NS_ATTRIBUTE_TOPIC_SELECTION, &state);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL,
- NULL, NSGetTopicPostClean(consumerId, topicList, i));
+ if (i == 0)
+ {
+ topicLL = topicNode;
+ continue;
+ }
- topicList->topics[i]->topicName = topicName;
- topicList->topics[i]->state = state;
+ NSResult ret = NSInsertTopicNode(topicLL, topicNode);
+ NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(NSOCResultToSuccess(ret),
+ NULL, NSRemoveTopicLL(topicLL));
}
- NSOICFree(consumerId);
-
- return topicList;*/
+ return topicLL;
}
OCStackApplicationResult NSIntrospectTopic(
void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
{
-/* TODO next commit, modify code.
(void) handle;
- NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
- NS_VERIFY_STACK_SUCCESS(NSOCResultToSuccess(clientResponse->result), OC_STACK_KEEP_TRANSACTION);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(clientResponse, OC_STACK_KEEP_TRANSACTION,
+ NSRemoveProvider((NSProvider_internal *) ctx));
+ NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(NSOCResultToSuccess(clientResponse->result),
+ OC_STACK_KEEP_TRANSACTION, NSRemoveProvider((NSProvider_internal *) ctx));
NS_LOG_V(DEBUG, "GET response income : %s:%d",
clientResponse->devAddr.addr, clientResponse->devAddr.port);
NS_LOG_V(DEBUG, "GET response resource uri : %s",
clientResponse->resourceUri);
NS_LOG_V(DEBUG, "GET response Transport Type : %d",
- clientResponse->devAddr.adapter);
+ clientResponse->devAddr.adapter);
- size_t topicListSize = 0;
- NSTopicList * newTopicList = NSGetTopic(clientResponse, &topicListSize);
- NS_VERIFY_NOT_NULL(newTopicList, OC_STACK_KEEP_TRANSACTION);
+ NSTopicLL * newTopicLL = NSGetTopicLL(clientResponse);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicLL, OC_STACK_KEEP_TRANSACTION,
+ NSRemoveProvider((NSProvider_internal *) ctx));
- // TODO Call the callback function registered at the start
NSProvider_internal * provider = (NSProvider_internal *) ctx;
- provider->topicList = NSCopyProviderTopicList(newTopicList, topicListSize);
- provider->topicListSize = topicListSize;
+ provider->topicLL = NSCopyTopicLL(newTopicLL);
NS_LOG(DEBUG, "build NSTask");
NSTask * task = NSMakeTask(TASK_CONSUMER_RECV_TOPIC_LIST, (void *) provider);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider(provider));
NSConsumerPushEvent(task);
- NSRemoveProviderTopicList(newTopicList, topicListSize);
+ NSRemoveTopicLL(newTopicLL);
return OC_STACK_KEEP_TRANSACTION;
- */
}
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
NSGetProviderPostClean(providerId, messageUri, syncUri, topicUri, connection));
- /* TODO next commit, modify code.
NS_LOG(DEBUG, "get topic URI");
getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TOPIC, & topicUri);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
NSGetProviderPostClean(providerId, messageUri, syncUri, topicUri, connection));
- */
NS_LOG(DEBUG, "get provider connection information");
NS_VERIFY_NOT_NULL(clientResponse->addr, NULL);
NSResult NSConsumerGetInterestTopics(NSProvider * provider)
{
- /* TODO next commit, modify code.
bool isStartedConsumer = NSIsStartedConsumer();
NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
NS_VERIFY_NOT_NULL(provider, NS_ERROR);
+ NSSelector selector = (NSSelector)((NSProvider_internal *) provider)->accessPolicy;
+ NS_VERIFY_NOT_NULL(selector == NS_SELECTION_CONSUMER ? (void *) 1 : NULL, NS_ERROR);
+
NSTask * topicTask = NSMakeTask(TASK_CONSUMER_GET_TOPIC_LIST, (void *) provider);
NS_VERIFY_NOT_NULL(topicTask, NS_ERROR);
return NSConsumerPushEvent(topicTask);
- */
}
NSResult NSConsumerSelectInterestTopics(NSProvider * provider)
{
- /* TODO next commit, modify code.
bool isStartedConsumer = NSIsStartedConsumer();
NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
NS_VERIFY_NOT_NULL(provider, NS_ERROR);
- if (!provider->topicList)
- provider->topicList = (NSTopicList *) OICMalloc(sizeof(NSTopicList));
- NS_VERIFY_NOT_NULL(provider->topicList, NS_ERROR);
+ NSSelector selector = (NSSelector)((NSProvider_internal *) provider)->accessPolicy;
+ NS_VERIFY_NOT_NULL(selector == NS_SELECTION_CONSUMER ? (void *) 1 : NULL, NS_ERROR);
+
+ if (!provider->topicLL)
+ {
+ provider->topicLL = (NSTopicLL *) OICMalloc(sizeof(NSTopicLL));
+ }
+ NS_VERIFY_NOT_NULL(provider->topicLL, NS_ERROR);
- OICStrcpy(provider->topicList->consumerId, NS_DEVICE_ID_LENGTH, provider->providerId);
NSTask * topicTask = NSMakeTask(TASK_CONSUMER_SELECT_TOPIC_LIST, (void *) provider);
NS_VERIFY_NOT_NULL(provider, NS_ERROR);
return NSConsumerPushEvent(topicTask);
- */
}
NSResult NSDropNSMessage(NSMessage * obj)
NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
NS_VERIFY_NOT_NULL_V(provider);
- if (provider->connection->next == NULL)
+ if (provider->connection->next == NULL && provider->accessPolicy == NS_SELECTION_CONSUMER)
{
NS_LOG(DEBUG, "call back to user");
NSProviderChanged((NSProvider *) provider, (NSResponse) msg->messageId);
NSConsumerPushEvent(topicTask);
}
-void NSConsumerHandleRecvTopicList(NSProvider_internal * provider)
+void NSConsumerHandleRecvTopicLL(NSProvider_internal * provider)
{
NS_VERIFY_NOT_NULL_V(provider);
NSResult ret = NSProviderCacheUpdate(provider);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
- // call the callback function when consumer is an accepter
if (provider->connection->next == NULL)
{
NS_LOG(DEBUG, "call back to user");
case TASK_CONSUMER_RECV_TOPIC_LIST:
{
NS_LOG(DEBUG, "Receive Topic List");
- NSConsumerHandleRecvTopicList((NSProvider_internal *)task->taskData);
+ NSConsumerHandleRecvTopicLL((NSProvider_internal *)task->taskData);
NSRemoveProvider((NSProvider_internal *)task->taskData);
break;
}
case TASK_RECV_SYNCINFO:
case TASK_CONSUMER_RECV_MESSAGE:
case TASK_CONSUMER_PROVIDER_DISCOVERED:
- //case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
case TASK_CONSUMER_RECV_PROVIDER_CHANGED:
case TASK_MAKE_SYNCINFO:
case TASK_CONSUMER_REQ_TOPIC_URI:
projects / platform / upstream / iotivity.git / commitdiff