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 "NSUtil.h"
  31 #include "oic_malloc.h"
  32 #include "oic_string.h"
  33
  34 // Public APIs
  35 NSResult NSStartConsumer(NSConsumerConfig config)
  36 {
  37     bool isStartedConsumer = NSIsStartedConsumer();
  38     NS_VERIFY_NOT_NULL(isStartedConsumer == false ? (void *) 1 : NULL, NS_OK);
  39
  40     NS_VERIFY_NOT_NULL(config.messageCb, NS_ERROR);
  41     NS_VERIFY_NOT_NULL(config.syncInfoCb, NS_ERROR);
  42     NS_VERIFY_NOT_NULL(config.changedCb, NS_ERROR);
  43
  44     NSSetMessagePostedCb(config.messageCb);
  45     NSSetNotificationSyncCb(config.syncInfoCb);
  46     NSSetProviderChangedCb(config.changedCb);
  47     NSSetIsStartedConsumer(true);
  48
  49     NSResult ret = NSConsumerMessageHandlerInit();
  50     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
  51             NS_ERROR, NSStopConsumer());
  52
  53     return NS_OK;
  54 }
  55
  56 NSResult NSStopConsumer()
  57 {
  58     bool isStartedConsumer = NSIsStartedConsumer();
  59     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
  60
  61     NSSetMessagePostedCb(NULL);
  62     NSSetNotificationSyncCb(NULL);
  63     NSSetProviderChangedCb(NULL);
  64     NSSetIsStartedConsumer(false);
  65
  66     NSConsumerMessageHandlerExit();
  67
  68     return NS_OK;
  69 }
  70
  71 #ifdef WITH_MQ
  72 NSResult NSConsumerSubscribeMQService(const char * serverAddress, const char * topicName)
  73 {
  74     NS_VERIFY_NOT_NULL(serverAddress, NS_ERROR);
  75     NS_VERIFY_NOT_NULL(topicName, NS_ERROR);
  76     bool isStartedConsumer = NSIsStartedConsumer();
  77     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
  78
  79     char * queryAddr = NSGetQueryAddress(serverAddress);
  80     NS_VERIFY_NOT_NULL(queryAddr, NS_ERROR);
  81
  82     NSMQTopicAddress * topicAddr = (NSMQTopicAddress *)OICMalloc(sizeof(NSMQTopicAddress));
  83     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(queryAddr, NS_ERROR, NSOICFree(queryAddr));
  84
  85     topicAddr->serverAddr = queryAddr;
  86     topicAddr->topicName = OICStrdup(topicName);
  87
  88     NSTask * subMQTask = NSMakeTask(TASK_MQ_REQ_SUBSCRIBE, (void *)topicAddr);
  89     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(subMQTask, NS_ERROR,
  90                   {
  91                       NSOICFree(topicAddr->serverAddr);
  92                       NSOICFree(topicAddr->topicName)
  93                       NSOICFree(topicAddr);
  94                   });
  95
  96     return NSConsumerPushEvent(subMQTask);
  97 }
  98 #endif
  99
 100 NSResult NSConsumerEnableRemoteService(const char * serverAddress)
 101 {
 102     NS_VERIFY_NOT_NULL(serverAddress, NS_ERROR);
 103     bool isStartedConsumer = NSIsStartedConsumer();
 104     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 105
 106     char * queryAddr = OICStrdup(serverAddress);
 107     NS_VERIFY_NOT_NULL(queryAddr, NS_ERROR);
 108
 109     NSTask * discoverTask = NSMakeTask(TASK_CONSUMER_REQ_DISCOVER, (void *)queryAddr);
 110     NS_VERIFY_NOT_NULL(discoverTask, NS_ERROR);
 111
 112     return NSConsumerPushEvent(discoverTask);
 113 }
 114
 115 NSResult NSSubscribe(const char * providerId)
 116 {
 117     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 118     bool isStartedConsumer = NSIsStartedConsumer();
 119     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 120
 121     NSProvider_internal * provInternal = NSConsumerFindNSProvider(providerId);
 122     NS_VERIFY_NOT_NULL(provInternal, NS_ERROR);
 123
 124     NSProvider * prov = (NSProvider *)NSCopyProvider(provInternal);
 125     NSRemoveProvider_internal(provInternal);
 126     NS_VERIFY_NOT_NULL(prov, NS_ERROR);
 127
 128     NSTask * subscribeTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) prov);
 129     NS_VERIFY_NOT_NULL(subscribeTask, NS_ERROR);
 130
 131     return NSConsumerPushEvent(subscribeTask);
 132 }
 133
 134 NSResult NSUnsubscribe(const char * providerId)
 135 {
 136     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 137     bool isStartedConsumer = NSIsStartedConsumer();
 138     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 139
 140     NSProvider_internal * provInternal = NSConsumerFindNSProvider(providerId);
 141     NS_VERIFY_NOT_NULL(provInternal, NS_ERROR);
 142
 143     NSProvider * prov = (NSProvider *)NSCopyProvider((NSProvider_internal *) provInternal);
 144     NSRemoveProvider_internal(provInternal);
 145     NS_VERIFY_NOT_NULL(prov, NS_ERROR);
 146
 147     NSTask * unsubscribeTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, (void *) prov);
 148     NS_VERIFY_NOT_NULL(unsubscribeTask, NS_ERROR);
 149
 150     return NSConsumerPushEvent(unsubscribeTask);
 151 }
 152
 153 NSResult NSConsumerSendSyncInfo(const char * providerId, uint64_t messageId, NSSyncType type)
 154 {
 155     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 156     bool isStartedConsumer = NSIsStartedConsumer();
 157     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 158
 159     NSSyncInfo * syncInfo = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
 160     NS_VERIFY_NOT_NULL(syncInfo, NS_ERROR);
 161
 162     OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
 163     syncInfo->messageId = messageId;
 164     syncInfo->state = type;
 165
 166     NSTask * syncTask = NSMakeTask(TASK_MAKE_SYNCINFO, (void *) syncInfo);
 167     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(syncTask, NS_ERROR, NSOICFree(syncInfo));
 168
 169     return NSConsumerPushEvent(syncTask);
 170 }
 171
 172 NSResult NSRescanProvider()
 173 {
 174     bool isStartedConsumer = NSIsStartedConsumer();
 175     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 176
 177     NSTask * discoverTask = NSMakeTask(TASK_CONSUMER_REQ_DISCOVER, NULL);
 178     NS_VERIFY_NOT_NULL(discoverTask, NS_ERROR);
 179
 180     return NSConsumerPushEvent(discoverTask);
 181 }
 182
 183 NSProvider * NSConsumerGetProvider(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_VERIFY_NOT_NULL(providerId, NULL);
 190
 191     NSProvider_internal * prov = NSConsumerFindNSProvider(providerId);
 192     NS_VERIFY_NOT_NULL(prov, NULL);
 193
 194     NSProvider * retProv = NSCopyProvider(prov);
 195     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(retProv, NULL, NSRemoveProvider_internal(prov));
 196     NSRemoveProvider_internal(prov);
 197
 198     return retProv;
 199 }
 200
 201 NSTopicLL * NSConsumerGetTopicList(const char * providerId)
 202 {
 203     NS_VERIFY_NOT_NULL(providerId, NULL);
 204     bool isStartedConsumer = NSIsStartedConsumer();
 205     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NULL);
 206
 207     NS_LOG_V(INFO_PRIVATE, "NSProvider ID: %s", providerId);
 208     NSProvider_internal * prov_internal = NSConsumerFindNSProvider(providerId);
 209     NS_VERIFY_NOT_NULL(prov_internal, NULL);
 210
 211     NSTopicLL * retTopics = prov_internal->topicLL;
 212     prov_internal->topicLL = NULL;
 213     NSRemoveProvider_internal(prov_internal);
 214
 215     return retTopics;
 216 }
 217
 218 NSResult NSConsumerUpdateTopicList(const char * providerId, NSTopicLL * topics)
 219 {
 220     NS_VERIFY_NOT_NULL(providerId, NS_ERROR);
 221     NS_VERIFY_NOT_NULL(topics, NS_ERROR);
 222     bool isStartedConsumer = NSIsStartedConsumer();
 223     NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
 224
 225     NSProvider_internal * prov_internal = NSConsumerFindNSProvider(providerId);
 226     NS_VERIFY_NOT_NULL(prov_internal, NS_ERROR);
 227     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(prov_internal->topicLL, NS_ERROR,
 228                          NSRemoveProvider_internal(prov_internal));
 229
 230     NSSelector selector = prov_internal->accessPolicy;
 231     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(
 232             selector == NS_SELECTION_CONSUMER ? (void *) 1 : NULL, NS_ERROR,
 233             NSRemoveProvider_internal(prov_internal));
 234
 235     NSRemoveTopicLL(prov_internal->topicLL);
 236     prov_internal->topicLL = NSCopyTopicLL(topics);
 237
 238     NSTask * topicTask = NSMakeTask(TASK_CONSUMER_SELECT_TOPIC_LIST, (void *) prov_internal);
 239     NS_VERIFY_NOT_NULL(topicTask, NS_ERROR);
 240
 241     return NSConsumerPushEvent(topicTask);
 242 }