Updated for consumer APIs. 49/8749/3
authorKIM JungYong <jyong2.kim@samsung.com>
Fri, 17 Jun 2016 07:32:11 +0000 (16:32 +0900)
committerUze Choi <uzchoi@samsung.com>
Mon, 20 Jun 2016 07:31:57 +0000 (07:31 +0000)
Parameters of NSConsumerStart func is modified to sturcture.
NSConsumerSendSyncInfo is added instead Read/DeleteCheck.
NSConsumerReadCheck and DeleteCheck is removed.
NSDropNSObject is removed.
typo error is fixed to NS_VERIFT~.

Change-Id: I4d00d4d1abdb3a4996e0ba5db82ac9bff1de18e9
Signed-off-by: KIM JungYong <jyong2.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/8749
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>
13 files changed:
service/notification/examples/linux/notificationconsumer.c
service/notification/include/NSConsumerInterface.h
service/notification/src/common/NSConstants.h
service/notification/src/consumer/NSConsumerCommon.c
service/notification/src/consumer/NSConsumerCommon.h
service/notification/src/consumer/NSConsumerCommunication.c
service/notification/src/consumer/NSConsumerDiscovery.c
service/notification/src/consumer/NSConsumerInterface.c
service/notification/src/consumer/NSConsumerInternalTaskController.c
service/notification/src/consumer/NSConsumerNetworkEventListener.c
service/notification/src/consumer/NSConsumerQueue.c
service/notification/src/consumer/NSConsumerQueueScheduler.c
service/notification/src/consumer/NSThread.c

index bd3ba48..e5a9b56 100644 (file)
@@ -5,19 +5,6 @@
 #include "NSConsumerInterface.h"
 #include "ocstack.h"
 
-void onNotificationPosted(NSProvider * provider, NSMessage * notification)
-{
-    (void) provider;
-//    printf("Notification from : %s:%d\n", ((OCDevAddr *)provider->mUserData)->addr,
-//            ((OCDevAddr *)provider->mUserData)->port);
-    printf("id : %ld\n", notification->messageId);
-    printf("title : %s\n", notification->title);
-    printf("content : %s\n", notification->contentText);
-    printf("source : %s\n", notification->sourceName);
-//    NSDropNSObject(notification);
-    NSConsumerReadCheck(notification);
-}
-
 void onDiscoverNotification(NSProvider * provider)
 {
     printf("notification resource discovered\n");
@@ -25,11 +12,23 @@ void onDiscoverNotification(NSProvider * provider)
     printf("startSubscribing\n");
 }
 
-void onNotificationSync(NSProvider * provider, NSSyncInfo * sync)
+void onSubscriptionAccepted(NSProvider * provider)
+{
+    printf("Subscription accepted\n");
+    printf("subscribed provider Id : %s\n", provider->providerId);
+}
+
+void onNotificationPosted(NSMessage * notification)
+{
+    printf("id : %ld\n", notification->messageId);
+    printf("title : %s\n", notification->title);
+    printf("content : %s\n", notification->contentText);
+    printf("source : %s\n", notification->sourceName);
+    NSConsumerSendSyncInfo(notification->providerId, notification->messageId, NS_SYNC_READ);
+}
+
+void onNotificationSync(NSSyncInfo * sync)
 {
-    (void) provider;
-//    printf("Sync from : %s:%d\n", ((OCDevAddr *)provider->mUserData)->addr,
-//            ((OCDevAddr *)provider->mUserData)->port);
     printf("Sync ID : %ld\n", sync->messageId);
     printf("Sync STATE : %d\n", sync->state);
 }
@@ -44,13 +43,15 @@ int main(void)
         return 0;
     }
 
+    NSConsumerConfig cfg;
+    cfg.discoverCb = onDiscoverNotification;
+    cfg.acceptedCb = onSubscriptionAccepted;
+    cfg.messageCb = onNotificationPosted;
+    cfg.syncInfoCb = onNotificationSync;
 
 
     printf("start notification consumer service\n");
-    NSResult ret = NSStartConsumer(
-            onDiscoverNotification,
-            onNotificationPosted,
-            onNotificationSync);
+    NSResult ret = NSStartConsumer(cfg);
     if(ret != NS_OK)
     {
         printf("error discoverNoti %d\n", ret);
index 0353e95..ba49e1f 100644 (file)
@@ -34,19 +34,13 @@ extern "C"
 
 #include "NSCommon.h"
 
-/**
- * Provider and consumer use this callback function to receive the status of the message
- * synchronization
- * @param[in] provider    Provider who requests synchronization with the status
- * @param[in] sync        Synchronization information of the notification message
- */
-typedef void (*NSSyncCallback)(NSProvider *, NSSyncInfo *);
-
 /**
  * Consumer uses this callback function to receive the discovered providers
  * @param[in] provider        Provider who has the notification resource
  */
-typedef void (*NSProviderDiscoveredCallback)(NSProvider *);
+typedef void (* NSProviderDiscoveredCallback)(NSProvider *);
+
+typedef void (* NSSubscriptionAcceptedCallback)(NSProvider *);
 
 /**
  * Consumer use this callback function to receive notification message from provider
@@ -54,7 +48,24 @@ typedef void (*NSProviderDiscoveredCallback)(NSProvider *);
  * @param[in] provider    Provider who sends notification message
  * @param[in] message     Notification message
  */
-typedef void (*NSNotificationReceivedCallback)(NSProvider *, NSMessage *);
+typedef void (* NSMessageReceivedCallback)(NSMessage *);
+
+/**
+ * Provider and consumer use this callback function to receive the status of the message
+ * synchronization
+ * @param[in] provider    Provider who requests synchronization with the status
+ * @param[in] sync        Synchronization information of the notification message
+ */
+typedef void (* NSSyncInfoReceivedCallback)(NSSyncInfo *);
+
+typedef struct
+{
+    NSProviderDiscoveredCallback discoverCb;
+    NSSubscriptionAcceptedCallback acceptedCb;
+    NSMessageReceivedCallback messageCb;
+    NSSyncInfoReceivedCallback syncInfoCb;
+
+} NSConsumerConfig;
 
 /**
  * Initialize notification service for consumer
@@ -63,8 +74,7 @@ typedef void (*NSNotificationReceivedCallback)(NSProvider *, NSMessage *);
  * @param[in]  syncCallback   Callback function to receive synchronization status of notification
  * @return ::NS_OK or result code of NSResult
  */
-NSResult NSStartConsumer(NSProviderDiscoveredCallback discoverCb,
-        NSNotificationReceivedCallback postCb, NSSyncCallback syncCb);
+NSResult NSStartConsumer(NSConsumerConfig config);
 
 /**
  * Terminate notification service for consumer
@@ -92,13 +102,8 @@ NSResult NSSubscribe(NSProvider *provider);
  */
 NSResult NSUnsubscribe(NSProvider *provider);
 
-NSResult NSConsumerReadCheck(NSMessage *);
-
-NSResult NSConsumerDismissCheck(NSMessage *);
-
-//** Remove below functions **//
-NSResult NSDropNSObject(NSMessage *);
-//** end of functions to be removed **//
+NSResult NSConsumerSendSyncInfo(
+        const char * providerId, uint64_t messageId, NSSyncType type);
 
 #ifdef __cplusplus
 }
index 9c91439..4aef533 100644 (file)
@@ -119,6 +119,7 @@ typedef enum eTaskType
     TASK_RECV_SYNCINFO = 5000,
     TASK_RECV_READ = 5001,
     TASK_RECV_DISMISS = 5003,
+    TASK_SEND_SYNCINFO = 5100,
     TASK_SEND_READ = 5101,
     TASK_SEND_DISMISS = 5102,
 
index 5c9ee73..3dddedd 100644 (file)
@@ -34,28 +34,28 @@ char ** NSGetConsumerId()
 
 void NSSetConsumerId(char * cId)
 {
-    NS_VERTIFY_NOT_NULL_V(cId);
+    NS_VERIFY_NOT_NULL_V(cId);
     char ** consumerId = NSGetConsumerId();
     NSOICFree(*consumerId);
     *consumerId = (char *)OICMalloc(sizeof(char) * NS_DEVICE_ID_LENGTH);
-    NS_VERTIFY_NOT_NULL_V(*consumerId);
+    NS_VERIFY_NOT_NULL_V(*consumerId);
 
     OICStrcpy(*consumerId, sizeof(char) * NS_DEVICE_ID_LENGTH, cId);
 }
 
-char * NSGetQuery(const char * uri)
+char * NSMakeRequestUriWithConsumerId(const char * uri)
 {
-    NS_VERTIFY_NOT_NULL(uri, NULL);
+    NS_VERIFY_NOT_NULL(uri, NULL);
 
     char * consumerId = OICStrdup(*NSGetConsumerId());
-    NS_VERTIFY_NOT_NULL(consumerId, NULL);
+    NS_VERIFY_NOT_NULL(consumerId, NULL);
 
     size_t uriLen = strlen(uri) + 1;
     size_t qKeyLen = sizeof(NS_QUERY_CONSUMER_ID);
     size_t queryLen = NS_DEVICE_ID_LENGTH + uriLen + qKeyLen + 2;
 
     char * retQuery = (char *)OICMalloc(sizeof(char) * queryLen);
-    NS_VERTIFY_NOT_NULL(retQuery, NULL);
+    NS_VERIFY_NOT_NULL(retQuery, NULL);
 
     size_t index = 0;
     OICStrcpy((retQuery + index), uriLen, uri);
@@ -117,93 +117,85 @@ void * NSDiscoveredProviderFunc(void * provider)
 void NSDiscoveredProvider(NSProvider * provider)
 {
     NSConsumerThread * thread = NSThreadInit(NSDiscoveredProviderFunc, (void *) provider);
-    NS_VERTIFY_NOT_NULL_V(thread);
+    NS_VERIFY_NOT_NULL_V(thread);
 }
 
-NSSyncCallback * NSGetBoneNotificationSyncCb()
+NSSubscriptionAcceptedCallback * NSGetSubscriptionAcceptedCb()
 {
-    static NSSyncCallback g_syncCb = NULL;
+    static NSSubscriptionAcceptedCallback g_acceptCb = NULL;
 
-    return & g_syncCb;
+    return & g_acceptCb;
 }
 
-void NSSetNotificationSyncCb(NSSyncCallback cb)
+void NSSetSubscriptionAcceptedCb(NSSubscriptionAcceptedCallback cb)
 {
-    * NSGetBoneNotificationSyncCb() = cb;
+    *(NSGetSubscriptionAcceptedCb()) = cb;
+}
+
+void NSSubscriptionAccepted(NSProvider * provider)
+{
+    (*(NSGetSubscriptionAcceptedCb()))(provider);
 }
 
-typedef struct
+NSSyncInfoReceivedCallback * NSGetBoneNotificationSyncCb()
 {
-    NSProvider * provider;
-    NSSyncInfo * sync;
-} NSSyncData;
+    static NSSyncInfoReceivedCallback g_syncCb = NULL;
+
+    return & g_syncCb;
+}
+
+void NSSetNotificationSyncCb(NSSyncInfoReceivedCallback cb)
+{
+    * NSGetBoneNotificationSyncCb() = cb;
+}
 
 void * NSNotificationSyncFunc(void * obj)
 {
-    NSProvider * provider = ((NSSyncData *) obj)->provider;
-    NSSyncInfo * syncData = ((NSSyncData *) obj)->sync;
-    (* NSGetBoneNotificationSyncCb())(provider, syncData);
+    (* NSGetBoneNotificationSyncCb())((NSSyncInfo *) obj);
     return NULL;
 }
 
-void NSNotificationSync(NSProvider * provider, NSSyncInfo * sync)
+void NSNotificationSync(NSSyncInfo * sync)
 {
-    NSSyncData * obj = (NSSyncData *)OICMalloc(sizeof(NSSyncData));
-    NS_VERTIFY_NOT_NULL_V(obj);
-    obj->provider = provider;
-    obj->sync = sync;
-
-    NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) obj);
-    NS_VERTIFY_NOT_NULL_V(thread);
+    NS_VERIFY_NOT_NULL_V(sync);
+    NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) sync);
+    NS_VERIFY_NOT_NULL_V(thread);
 }
 
-NSNotificationReceivedCallback  * NSGetBoneMessagePostedCb()
+NSMessageReceivedCallback  * NSGetBoneMessagePostedCb()
 {
-    static NSNotificationReceivedCallback  g_postCb = NULL;
+    static NSMessageReceivedCallback  g_postCb = NULL;
 
     return & g_postCb;
 }
 
-void NSSetMessagePostedCb(NSNotificationReceivedCallback  cb)
+void NSSetMessagePostedCb(NSMessageReceivedCallback  cb)
 {
     * NSGetBoneMessagePostedCb() = cb;
 }
 
-NSNotificationReceivedCallback  NSGetMessagePostedCb()
+NSMessageReceivedCallback  NSGetMessagePostedCb()
 {
     return * NSGetBoneMessagePostedCb();
 }
 
-typedef struct
-{
-    NSProvider * provider;
-    NSMessage * msg;
-} NSMessageData;
-
 void * NSMessagePostFunc(void * obj)
 {
-    NSMessageData * msgData = (NSMessageData *) obj;
-
-    NSGetMessagePostedCb()((NSProvider *) msgData->provider,
-            (NSMessage *) msgData->msg);
+    NSGetMessagePostedCb()((NSMessage *) obj);
     return NULL;
 }
 
-void NSMessagePost(NSProvider * provider, NSMessage * msg)
+void NSMessagePost(NSMessage * msg)
 {
-    NSMessageData * obj = (NSMessageData *)OICMalloc(sizeof(NSMessageData));
-    NS_VERTIFY_NOT_NULL_V(obj);
-    obj->provider = provider;
-    obj->msg = msg;
-
-    NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) obj);
-    NS_VERTIFY_NOT_NULL_V(thread);
+    NS_VERIFY_NOT_NULL_V(msg);
+    NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) msg);
+    NS_VERIFY_NOT_NULL_V(thread);
 }
 
 NSTask * NSMakeTask(NSTaskType type, void * data)
 {
     NSTask * retTask = OICMalloc(sizeof(NSTask));
-    NS_VERTIFY_NOT_NULL(retTask, NULL);
+    NS_VERIFY_NOT_NULL(retTask, NULL);
 
     retTask->taskType = type;
     retTask->taskData = data;
@@ -214,13 +206,13 @@ NSTask * NSMakeTask(NSTaskType type, void * data)
 
 NSMessage_consumer * NSCopyMessage(NSMessage_consumer * msg)
 {
-    NS_VERTIFY_NOT_NULL(msg, NULL);
+    NS_VERIFY_NOT_NULL(msg, NULL);
 
     NSMessage_consumer * newMsg = (NSMessage_consumer *)OICMalloc(sizeof(NSMessage_consumer));
-    NS_VERTIFY_NOT_NULL(newMsg, NULL);
+    NS_VERIFY_NOT_NULL(newMsg, NULL);
 
     newMsg->addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(newMsg, NULL, OICFree(newMsg));
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newMsg, NULL, OICFree(newMsg));
     memcpy(newMsg->addr, msg->addr, sizeof(OCDevAddr));
 
     newMsg->messageId = msg->messageId;
index 4bd82e3..304ab33 100644 (file)
@@ -43,61 +43,61 @@ extern "C" {
 #define NS_DISCOVER_QUERY "/oic/res?rt=oic.r.notification"
 #define NS_DEVICE_ID_LENGTH 37
 
-#define NS_VERTIFY_NOT_NULL_V(obj) \
+#define NS_VERIFY_NOT_NULL_V(obj) \
     { \
         if ((obj) == NULL) \
         { \
-            NS_LOG_V(ERROR, "%s : obj is null", __func__); \
+            NS_LOG_V(ERROR, "%s : %s is null", __func__, #obj); \
             return; \
         } \
     }
 
-#define NS_VERTIFY_NOT_NULL(obj, retVal) \
+#define NS_VERIFY_NOT_NULL(obj, retVal) \
     { \
         if ((obj) == NULL) \
         { \
-            NS_LOG_V(ERROR, "%s : obj is null", __func__); \
+            NS_LOG_V(ERROR, "%s : %s is null", __func__, #obj); \
             return (retVal); \
         } \
     }
 
-#define NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(obj, retVal, func) \
+#define NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(obj, retVal, func) \
     { \
         if ((obj) == NULL) \
         { \
-            NS_LOG_V(ERROR, "%s : obj is null", __func__); \
+            NS_LOG_V(ERROR, "%s : %s is null", __func__, #obj); \
             NS_LOG(ERROR, "execute deletion"); \
             (func); \
             return (retVal); \
         } \
     }
 
-#define NS_VERTIFY_STACK_OK_V(obj) \
+#define NS_VERIFY_STACK_OK_V(obj) \
     { \
         OCStackResult _ret = (obj); \
         if ( _ret != OC_STACK_OK) \
         { \
-            NS_LOG_V(ERROR, "%s : obj is not OC_STACK_OK : %d", __func__, _ret); \
+            NS_LOG_V(ERROR, "%s : %s is not OC_STACK_OK : %d", __func__, #obj, _ret); \
             return; \
         } \
     }
 
-#define NS_VERTIFY_STACK_OK(obj, retVal) \
+#define NS_VERIFY_STACK_OK(obj, retVal) \
     { \
         OCStackResult _ret = (obj); \
         if ( _ret != OC_STACK_OK) \
         { \
-            NS_LOG_V(ERROR, "%s : obj is not OC_STACK_OK : %d", __func__, _ret); \
+            NS_LOG_V(ERROR, "%s : %s is not OC_STACK_OK : %d", __func__, #obj, _ret); \
             return (retVal); \
         } \
     }
 
-#define NS_VERTIFY_STACK_OK_WITH_POST_CLEANING(obj, retVal, func) \
+#define NS_VERIFY_STACK_OK_WITH_POST_CLEANING(obj, retVal, func) \
     { \
         OCStackResult _ret = (obj); \
         if ( _ret != OC_STACK_OK) \
         { \
-            NS_LOG_V(ERROR, "%s : obj is not OC_STACK_OK : %d", __func__, _ret); \
+            NS_LOG_V(ERROR, "%s : %s is not OC_STACK_OK : %d", __func__, #obj, _ret); \
             (func); \
             return (retVal); \
         } \
@@ -109,6 +109,7 @@ extern "C" {
         { \
             OICFree((obj)); \
             (obj) = NULL; \
+            NS_LOG_V(DEBUG, "%s : %s Removed", __func__, #obj); \
         } \
     }
 
@@ -137,7 +138,7 @@ typedef struct
 {
     // Mandatory
     uint64_t messageId;
-    char * providerId;
+    char providerId[37];
 
     //optional
     NSMessageType type;
@@ -156,18 +157,21 @@ bool NSIsStartedConsumer();
 void NSSetIsStartedConsumer(bool setValue);
 
 void NSSetDiscoverProviderCb(NSProviderDiscoveredCallback cb);
-void NSDiscoveredProvider(NSProvider * handle);
+void NSDiscoveredProvider(NSProvider * provider);
+
+void NSSetSubscriptionAcceptedCb(NSSubscriptionAcceptedCallback cb);
+void NSSubscriptionAccepted(NSProvider * provider);
 
-void NSSetMessagePostedCb(NSNotificationReceivedCallback  cb);
-void NSMessagePost(NSProvider * provider, NSMessage * obj);
+void NSSetMessagePostedCb(NSMessageReceivedCallback  cb);
+void NSMessagePost(NSMessage * obj);
 
-void NSSetNotificationSyncCb(NSSyncCallback cb);
-void NSNotificationSync(NSProvider * provider, NSSyncInfo * sync);
+void NSSetNotificationSyncCb(NSSyncInfoReceivedCallback cb);
+void NSNotificationSync(NSSyncInfo * sync);
 
 char ** NSGetConsumerId();
 void NSSetConsumerId(char * cId);
 
-char * NSGetQuery(const char * uri);
+char * NSMakeRequestUriWithConsumerId(const char * uri);
 
 NSTask * NSMakeTask(NSTaskType, void *);
 
index 6f0ad95..e275c91 100644 (file)
@@ -36,7 +36,7 @@ NSMessage_consumer * NSGetMessage(OCClientResponse * clientResponse);
 NSSyncInfo * NSGetSyncInfoc(OCClientResponse * clientResponse);
 
 OCRepPayload * NSGetofSyncInfoPayload(NSMessage_consumer * message, int type);
-OCStackResult NSSendSyncInfo(NSMessage_consumer * message, int type);
+OCStackResult NSSendSyncInfoUsingMessage(NSMessage_consumer * message, int type);
 
 // TODO it seem to not to be this file
 NSResult NSPushToCache(OCClientResponse * clientResponse, NSTaskType type);
@@ -44,30 +44,30 @@ NSResult NSPushToCache(OCClientResponse * clientResponse, NSTaskType type);
 NSResult NSConsumerSubscribeProvider(NSProvider * provider)
 {
     NSProvider_internal * provider_internal = (NSProvider_internal *) provider;
-    NS_VERTIFY_NOT_NULL(provider_internal, NS_ERROR);
+    NS_VERIFY_NOT_NULL(provider_internal, NS_ERROR);
 
     NS_LOG(DEBUG, "get subscribe message query");
-    char * query = NSGetQuery(provider_internal->messageUri);
-    NS_VERTIFY_NOT_NULL(query, NS_ERROR);
+    char * query = NSMakeRequestUriWithConsumerId(provider_internal->messageUri);
+    NS_VERIFY_NOT_NULL(query, NS_ERROR);
 
     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,
                           query, NULL, NSConsumerMessageListener, NULL);
-    NS_VERTIFY_STACK_OK(ret, NS_ERROR);
+    NS_VERIFY_STACK_OK(ret, NS_ERROR);
     NSOICFree(query);
 
     NS_LOG(DEBUG, "get subscribe sync query");
-    query = NSGetQuery(provider_internal->syncUri);
-    NS_VERTIFY_NOT_NULL(query, NS_ERROR);
+    query = NSMakeRequestUriWithConsumerId(provider_internal->syncUri);
+    NS_VERIFY_NOT_NULL(query, NS_ERROR);
 
     NS_LOG(DEBUG, "subscribe sync");
     NS_LOG_V(DEBUG, "subscribe query : %s", query);
     ret = NSInvokeRequest(&(provider_internal->syncHandle),
                           OC_REST_OBSERVE, provider_internal->addr,
                           query, NULL, NSConsumerSyncInfoListener, NULL);
-    NS_VERTIFY_STACK_OK(ret, NS_ERROR);
+    NS_VERIFY_STACK_OK(ret, NS_ERROR);
     NSOICFree(query);
 
     return NS_OK;
@@ -79,8 +79,8 @@ OCStackApplicationResult NSConsumerCheckPostResult(
     (void) ctx;
     (void) handle;
 
-    NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
-    NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 
     return OC_STACK_KEEP_TRANSACTION;
 }
@@ -96,18 +96,18 @@ OCStackApplicationResult NSConsumerSyncInfoListener(
     (void) ctx;
     (void) handle;
 
-    NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
-    NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 
     NS_LOG(DEBUG, "get NSSyncInfo");
     NSSyncInfo * newSync = NSGetSyncInfoc(clientResponse);
-    NS_VERTIFY_NOT_NULL(newSync, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(newSync, OC_STACK_KEEP_TRANSACTION);
 
     NSTaskType taskType = TASK_RECV_SYNCINFO;
 
     NS_LOG(DEBUG, "build NSTask");
     NSTask * task = NSMakeTask(taskType, (void *) newSync);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(task,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task,
                OC_STACK_KEEP_TRANSACTION, NSRemoveSyncInfoObj(newSync));
 
     NSConsumerPushEvent(task);
@@ -121,12 +121,12 @@ OCStackApplicationResult NSConsumerMessageListener(
     (void) ctx;
     (void) handle;
 
-    NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
-    NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 
     NS_LOG(DEBUG, "build NSMessage");
     NSMessage_consumer * newNoti = NSGetMessage(clientResponse);
-    NS_VERTIFY_NOT_NULL(newNoti, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(newNoti, OC_STACK_KEEP_TRANSACTION);
 
     NSTaskType type = TASK_CONSUMER_RECV_MESSAGE;
 
@@ -142,7 +142,7 @@ OCStackApplicationResult NSConsumerMessageListener(
 
     NS_LOG(DEBUG, "build NSTask");
     NSTask * task = NSMakeTask(type, (void *) newNoti);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveMessage(newNoti));
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveMessage(newNoti));
 
     NSConsumerPushEvent(task);
 
@@ -153,11 +153,11 @@ NSResult NSPushToCache(OCClientResponse * clientResponse, NSTaskType type)
 {
     NSMessage_consumer * cachedNoti = NSGetMessage(clientResponse);
     NS_LOG(DEBUG, "build NSMessage");
-    NS_VERTIFY_NOT_NULL(cachedNoti, NS_ERROR);
+    NS_VERIFY_NOT_NULL(cachedNoti, NS_ERROR);
 
     NS_LOG(DEBUG, "build NSTask");
     NSTask * task = NSMakeTask(type, (void *) cachedNoti);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveMessage(cachedNoti));
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveMessage(cachedNoti));
 
     NSConsumerPushEvent(task);
 
@@ -172,27 +172,27 @@ void NSGetMessagePostClean(char * pId, OCDevAddr * addr)
 
 NSMessage_consumer * NSGetMessage(OCClientResponse * clientResponse)
 {
-    NS_VERTIFY_NOT_NULL(clientResponse->payload, NULL);
+    NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
     OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
 
     NS_LOG(DEBUG, "get msg id");
     uint64_t id = NULL;
     bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t *)&id);
-    NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+    NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 
     NS_LOG(DEBUG, "get provider id");
     char * pId = NULL;
     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, &pId);
-    NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+    NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 
     NS_LOG(DEBUG, "get provider address");
     OCDevAddr * addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(addr, NULL, NSGetMessagePostClean(pId, addr));
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(addr, NULL, NSGetMessagePostClean(pId, addr));
     memcpy(addr, clientResponse->addr, sizeof(OCDevAddr));
 
     NS_LOG(DEBUG, "create NSMessage");
     NSMessage_consumer * retNoti = NSCreateMessage_internal(id, pId);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(retNoti, NULL, NSGetMessagePostClean(pId, addr));
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(retNoti, NULL, NSGetMessagePostClean(pId, addr));
     NSOICFree(pId);
 
     retNoti->addr = addr;
@@ -221,28 +221,28 @@ NSMessage_consumer * NSGetMessage(OCClientResponse * clientResponse)
 
 NSSyncInfo * NSGetSyncInfoc(OCClientResponse * clientResponse)
 {
-    NS_VERTIFY_NOT_NULL(clientResponse->payload, NULL);
+    NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
 
     OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
 
     NS_LOG(DEBUG, "get msg id");
     uint64_t id = NULL;
     bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t *)&id);
-    NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+    NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 
     NS_LOG(DEBUG, "get provider id");
     char * pId = NULL;
     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, &pId);
-    NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+    NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 
     NS_LOG(DEBUG, "get state");
     int64_t state = 0;
     getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_STATE, & state);
-    NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+    NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 
     NS_LOG(DEBUG, "create NSSyncInfo");
     NSSyncInfo * retSync = NSCreateSyncInfo_consumer(id, pId, (NSSyncType)state);
-    NS_VERTIFY_NOT_NULL(retSync, NULL);
+    NS_VERIFY_NOT_NULL(retSync, NULL);
 
     NS_LOG_V(DEBUG, "Sync ID : %ld", retSync->messageId);
     NS_LOG_V(DEBUG, "Sync State : %d", (int) retSync->state);
@@ -254,7 +254,7 @@ NSSyncInfo * NSGetSyncInfoc(OCClientResponse * clientResponse)
 NSMessage_consumer * NSCreateMessage_internal(uint64_t id, const char * providerId)
 {
     NSMessage_consumer * retNoti = (NSMessage_consumer *)OICMalloc(sizeof(NSMessage_consumer));
-    NS_VERTIFY_NOT_NULL(retNoti, NULL);
+    NS_VERIFY_NOT_NULL(retNoti, NULL);
 
     retNoti->messageId = id;
     OICStrcpy(retNoti->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
@@ -272,7 +272,7 @@ NSMessage_consumer * NSCreateMessage_internal(uint64_t id, const char * provider
 NSSyncInfo * NSCreateSyncInfo_consumer(uint64_t msgId, const char * providerId, NSSyncType state)
 {
     NSSyncInfo * retSync = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
-    NS_VERTIFY_NOT_NULL(retSync, NULL);
+    NS_VERIFY_NOT_NULL(retSync, NULL);
 
     retSync->messageId = msgId;
     retSync->state = state;
@@ -283,23 +283,20 @@ NSSyncInfo * NSCreateSyncInfo_consumer(uint64_t msgId, const char * providerId,
 
 void NSConsumerCommunicationTaskProcessing(NSTask * task)
 {
-    NS_VERTIFY_NOT_NULL_V(task);
+    NS_VERIFY_NOT_NULL_V(task);
 
     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
     if (task->taskType == TASK_CONSUMER_REQ_SUBSCRIBE)
     {
         NS_LOG(DEBUG, "Request Subscribe");
         NSResult ret = NSConsumerSubscribeProvider((NSProvider *)task->taskData);
-        NS_VERTIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
+        NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
     }
-    else if (task->taskType == TASK_SEND_READ || task->taskType == TASK_SEND_DISMISS)
+    else if (task->taskType == TASK_SEND_SYNCINFO)
     {
-        NSMessage_consumer * message = (NSMessage_consumer *) task->taskData;
-        NS_VERTIFY_NOT_NULL_V(message);
-
-        OCStackResult ret = NSSendSyncInfo(message, (task->taskType == TASK_SEND_READ) ? 0 : 1);
-        NS_VERTIFY_STACK_OK_V(ret);
-
+        // TODO find target OCDevAddr using provider Id.
+        //OCStackResult ret = NSSendSyncInfo((NSSyncInfo *)task->taskData, );
+        //NS_VERTIFY_STACK_OK_V(ret);
     }
     else if (task->taskType == TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL)
     {
@@ -314,23 +311,15 @@ void NSConsumerCommunicationTaskProcessing(NSTask * task)
     }
 }
 
-OCRepPayload * NSGetofSyncInfoPayload(NSMessage_consumer * message, int type)
+OCStackResult NSSendSyncInfo(NSSyncInfo * syncInfo, OCDevAddr * addr)
 {
     OCRepPayload * payload = OCRepPayloadCreate();
-    NS_VERTIFY_NOT_NULL(payload, NULL);
-
-    OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t)message->messageId);
-    OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_STATE, type);
+    NS_VERIFY_NOT_NULL(payload, OC_STACK_ERROR);
 
-    return payload;
-}
-
-OCStackResult NSSendSyncInfo(NSMessage_consumer * message, int type)
-{
-    OCRepPayload * payload = NSGetofSyncInfoPayload(message, type);
-    NS_VERTIFY_NOT_NULL(payload, OC_STACK_ERROR);
+    OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t)syncInfo->messageId);
+    OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_STATE, syncInfo->state);
 
-    return NSInvokeRequest(NULL, OC_REST_POST, message->addr,
+    return NSInvokeRequest(NULL, OC_REST_POST, addr,
                            NS_SYNC_URI, (OCPayload*)payload,
                            NSConsumerCheckPostResult, NULL);
 }
index 549c76e..b4f8f6f 100644 (file)
@@ -40,8 +40,8 @@ OCStackApplicationResult NSConsumerPresenceListener(
     (void) ctx;
     (void) handle;
 
-    NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
-    NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 
     NS_LOG_V(DEBUG, "Presence income : %s:%d",
             clientResponse->devAddr.addr, clientResponse->devAddr.port);
@@ -80,9 +80,9 @@ OCStackApplicationResult NSProviderDiscoverListener(
     (void) ctx;
     (void) handle;
 
-    NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
-    NS_VERTIFY_NOT_NULL(clientResponse->payload, OC_STACK_KEEP_TRANSACTION);
-    NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(clientResponse->payload, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 
     NS_LOG_V(DEBUG, "Discover income : %s:%d",
             clientResponse->devAddr.addr, clientResponse->devAddr.port);
@@ -128,8 +128,8 @@ OCStackApplicationResult NSIntrospectProvider(
     (void) ctx;
     (void) handle;
 
-    NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
-    NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 
     NS_LOG_V(DEBUG, "GET response income : %s:%d",
             clientResponse->devAddr.addr, clientResponse->devAddr.port);
@@ -146,11 +146,11 @@ OCStackApplicationResult NSIntrospectProvider(
     }
 
     NSProvider_internal * newProvider = NSGetProvider(clientResponse);
-    NS_VERTIFY_NOT_NULL(newProvider, OC_STACK_KEEP_TRANSACTION);
+    NS_VERIFY_NOT_NULL(newProvider, OC_STACK_KEEP_TRANSACTION);
 
     NS_LOG(DEBUG, "build NSTask");
     NSTask * task = NSMakeTask(TASK_CONSUMER_PROVIDER_DISCOVERED, (void *) newProvider);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProviderObj(newProvider));
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProviderObj(newProvider));
 
     NSConsumerPushEvent(task);
 
@@ -168,7 +168,7 @@ void NSGetProviderPostClean(char * pId, char * mUri, char * sUri, OCDevAddr * ad
 NSProvider_internal * NSGetProvider(OCClientResponse * clientResponse)
 {
     NS_LOG(DEBUG, "create NSProvider");
-    NS_VERTIFY_NOT_NULL(clientResponse->payload, NULL);
+    NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
 
     OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
     while (payload)
@@ -187,31 +187,31 @@ NSProvider_internal * NSGetProvider(OCClientResponse * clientResponse)
 
     NS_LOG(DEBUG, "get information of accepter");
     bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_POLICY, & accepter);
-    NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+    NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 
     NS_LOG(DEBUG, "get provider ID");
     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, & providerId);
-    NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+    NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 
     NS_LOG(DEBUG, "get message URI");
     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_MESSAGE, & messageUri);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
             NSGetProviderPostClean(providerId, messageUri, syncUri, addr));
 
     NS_LOG(DEBUG, "get sync URI");
     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_SYNC, & syncUri);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
             NSGetProviderPostClean(providerId, messageUri, syncUri, addr));
 
     NS_LOG(DEBUG, "get provider address");
     addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(addr, NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(addr, NULL,
            NSGetProviderPostClean(providerId, messageUri, syncUri, addr));
     memcpy(addr, clientResponse->addr, sizeof(OCDevAddr));
 
     NSProvider_internal * newProvider
         = (NSProvider_internal *)OICMalloc(sizeof(NSProvider_internal));
-    NS_VERTIFY_NOT_NULL(newProvider, NULL);
+    NS_VERIFY_NOT_NULL(newProvider, NULL);
 
     OICStrcpy(newProvider->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
     NSOICFree(providerId);
@@ -227,7 +227,7 @@ NSProvider_internal * NSGetProvider(OCClientResponse * clientResponse)
 
 void NSConsumerDiscoveryTaskProcessing(NSTask * task)
 {
-    NS_VERTIFY_NOT_NULL_V(task);
+    NS_VERIFY_NOT_NULL_V(task);
 
     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
     if (task->taskType == TASK_EVENT_CONNECTED || task->taskType == TASK_CONSUMER_REQ_DISCOVER)
index 51ca8ce..e246eb5 100644 (file)
 #include "NSConstants.h"
 #include "NSConsumerQueueScheduler.h"
 #include "oic_malloc.h"
+#include "oic_string.h"
 
 // Public APIs
-NSResult NSStartConsumer(
-        NSProviderDiscoveredCallback discoverCb,
-        NSNotificationReceivedCallback  postCb,
-        NSSyncCallback syncCb)
+NSResult NSStartConsumer(NSConsumerConfig config)
 {
     bool isStartedConsumer = NSIsStartedConsumer();
-    NS_VERTIFY_NOT_NULL(isStartedConsumer == false ? (void *) 1 : NULL, NS_OK);
+    NS_VERIFY_NOT_NULL(isStartedConsumer == false ? (void *) 1 : NULL, NS_OK);
 
-    NS_VERTIFY_NOT_NULL(discoverCb, NS_ERROR);
-    NS_VERTIFY_NOT_NULL(postCb, NS_ERROR);
-    NS_VERTIFY_NOT_NULL(syncCb, NS_ERROR);
+    NS_VERIFY_NOT_NULL(config.discoverCb, NS_ERROR);
+    NS_VERIFY_NOT_NULL(config.messageCb, NS_ERROR);
+    NS_VERIFY_NOT_NULL(config.syncInfoCb, NS_ERROR);
+    NS_VERIFY_NOT_NULL(config.acceptedCb, NS_ERROR);
 
-    NSSetDiscoverProviderCb(discoverCb);
-    NSSetMessagePostedCb(postCb);
-    NSSetNotificationSyncCb(syncCb);
+    NSSetDiscoverProviderCb(config.discoverCb);
+    NSSetMessagePostedCb(config.messageCb);
+    NSSetNotificationSyncCb(config.syncInfoCb);
+    NSSetSubscriptionAcceptedCb(config.acceptedCb);
     NSSetIsStartedConsumer(true);
 
     NSResult ret = NSConsumerMessageHandlerInit();
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
             NS_ERROR, NSStopConsumer());
 
     return NS_OK;
@@ -59,6 +59,7 @@ NSResult NSStopConsumer()
     NSSetDiscoverProviderCb(NULL);
     NSSetMessagePostedCb(NULL);
     NSSetNotificationSyncCb(NULL);
+    NSSetSubscriptionAcceptedCb(NULL);
     NSSetIsStartedConsumer(false);
 
     NSConsumerMessageHandlerExit();
@@ -69,7 +70,7 @@ NSResult NSStopConsumer()
 NSResult NSSubscribe(NSProvider * provider)
 {
     NSTask * subscribeTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) provider);
-    NS_VERTIFY_NOT_NULL(subscribeTask, NS_ERROR);
+    NS_VERIFY_NOT_NULL(subscribeTask, NS_ERROR);
 
     return NSConsumerPushEvent(subscribeTask);
 }
@@ -77,38 +78,37 @@ NSResult NSSubscribe(NSProvider * provider)
 NSResult NSUnsubscribe(NSProvider * provider)
 {
     NSTask * unsubscribeTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, (void *) provider);
-    NS_VERTIFY_NOT_NULL(unsubscribeTask, NS_ERROR);
+    NS_VERIFY_NOT_NULL(unsubscribeTask, NS_ERROR);
 
     return NSConsumerPushEvent(unsubscribeTask);
 }
 
-NSResult NSRescanProvider()
+NSResult NSConsumerSendSyncInfo(const char * providerId, uint64_t messageId, NSSyncType type)
 {
-    NSTask * discoverTask = NSMakeTask(TASK_CONSUMER_REQ_DISCOVER, NULL);
-    NS_VERTIFY_NOT_NULL(discoverTask, NS_ERROR);
+    NSSyncInfo * syncInfo = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
+    NS_VERIFY_NOT_NULL(syncInfo, NS_ERROR);
 
-    return NSConsumerPushEvent(discoverTask);
-}
+    OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
+    syncInfo->messageId = messageId;
+    syncInfo->state = type;
 
-NSResult NSConsumerReadCheck(NSMessage * obj)
-{
-    NSTask * readTask = NSMakeTask(TASK_SEND_READ, (void *) obj);
-    NS_VERTIFY_NOT_NULL(readTask, NS_ERROR);
+    NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(syncTask, NS_ERROR, NSOICFree(syncInfo));
 
-    return NSConsumerPushEvent(readTask);
+    return NSConsumerPushEvent(syncTask);
 }
 
-NSResult NSConsumerDismissCheck(NSMessage * obj)
+NSResult NSRescanProvider()
 {
-    NSTask * dismissTask = NSMakeTask(TASK_SEND_DISMISS, (void *) obj);
-    NS_VERTIFY_NOT_NULL(dismissTask, NS_ERROR);
+    NSTask * discoverTask = NSMakeTask(TASK_CONSUMER_REQ_DISCOVER, NULL);
+    NS_VERIFY_NOT_NULL(discoverTask, NS_ERROR);
 
-    return NSConsumerPushEvent(dismissTask);
+    return NSConsumerPushEvent(discoverTask);
 }
 
-NSResult NSDropNSObject(NSMessage * obj)
+NSResult NSDropNSMessage(NSMessage * obj)
 {
-    NS_VERTIFY_NOT_NULL(obj, NS_ERROR);
+    NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 
     obj->messageId = 0;
     NSOICFree(obj->title);
index 4dd03f4..39bc933 100644 (file)
@@ -24,6 +24,7 @@
 #include "NSStructs.h"
 
 #include "oic_malloc.h"
+#include "oic_string.h"
 
 NSCacheList ** NSGetCacheList()
 {
@@ -48,19 +49,19 @@ void NSDestroyCacheList()
 NSResult NSCacheUpdate(NSCacheList * cache, NSTask * task, NSConsumerMessageTypes type)
 {
     NSMessage_consumer * noti = (NSMessage_consumer *) task->taskData;
-    NS_VERTIFY_NOT_NULL(noti, NS_ERROR);
+    NS_VERIFY_NOT_NULL(noti, NS_ERROR);
 
     noti->type = type;
 
     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
-    NS_VERTIFY_NOT_NULL(obj, NS_ERROR);
+    NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 
     obj->data = (NSCacheData *) noti;
     obj->next = NULL;
 
     NS_LOG(DEBUG, "try to write to storage");
     NSResult ret = NSStorageWrite(cache, obj);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
             NS_ERROR, NSRemoveMessage(noti));
 
     NSRemoveMessage(noti);
@@ -71,7 +72,7 @@ NSResult NSCacheUpdate(NSCacheList * cache, NSTask * task, NSConsumerMessageType
 
 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
 {
-    // TODO need to check for discovered provider is new.
+    // TODO need to check for discovered provider is new and store provider.
 
     if (provider->accessPolicy == NS_ACCESS_DENY)
     {
@@ -82,7 +83,7 @@ void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
     {
         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
         NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) provider);
-        NS_VERTIFY_NOT_NULL_V(task);
+        NS_VERIFY_NOT_NULL_V(task);
 
         NSConsumerPushEvent(task);
     }
@@ -90,40 +91,51 @@ void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
 
 void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage_consumer * msg)
 {
-    // TODO need to check for provider is new and callback to upper apis.
-    (void) msg;
+    NS_VERIFY_NOT_NULL_V(msg);
+
+    // TODO change to find provider using pId.
+    NSProvider * provider = NULL;
+    {
+        provider = (NSProvider *)OICMalloc(sizeof(NSProvider));
+        NS_VERIFY_NOT_NULL_V(provider);
+        OICStrcpy(provider->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, msg->providerId);
+    }
+
+    NSSubscriptionAccepted(provider);
 }
 
 void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
 {
-    NSMessagePost(NULL, (NSMessage *) msg);
-
+    NS_VERIFY_NOT_NULL_V(msg);
+    // TODO store message to cache
 //    NSResult ret = NSCacheUpdate(cache, task, Notification);
 //    NS_VERTIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
+
+    NSMessagePost((NSMessage *) msg);
 }
 
 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
 {
-    NS_VERTIFY_NOT_NULL_V(sync);
+    NS_VERIFY_NOT_NULL_V(sync);
 
     // TODO need to check for provider is available.
-    NSNotificationSync(NULL, sync);
-
     // TODO need to update msg list.
 //        NSResult ret = NSPushToCache(clientResponse, taskType);
 //        NS_VERTIFY_NOT_NULL(ret == NS_OK ? (void *)1 : NULL, OC_STACK_KEEP_TRANSACTION);
+
+    NSNotificationSync(sync);
 }
 
 void NSConsumerInternalTaskProcessing(NSTask * task)
 {
-    NS_VERTIFY_NOT_NULL_V(task);
+    NS_VERIFY_NOT_NULL_V(task);
 
     NSCacheList * cache = *(NSGetCacheList());
     if (!cache)
     {
         NS_LOG(DEBUG, "Cache Init");
         cache = NSStorageCreate();
-        NS_VERTIFY_NOT_NULL_V(cache);
+        NS_VERIFY_NOT_NULL_V(cache);
 
         cache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
         NSSetCacheList(cache);
@@ -163,7 +175,7 @@ void NSConsumerInternalTaskProcessing(NSTask * task)
             NS_LOG(DEBUG, "Receive Read Notification");
 
             ret = NSCacheUpdate(cache, task, Read);
-            NS_VERTIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
+            NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
             break;
         }
         case TASK_RECV_DISMISS:
@@ -171,7 +183,7 @@ void NSConsumerInternalTaskProcessing(NSTask * task)
             NS_LOG(DEBUG, "Receive Dismiss Notification");
 
             ret = NSCacheUpdate(cache, task, Dismiss);
-            NS_VERTIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
+            NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
             break;
         }
         default :
index 1dd6764..ca78381 100644 (file)
@@ -56,12 +56,12 @@ NSResult NSConsumerListenerInit()
     NS_LOG(DEBUG, "Request to subscribe presence");
     OCStackResult stackResult = NSInvokeRequest(getPresenceHandle(), OC_REST_PRESENCE, NULL,
                         NS_PRESENCE_SUBSCRIBE_QUERY, NULL, NSConsumerPresenceListener, NULL);
-    NS_VERTIFY_STACK_OK(stackResult, NS_ERROR);
+    NS_VERIFY_STACK_OK(stackResult, NS_ERROR);
 
     NS_LOG(DEBUG, "Request to discover provider");
     stackResult = NSInvokeRequest(NULL, OC_REST_DISCOVER, NULL,
                       NS_DISCOVER_QUERY, NULL, NSProviderDiscoverListener, NULL);
-    NS_VERTIFY_STACK_OK(stackResult, NS_ERROR);
+    NS_VERIFY_STACK_OK(stackResult, NS_ERROR);
 
     return NS_OK;
 }
@@ -87,7 +87,7 @@ void NSConnectionStateListener(CATransportAdapter_t adapter,
         NS_LOG(DEBUG, "try to discover notification provider.");
 
         NSTask * task = NSMakeTask(TASK_EVENT_CONNECTED, NULL);
-        NS_VERTIFY_NOT_NULL_V(task);
+        NS_VERIFY_NOT_NULL_V(task);
 
         NSConsumerPushEvent(task);
     }
@@ -105,7 +105,7 @@ void NSAdapterStateListener(CATransportAdapter_t adapter, bool enabled)
         NS_LOG(DEBUG, "try to discover notification provider.");
 
         NSTask * task = NSMakeTask(TASK_EVENT_CONNECTED, NULL);
-        NS_VERTIFY_NOT_NULL_V(task);
+        NS_VERIFY_NOT_NULL_V(task);
 
         NSConsumerPushEvent(task);
     }
index d31d996..ae6cd2e 100644 (file)
@@ -27,7 +27,7 @@
 NSConsumerQueue * NSCreateQueue()
 {
     NSConsumerQueue * newQueue = (NSConsumerQueue *)OICMalloc(sizeof(NSConsumerQueue));
-    NS_VERTIFY_NOT_NULL(newQueue, NULL);
+    NS_VERIFY_NOT_NULL(newQueue, NULL);
 
     newQueue->size = 0;
     newQueue->head = NULL;
@@ -51,8 +51,8 @@ void NSDestroyQueue(NSConsumerQueue * queue)
 
 bool NSPushQueue(NSConsumerQueue * queue, NSConsumerQueueObject * object)
 {
-    NS_VERTIFY_NOT_NULL(queue, false);
-    NS_VERTIFY_NOT_NULL(object, false);
+    NS_VERIFY_NOT_NULL(queue, false);
+    NS_VERIFY_NOT_NULL(object, false);
 
     if (!(queue->head))
     {
@@ -73,8 +73,8 @@ NSConsumerQueueObject * NSPopQueue(NSConsumerQueue * queue)
 {
     NSConsumerQueueObject * retObject = NULL;
 
-    NS_VERTIFY_NOT_NULL(queue, NULL);
-    NS_VERTIFY_NOT_NULL(queue->head, NULL);
+    NS_VERIFY_NOT_NULL(queue, NULL);
+    NS_VERIFY_NOT_NULL(queue->head, NULL);
 
     if (queue->size <= 0)
     {
index 9af64e1..5d7d0c0 100644 (file)
@@ -82,20 +82,20 @@ NSResult NSConsumerMessageHandlerInit()
 
     NS_LOG(DEBUG, "listener init");
     NSResult ret = NSConsumerListenerInit();
-    NS_VERTIFY_NOT_NULL(ret == NS_OK ? (void *) 1 : NULL, NS_ERROR);
+    NS_VERIFY_NOT_NULL(ret == NS_OK ? (void *) 1 : NULL, NS_ERROR);
 
     NS_LOG(DEBUG, "system init");
     ret = NSConsumerSystemInit();
-    NS_VERTIFY_NOT_NULL(ret == NS_OK ? (void *) 1 : NULL, NS_ERROR);
+    NS_VERIFY_NOT_NULL(ret == NS_OK ? (void *) 1 : NULL, NS_ERROR);
 
     NS_LOG(DEBUG, "queue thread init");
     handle = NSThreadInit(NSConsumerMsgHandleThreadFunc, NULL);
-    NS_VERTIFY_NOT_NULL(handle, NS_ERROR);
+    NS_VERIFY_NOT_NULL(handle, NS_ERROR);
     NSSetMsgHandleThreadHandle(handle);
 
     NS_LOG(DEBUG, "create queue");
     queue = NSCreateQueue();
-    NS_VERTIFY_NOT_NULL(queue, NS_ERROR);
+    NS_VERIFY_NOT_NULL(queue, NS_ERROR);
     NSSetMsgHandleQueue(queue);
 
     return NS_OK;
@@ -104,7 +104,7 @@ NSResult NSConsumerMessageHandlerInit()
 NSResult NSConsumerPushEvent(NSTask * task)
 {
     NSConsumerThread * thread = NSThreadInit(NSConsumerMsgPushThreadFunc, (void *) task);
-    NS_VERTIFY_NOT_NULL(thread, NS_ERROR);
+    NS_VERIFY_NOT_NULL(thread, NS_ERROR);
 
     return NS_OK;
 }
@@ -124,7 +124,7 @@ void * NSConsumerMsgHandleThreadFunc(void * threadHandle)
 
     NS_LOG(DEBUG, "create thread for consumer message handle");
     NSConsumerThread * queueHandleThread = (NSConsumerThread *) threadHandle;
-    NS_VERTIFY_NOT_NULL(queueHandleThread, NULL);
+    NS_VERIFY_NOT_NULL(queueHandleThread, NULL);
 
     while (true)
     {
@@ -169,11 +169,11 @@ void * NSConsumerMsgPushThreadFunc(void * data)
 
     NS_LOG(DEBUG, "get queueThread handle");
     NSConsumerThread * msgHandleThread = *(NSGetMsgHandleThreadHandle());
-    NS_VERTIFY_NOT_NULL(msgHandleThread, NULL);
+    NS_VERIFY_NOT_NULL(msgHandleThread, NULL);
 
     NS_LOG(DEBUG, "create queue object");
     obj = (NSConsumerQueueObject *)OICMalloc(sizeof(NSConsumerQueueObject));
-    NS_VERTIFY_NOT_NULL(obj, NULL);
+    NS_VERIFY_NOT_NULL(obj, NULL);
 
     obj->data = data;
     obj->next = NULL;
@@ -209,6 +209,7 @@ void NSConsumerTaskProcessing(NSTask * task)
     }
     case TASK_CONSUMER_REQ_SUBSCRIBE:
     case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
+    case TASK_SEND_SYNCINFO:
     case TASK_SEND_READ:
     case TASK_SEND_DISMISS:
     {
index a30fa64..063b032 100644 (file)
@@ -32,23 +32,23 @@ void NSDestroyThreadHandle(NSConsumerThread *);
 
 NSConsumerThread * NSThreadInit(NSThreadFunc func, void * data)
 {
-    NS_VERTIFY_NOT_NULL(func, NULL);
+    NS_VERIFY_NOT_NULL(func, NULL);
 
     pthread_mutex_init(&g_create_mutex, NULL);
 
     NSConsumerThread * handle = (NSConsumerThread *)OICMalloc(sizeof(NSConsumerThread));
-    NS_VERTIFY_NOT_NULL(handle, NULL);
+    NS_VERIFY_NOT_NULL(handle, NULL);
 
     memset(handle, 0, sizeof(NSConsumerThread));
 
     pthread_mutexattr_init(&(handle->mutex_attr));
 
     int pthreadResult = pthread_mutexattr_settype(&(handle->mutex_attr), PTHREAD_MUTEX_RECURSIVE);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(pthreadResult == 0 ? (void *)1 : NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(pthreadResult == 0 ? (void *)1 : NULL,
             NULL, NSDestroyThreadHandle(handle));
 
     pthreadResult = pthread_mutex_init(&(handle->mutex), &(handle->mutex_attr));
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(pthreadResult == 0 ? (void *)1 : NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(pthreadResult == 0 ? (void *)1 : NULL,
             NULL, NSDestroyThreadHandle(handle));
 
     pthread_mutex_lock(&g_create_mutex);
@@ -57,7 +57,7 @@ NSConsumerThread * NSThreadInit(NSThreadFunc func, void * data)
 
     pthreadResult = pthread_create(&(handle->thread_id), NULL, func,
                            (data == NULL) ? (void *) handle : (void *)data);
-    NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(pthreadResult == 0 ? (void *)1 : NULL,
+    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(pthreadResult == 0 ? (void *)1 : NULL,
             NULL, NSDestroyThreadHandle(handle));
 
     pthread_mutex_unlock(&g_create_mutex);