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     NSMessage_consumer * retMsg = NSStorageRead(MessageCache, messageId);
  85
  86     return retMsg;
  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         NSSetMessageCacheList(ProviderCache);
 102     }
 103
 104     NSProvider_internal * retMsg = NSStorageRead(ProviderCache, providerId);
 105
 106     return retMsg;
 107 }
 108
 109
 110 NSResult NSMessageCacheUpdate(NSMessage_consumer * msg, NSSyncType type)
 111 {
 112     NSCacheList * MessageCache = *(NSGetMessageCacheList());
 113     if (!MessageCache)
 114     {
 115         NS_LOG(DEBUG, "Message Cache Init");
 116         MessageCache = NSStorageCreate();
 117         NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);
 118
 119         MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
 120         NSSetMessageCacheList(MessageCache);
 121     }
 122
 123     NS_VERIFY_NOT_NULL(msg, NS_ERROR);
 124
 125     msg->type = type;
 126
 127     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 128     NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 129
 130     obj->data = (NSCacheData *) msg;
 131     obj->next = NULL;
 132
 133     NS_LOG(DEBUG, "try to write to storage");
 134     NSResult ret = NSStorageWrite(MessageCache, obj);
 135     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 136             NS_ERROR, NSRemoveMessage(msg));
 137
 138     NSOICFree(obj);
 139
 140     return NS_OK;
 141 }
 142
 143 NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
 144 {
 145     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
 146     if (!ProviderCache)
 147     {
 148         NS_LOG(DEBUG, "Provider Cache Init");
 149         ProviderCache = NSStorageCreate();
 150         NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
 151
 152         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 153         NSSetProviderCacheList(ProviderCache);
 154     }
 155
 156     NS_VERIFY_NOT_NULL(provider, NS_ERROR);
 157
 158     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 159     NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 160
 161     obj->data = (NSCacheData *) provider;
 162     obj->next = NULL;
 163
 164     NS_LOG(DEBUG, "try to write to storage");
 165     NSResult ret = NSStorageWrite(ProviderCache, obj);
 166     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 167             NS_ERROR, NSRemoveProvider(provider));
 168
 169     NSOICFree(obj);
 170
 171     return NS_OK;
 172 }
 173
 174 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
 175 {
 176     NS_VERIFY_NOT_NULL_V(provider);
 177
 178     NSCacheElement * cacheElement = NSProviderCacheFind(provider->providerId);
 179     NS_VERIFY_NOT_NULL_V(cacheElement);
 180
 181     NS_LOG (ERROR, "New provider is discovered");
 182     NSResult ret = NSProviderCacheUpdate(provider);
 183     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 184
 185
 186     if (provider->accessPolicy == NS_ACCESS_DENY)
 187     {
 188         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
 189         NSDiscoveredProvider((NSProvider *) provider);
 190     }
 191     else
 192     {
 193         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
 194         NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) provider);
 195         NS_VERIFY_NOT_NULL_V(task);
 196
 197         NSConsumerPushEvent(task);
 198     }
 199 }
 200
 201 void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage_consumer * msg)
 202 {
 203     NS_VERIFY_NOT_NULL_V(msg);
 204
 205     NSCacheElement * cacheElement = NSMessageCacheFind(msg->providerId);
 206     NS_VERIFY_NOT_NULL_V(cacheElement);
 207
 208     NSProvider * provider = (NSProvider *) cacheElement->data;
 209
 210     NSSubscriptionAccepted(provider);
 211 }
 212
 213 void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
 214 {
 215     NS_VERIFY_NOT_NULL_V(msg);
 216
 217     NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
 218     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 219
 220     NSMessagePost((NSMessage *) msg);
 221 }
 222
 223 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
 224 {
 225     NS_VERIFY_NOT_NULL_V(sync);
 226
 227     NSCacheElement * providerCacheElement = NSProviderCacheFind(sync->providerId);
 228     NS_VERIFY_NOT_NULL_V(providerCacheElement);
 229
 230     char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
 231     snprintf(msgId, NS_DEVICE_ID_LENGTH, "%llu", sync->messageId);
 232
 233     NSCacheElement * messageCacheElement = NSMessageCacheFind(msgId);
 234     NS_VERIFY_NOT_NULL_V (messageCacheElement);
 235
 236     NSMessage_consumer * msg = (NSMessage_consumer *) messageCacheElement->data;
 237     NSResult ret = NSMessageCacheUpdate(msg, sync->state);
 238     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 239
 240     NSNotificationSync(sync);
 241 }
 242
 243 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
 244 {
 245     NS_VERIFY_NOT_NULL_V(sync);
 246
 247     NSCacheElement * providerCacheElement = NSProviderCacheFind(sync->providerId);
 248     NS_VERIFY_NOT_NULL_V (providerCacheElement);
 249     NSProvider_internal * provider = (NSProvider_internal *) providerCacheElement->data;
 250     NS_VERIFY_NOT_NULL_V (provider);
 251
 252     NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
 253     NS_VERIFY_NOT_NULL_V(syncInfo);
 254
 255     OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
 256     syncInfo->messageId = sync->messageId;
 257     syncInfo->state = sync->state;
 258     syncInfo->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 259     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo->i_addr, NSOICFree(syncInfo));
 260     memcpy(syncInfo->i_addr, provider->i_addr, sizeof(OCDevAddr));
 261
 262     NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
 263     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
 264
 265     NSConsumerPushEvent(syncTask);
 266
 267     NSOICFree(sync);
 268 }
 269
 270 void NSConsumerInternalTaskProcessing(NSTask * task)
 271 {
 272     NS_VERIFY_NOT_NULL_V(task);
 273
 274     NSResult ret = NS_ERROR;
 275     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
 276     switch (task->taskType)
 277     {
 278         case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
 279         {
 280             NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
 281             NSConsumerHandleRecvSubscriptionConfirmed((NSMessage_consumer *)task->taskData);
 282             break;
 283         }
 284         case TASK_CONSUMER_RECV_MESSAGE:
 285         {
 286             NS_LOG(DEBUG, "Receive New Notification");
 287             NSConsumerHandleRecvMessage((NSMessage_consumer *)task->taskData);
 288
 289             break;
 290         }
 291         case TASK_CONSUMER_PROVIDER_DISCOVERED:
 292         {
 293             NS_LOG(DEBUG, "Receive New Provider is discovered.");
 294             NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
 295             break;
 296         }
 297         case TASK_RECV_SYNCINFO:
 298         {
 299             NS_LOG(DEBUG, "Receive SyncInfo.");
 300             NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
 301             break;
 302         }
 303         case TASK_MAKE_SYNCINFO:
 304         {
 305             NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
 306             NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
 307             break;
 308         }
 309         default :
 310         {
 311             NS_LOG(ERROR, "Unknown TASK Type");
 312             return ;
 313         }
 314     }
 315 }