service/notification/src/consumer/NSConsumerInternalTaskController.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 "NSConstants.h"
  22 #include "NSConsumerCommon.h"
  23 #include "NSConsumerInternalTaskController.h"
  24 #include "NSStructs.h"
  25
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28
  29 NSCacheList ** NSGetMessageCacheList()
  30 {
  31     static NSCacheList * messageCache = NULL;
  32     return & messageCache;
  33 }
  34
  35 void NSSetMessageCacheList(NSCacheList * cache)
  36 {
  37     *(NSGetMessageCacheList()) = cache;
  38 }
  39
  40 NSCacheList ** NSGetProviderCacheList()
  41 {
  42     static NSCacheList * providerCache = NULL;
  43     return & providerCache;
  44 }
  45
  46 void NSSetProviderCacheList(NSCacheList * cache)
  47 {
  48     *(NSGetProviderCacheList()) = cache;
  49 }
  50
  51 void NSDestroyMessageCacheList()
  52 {
  53     NSCacheList * cache = *(NSGetMessageCacheList());
  54     if (cache)
  55     {
  56         NSStorageDestroy(cache);
  57     }
  58 }
  59
  60 void NSDestroyProviderCacheList()
  61 {
  62     NSCacheList * cache = *(NSGetProviderCacheList());
  63     if (cache)
  64     {
  65         NSStorageDestroy(cache);
  66     }
  67 }
  68
  69 NSMessage_consumer * NSMessageCacheFind(const char * messageId)
  70 {
  71     NS_VERIFY_NOT_NULL(messageId, NULL);
  72
  73     NSCacheList * MessageCache = *(NSGetMessageCacheList());
  74     if (!MessageCache)
  75     {
  76         NS_LOG(DEBUG, "Message Cache Init");
  77         MessageCache = NSStorageCreate();
  78         NS_VERIFY_NOT_NULL(MessageCache, NULL);
  79
  80         MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
  81         NSSetMessageCacheList(MessageCache);
  82     }
  83
  84     NSCacheElement * cacheElement = NSStorageRead(MessageCache, messageId);
  85
  86     return (NSMessage_consumer *) cacheElement->data;
  87 }
  88
  89 NSProvider_internal * NSProviderCacheFind(const char * providerId)
  90 {
  91     NS_VERIFY_NOT_NULL(providerId, NULL);
  92
  93     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
  94     if (!ProviderCache)
  95     {
  96         NS_LOG(DEBUG, "Provider Cache Init");
  97         ProviderCache = NSStorageCreate();
  98         NS_VERIFY_NOT_NULL(ProviderCache, NULL);
  99
 100         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 101         NSSetProviderCacheList(ProviderCache);
 102     }
 103
 104     NSCacheElement * cacheElement = NSStorageRead(ProviderCache, providerId);
 105     NS_VERIFY_NOT_NULL(cacheElement, NULL);
 106
 107     return (NSProvider_internal *) cacheElement->data;
 108 }
 109
 110
 111 NSResult NSMessageCacheUpdate(NSMessage_consumer * msg, NSSyncType type)
 112 {
 113     NSCacheList * MessageCache = *(NSGetMessageCacheList());
 114     if (!MessageCache)
 115     {
 116         NS_LOG(DEBUG, "Message Cache Init");
 117         MessageCache = NSStorageCreate();
 118         NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);
 119
 120         MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
 121         NSSetMessageCacheList(MessageCache);
 122     }
 123
 124     NS_VERIFY_NOT_NULL(msg, NS_ERROR);
 125
 126     msg->type = type;
 127
 128     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 129     NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 130
 131     obj->data = (NSCacheData *) msg;
 132     obj->next = NULL;
 133
 134     NS_LOG(DEBUG, "try to write to storage");
 135     NSResult ret = NSStorageWrite(MessageCache, obj);
 136     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 137             NS_ERROR, NSRemoveMessage(msg));
 138
 139     NSOICFree(obj);
 140
 141     return NS_OK;
 142 }
 143
 144 NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
 145 {
 146     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
 147     if (!ProviderCache)
 148     {
 149         NS_LOG(DEBUG, "Provider Cache Init");
 150         ProviderCache = NSStorageCreate();
 151         NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
 152
 153         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 154         NSSetProviderCacheList(ProviderCache);
 155     }
 156
 157     NS_VERIFY_NOT_NULL(provider, NS_ERROR);
 158
 159     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 160     NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 161
 162     obj->data = (NSCacheData *) provider;
 163     obj->next = NULL;
 164
 165     NS_LOG(DEBUG, "try to write to storage");
 166     NSResult ret = NSStorageWrite(ProviderCache, obj);
 167     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 168             NS_ERROR, NSRemoveProvider(provider));
 169
 170     NSOICFree(obj);
 171
 172     return NS_OK;
 173 }
 174
 175 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
 176 {
 177     NS_VERIFY_NOT_NULL_V(provider);
 178
 179     bool isAdded = true;
 180     NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
 181     //NS_VERIFY_NOT_NULL_V(providerCacheData == NULL ? (void *)1 : NULL);
 182     if (providerCacheData == NULL)
 183     {
 184         isAdded = false;
 185     }
 186     else
 187     {
 188         NSProviderConnectionInfo * infos = providerCacheData->connection;
 189         OCTransportAdapter newAdapter = provider->connection->addr->adapter;
 190         while(infos)
 191         {
 192             if (infos->addr->adapter == newAdapter)
 193             {
 194                 NS_LOG(DEBUG, "This provider already discovered.");
 195                 return;
 196             }
 197             infos = infos->next;
 198         }
 199     }
 200
 201     NSResult ret = NSProviderCacheUpdate(provider);
 202     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 203
 204     if (isAdded == false)
 205     {
 206         NS_LOG(DEBUG, "New provider is discovered");
 207     }
 208     else
 209     {
 210         provider = providerCacheData;
 211         NS_LOG(DEBUG, "provider's connection is updated.");
 212     }
 213
 214
 215     if (provider->accessPolicy == NS_ACCESS_DENY && isAdded == false)
 216     {
 217         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
 218         NSDiscoveredProvider((NSProvider *) provider);
 219     }
 220     else
 221     {
 222         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
 223         NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) provider);
 224         NS_VERIFY_NOT_NULL_V(task);
 225
 226         NSConsumerPushEvent(task);
 227     }
 228 }
 229
 230 void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage_consumer * msg)
 231 {
 232     NS_VERIFY_NOT_NULL_V(msg);
 233
 234     NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
 235     NS_VERIFY_NOT_NULL_V(provider);
 236
 237     if (provider->connection->next == NULL)
 238     {
 239         NSSubscriptionAccepted((NSProvider *) provider);
 240     }
 241 }
 242
 243 void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
 244 {
 245     NS_VERIFY_NOT_NULL_V(msg);
 246
 247     NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
 248     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 249
 250     NSMessagePost((NSMessage *) msg);
 251 }
 252
 253 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
 254 {
 255     NS_VERIFY_NOT_NULL_V(sync);
 256
 257     NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
 258     NS_VERIFY_NOT_NULL_V(provider);
 259
 260     char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
 261     snprintf(msgId, NS_DEVICE_ID_LENGTH, "%lld", sync->messageId);
 262
 263     NSMessage_consumer * msg = NSMessageCacheFind(msgId);
 264     NS_VERIFY_NOT_NULL_V(msg);
 265
 266     NSResult ret = NSMessageCacheUpdate(msg, sync->state);
 267     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 268
 269     NSNotificationSync(sync);
 270 }
 271
 272 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
 273 {
 274     NS_VERIFY_NOT_NULL_V(sync);
 275
 276     NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
 277     NS_VERIFY_NOT_NULL_V (provider);
 278
 279     NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
 280     NS_VERIFY_NOT_NULL_V (connections);
 281
 282     NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
 283     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections));
 284
 285     OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
 286     syncInfo->messageId = sync->messageId;
 287     syncInfo->state = sync->state;
 288     syncInfo->connection = connections;
 289
 290     NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
 291     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
 292
 293     NSConsumerPushEvent(syncTask);
 294
 295     NSOICFree(sync);
 296 }
 297
 298 void NSConsumerInternalTaskProcessing(NSTask * task)
 299 {
 300     NS_VERIFY_NOT_NULL_V(task);
 301
 302     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
 303     switch (task->taskType)
 304     {
 305         case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
 306         {
 307             NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
 308             NSConsumerHandleRecvSubscriptionConfirmed((NSMessage_consumer *)task->taskData);
 309             break;
 310         }
 311         case TASK_CONSUMER_RECV_MESSAGE:
 312         {
 313             NS_LOG(DEBUG, "Receive New Notification");
 314             NSConsumerHandleRecvMessage((NSMessage_consumer *)task->taskData);
 315
 316             break;
 317         }
 318         case TASK_CONSUMER_PROVIDER_DISCOVERED:
 319         {
 320             NS_LOG(DEBUG, "Receive New Provider is discovered.");
 321             NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
 322             break;
 323         }
 324         case TASK_RECV_SYNCINFO:
 325         {
 326             NS_LOG(DEBUG, "Receive SyncInfo.");
 327             NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
 328             break;
 329         }
 330         case TASK_MAKE_SYNCINFO:
 331         {
 332             NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
 333             NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
 334             break;
 335         }
 336         default :
 337         {
 338             NS_LOG(ERROR, "Unknown TASK Type");
 339             return ;
 340         }
 341     }
 342 }