service/notification/src/consumer/NSConsumerInterface.c

   1 //******************************************************************
   2 //
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "NSConsumerInterface.h"
  22
  23 #include <stdlib.h>
  24 #include <stdbool.h>
  25
  26 #include "NSCommon.h"
  27 #include "NSConsumerCommon.h"
  28 #include "NSConstants.h"
  29 #include "NSConsumerScheduler.h"
  30 #include "oic_malloc.h"
  31 #include "oic_string.h"
  32
  33 // Public APIs
  34 NSResult NSStartConsumer(NSConsumerConfig config)
  35 {
  36     bool isStartedConsumer = NSIsStartedConsumer();
  37     NS_VERIFY_NOT_NULL(isStartedConsumer == false ? (void *) 1 : NULL, NS_OK);
  38
  39     NS_VERIFY_NOT_NULL(config.messageCb, NS_ERROR);
  40     NS_VERIFY_NOT_NULL(config.syncInfoCb, NS_ERROR);
  41     NS_VERIFY_NOT_NULL(config.changedCb, NS_ERROR);
  42
  43     NSSetMessagePostedCb(config.messageCb);
  44     NSSetNotificationSyncCb(config.syncInfoCb);
  45     NSSetProviderChangedCb(config.changedCb);
  46     NSSetIsStartedConsumer(true);
  47
  48     NSResult ret = NSConsumerMessageHandlerInit();
  49     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
  50             NS_ERROR, NSStopConsumer());
  51
  52     return NS_OK;
  53 }
  54
  55 NSResult NSStopConsumer()
  56 {
  57     bool isStartedConsumer = NSIsStartedConsumer();
  58     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
  59
  60     NSSetMessagePostedCb(NULL);
  61     NSSetNotificationSyncCb(NULL);
  62     NSSetProviderChangedCb(NULL);
  63     NSSetIsStartedConsumer(false);
  64
  65     NSConsumerMessageHandlerExit();
  66
  67     return NS_OK;
  68 }
  69
  70 NSResult NSConsumerEnableRemoteService(const char *serverAddress)
  71 {
  72     NS_VERIFY_NOT_NULL(serverAddress, NS_ERROR);
  73     bool isStartedConsumer = NSIsStartedConsumer();
  74     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
  75
  76     char * queryAddr = NULL;
  77     if (strstr(serverAddress, "coap+tcp://"))
  78     {
  79         queryAddr = OICStrdup(serverAddress+11);
  80     }
  81     else if (strstr(serverAddress, "coap://"))
  82     {
  83         queryAddr = OICStrdup(serverAddress+7);
  84     }
  85     else
  86     {
  87         queryAddr = OICStrdup(serverAddress);
  88     }
  89     NS_VERIFY_NOT_NULL(queryAddr, NS_ERROR);
  90
  91     NSTask * discoverTask = NSMakeTask(TASK_CONSUMER_REQ_DISCOVER, (void *)queryAddr);
  92     NS_VERIFY_NOT_NULL(discoverTask, NS_ERROR);
  93
  94     return NSConsumerPushEvent(discoverTask);
  95 }
  96
  97 NSResult NSSubscribe(const char * providerId)
  98 {
  99     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 100     bool isStartedConsumer = NSIsStartedConsumer();
 101     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 102
 103     NSProvider_internal * provInternal = NSConsumerFindNSProvider(providerId);
 104     NS_VERIFY_NOT_NULL(provInternal, NS_ERROR);
 105
 106     NSProvider * prov = (NSProvider *)NSCopyProvider(provInternal);
 107     NSRemoveProvider_internal(provInternal);
 108     NS_VERIFY_NOT_NULL(prov, NS_ERROR);
 109
 110     NSTask * subscribeTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) prov);
 111     NS_VERIFY_NOT_NULL(subscribeTask, NS_ERROR);
 112
 113     return NSConsumerPushEvent(subscribeTask);
 114 }
 115
 116 NSResult NSUnsubscribe(const char * providerId)
 117 {
 118     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 119     bool isStartedConsumer = NSIsStartedConsumer();
 120     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 121
 122     NSProvider_internal * provInternal = NSConsumerFindNSProvider(providerId);
 123     NS_VERIFY_NOT_NULL(provInternal, NS_ERROR);
 124
 125     NSProvider * prov = (NSProvider *)NSCopyProvider((NSProvider_internal *) provInternal);
 126     NSRemoveProvider_internal(provInternal);
 127     NS_VERIFY_NOT_NULL(prov, NS_ERROR);
 128
 129     NSTask * unsubscribeTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, (void *) prov);
 130     NS_VERIFY_NOT_NULL(unsubscribeTask, NS_ERROR);
 131
 132     return NSConsumerPushEvent(unsubscribeTask);
 133 }
 134
 135 NSResult NSConsumerSendSyncInfo(const char * providerId, uint64_t messageId, NSSyncType type)
 136 {
 137     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 138     bool isStartedConsumer = NSIsStartedConsumer();
 139     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 140
 141     NSSyncInfo * syncInfo = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
 142     NS_VERIFY_NOT_NULL(syncInfo, NS_ERROR);
 143
 144     OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
 145     syncInfo->messageId = messageId;
 146     syncInfo->state = type;
 147
 148     NSTask * syncTask = NSMakeTask(TASK_MAKE_SYNCINFO, (void *) syncInfo);
 149     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(syncTask, NS_ERROR, NSOICFree(syncInfo));
 150
 151     return NSConsumerPushEvent(syncTask);
 152 }
 153
 154 NSResult NSRescanProvider()
 155 {
 156     bool isStartedConsumer = NSIsStartedConsumer();
 157     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 158
 159     NSTask * discoverTask = NSMakeTask(TASK_CONSUMER_REQ_DISCOVER, NULL);
 160     NS_VERIFY_NOT_NULL(discoverTask, NS_ERROR);
 161
 162     return NSConsumerPushEvent(discoverTask);
 163 }
 164
 165 NSProvider * NSConsumerGetProvider(const char * providerId)
 166 {
 167     NS_VERIFY_NOT_NULL(providerId, NULL);
 168     bool isStartedConsumer = NSIsStartedConsumer();
 169     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NULL);
 170
 171     NS_VERIFY_NOT_NULL(providerId, NULL);
 172
 173     NSProvider_internal * prov = NSConsumerFindNSProvider(providerId);
 174     NS_VERIFY_NOT_NULL(prov, NULL);
 175
 176     NSProvider * retProv = NSCopyProvider(prov);
 177     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(retProv, NULL, NSRemoveProvider_internal(prov));
 178     NSRemoveProvider_internal(prov);
 179
 180     return retProv;
 181 }
 182
 183 NSTopicLL * NSConsumerGetTopicList(const char * providerId)
 184 {
 185     NS_VERIFY_NOT_NULL(providerId, NULL);
 186     bool isStartedConsumer = NSIsStartedConsumer();
 187     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NULL);
 188
 189     NS_LOG_V(DEBUG, "NSProvider ID: %s", providerId);
 190     NSProvider_internal * prov_internal = NSConsumerFindNSProvider(providerId);
 191     NS_VERIFY_NOT_NULL(prov_internal, NULL);
 192
 193     NSTopicLL * retTopics = prov_internal->topicLL;
 194     prov_internal->topicLL = NULL;
 195     NSRemoveProvider_internal(prov_internal);
 196
 197     return retTopics;
 198 }
 199
 200 NSResult NSConsumerUpdateTopicList(const char * providerId, NSTopicLL * topics)
 201 {
 202     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 203     NS_VERIFY_NOT_NULL(topics, NS_ERROR);
 204     bool isStartedConsumer = NSIsStartedConsumer();
 205     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 206
 207     NSProvider_internal * prov_internal = NSConsumerFindNSProvider(providerId);
 208     NS_VERIFY_NOT_NULL(prov_internal, NS_ERROR);
 209     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(prov_internal->topicLL, NS_ERROR,
 210                          NSRemoveProvider_internal(prov_internal));
 211
 212     NSSelector selector = prov_internal->accessPolicy;
 213     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(
 214             selector == NS_SELECTION_CONSUMER ? (void *) 1 : NULL, NS_ERROR,
 215             NSRemoveProvider_internal(prov_internal));
 216
 217     NSRemoveTopicLL(prov_internal->topicLL);
 218     prov_internal->topicLL = NSCopyTopicLL(topics);
 219
 220     NSTask * topicTask = NSMakeTask(TASK_CONSUMER_SELECT_TOPIC_LIST, (void *) prov_internal);
 221     NS_VERIFY_NOT_NULL(topicTask, NS_ERROR);
 222
 223     return NSConsumerPushEvent(topicTask);
 224 }