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         NSSetMessageCacheList(ProviderCache);
 102     }
 103
 104     NSCacheElement * cacheElement = NSStorageRead(ProviderCache, providerId);
 105
 106     return (NSProvider_internal *) cacheElement->data;
 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     NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
 179     NS_VERIFY_NOT_NULL_V(providerCacheData == NULL ? (void *)1 : NULL);
 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     NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
 206     NS_VERIFY_NOT_NULL_V(provider);
 207
 208     NSSubscriptionAccepted((NSProvider *) provider);
 209 }
 210
 211 void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
 212 {
 213     NS_VERIFY_NOT_NULL_V(msg);
 214
 215     NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
 216     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 217
 218     NSMessagePost((NSMessage *) msg);
 219 }
 220
 221 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
 222 {
 223     NS_VERIFY_NOT_NULL_V(sync);
 224
 225     NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
 226     NS_VERIFY_NOT_NULL_V(provider);
 227
 228     char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
 229     snprintf(msgId, NS_DEVICE_ID_LENGTH, "%lu", sync->messageId);
 230
 231     NSMessage_consumer * msg = NSMessageCacheFind(msgId);
 232     NS_VERIFY_NOT_NULL_V(msg);
 233
 234     NSResult ret = NSMessageCacheUpdate(msg, sync->state);
 235     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 236
 237     NSNotificationSync(sync);
 238 }
 239
 240 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
 241 {
 242     NS_VERIFY_NOT_NULL_V(sync);
 243
 244     NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
 245     NS_VERIFY_NOT_NULL_V (provider);
 246
 247     NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
 248     NS_VERIFY_NOT_NULL_V(syncInfo);
 249
 250     OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
 251     syncInfo->messageId = sync->messageId;
 252     syncInfo->state = sync->state;
 253     syncInfo->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 254     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo->i_addr, NSOICFree(syncInfo));
 255     memcpy(syncInfo->i_addr, provider->i_addr, sizeof(OCDevAddr));
 256
 257     NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
 258     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
 259
 260     NSConsumerPushEvent(syncTask);
 261
 262     NSOICFree(sync);
 263 }
 264
 265 void NSConsumerInternalTaskProcessing(NSTask * task)
 266 {
 267     NS_VERIFY_NOT_NULL_V(task);
 268
 269     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
 270     switch (task->taskType)
 271     {
 272         case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
 273         {
 274             NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
 275             NSConsumerHandleRecvSubscriptionConfirmed((NSMessage_consumer *)task->taskData);
 276             break;
 277         }
 278         case TASK_CONSUMER_RECV_MESSAGE:
 279         {
 280             NS_LOG(DEBUG, "Receive New Notification");
 281             NSConsumerHandleRecvMessage((NSMessage_consumer *)task->taskData);
 282
 283             break;
 284         }
 285         case TASK_CONSUMER_PROVIDER_DISCOVERED:
 286         {
 287             NS_LOG(DEBUG, "Receive New Provider is discovered.");
 288             NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
 289             break;
 290         }
 291         case TASK_RECV_SYNCINFO:
 292         {
 293             NS_LOG(DEBUG, "Receive SyncInfo.");
 294             NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
 295             break;
 296         }
 297         case TASK_MAKE_SYNCINFO:
 298         {
 299             NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
 300             NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
 301             break;
 302         }
 303         default :
 304         {
 305             NS_LOG(ERROR, "Unknown TASK Type");
 306             return ;
 307         }
 308     }
 309 }