1 //******************************************************************
3 // Copyright 2016 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "NSConstants.h"
22 #include "NSConsumerCommon.h"
23 #include "NSConsumerInternalTaskController.h"
24 #include "NSStructs.h"
26 #include "oic_malloc.h"
27 #include "oic_string.h"
29 NSCacheList ** NSGetMessageCacheList()
31 static NSCacheList * messageCache = NULL;
32 return & messageCache;
35 void NSSetMessageCacheList(NSCacheList * cache)
37 *(NSGetMessageCacheList()) = cache;
40 NSCacheList ** NSGetProviderCacheList()
42 static NSCacheList * providerCache = NULL;
43 return & providerCache;
46 void NSSetProviderCacheList(NSCacheList * cache)
48 *(NSGetProviderCacheList()) = cache;
51 void NSDestroyMessageCacheList()
53 NSCacheList * cache = *(NSGetMessageCacheList());
56 NSStorageDestroy(cache);
60 void NSDestroyProviderCacheList()
62 NSCacheList * cache = *(NSGetProviderCacheList());
65 NSStorageDestroy(cache);
69 NSMessage_consumer * NSMessageCacheFind(const char * messageId)
71 NS_VERIFY_NOT_NULL(messageId, NULL);
73 NSCacheList * MessageCache = *(NSGetMessageCacheList());
76 NS_LOG(DEBUG, "Message Cache Init");
77 MessageCache = NSStorageCreate();
78 NS_VERIFY_NOT_NULL(MessageCache, NULL);
80 MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
81 NSSetMessageCacheList(MessageCache);
84 NSCacheElement * cacheElement = NSStorageRead(MessageCache, messageId);
86 return (NSMessage_consumer *) cacheElement->data;
89 NSProvider_internal * NSProviderCacheFind(const char * providerId)
91 NS_VERIFY_NOT_NULL(providerId, NULL);
93 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
96 NS_LOG(DEBUG, "Provider Cache Init");
97 ProviderCache = NSStorageCreate();
98 NS_VERIFY_NOT_NULL(ProviderCache, NULL);
100 ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
101 NSSetProviderCacheList(ProviderCache);
104 NSCacheElement * cacheElement = NSStorageRead(ProviderCache, providerId);
105 NS_VERIFY_NOT_NULL(cacheElement, NULL);
107 return (NSProvider_internal *) cacheElement->data;
111 NSResult NSMessageCacheUpdate(NSMessage_consumer * msg, NSSyncType type)
113 NSCacheList * MessageCache = *(NSGetMessageCacheList());
116 NS_LOG(DEBUG, "Message Cache Init");
117 MessageCache = NSStorageCreate();
118 NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);
120 MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
121 NSSetMessageCacheList(MessageCache);
124 NS_VERIFY_NOT_NULL(msg, NS_ERROR);
128 NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
129 NS_VERIFY_NOT_NULL(obj, NS_ERROR);
131 obj->data = (NSCacheData *) msg;
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));
144 NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
146 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
149 NS_LOG(DEBUG, "Provider Cache Init");
150 ProviderCache = NSStorageCreate();
151 NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
153 ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
154 NSSetProviderCacheList(ProviderCache);
157 NS_VERIFY_NOT_NULL(provider, NS_ERROR);
159 NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
160 NS_VERIFY_NOT_NULL(obj, NS_ERROR);
162 obj->data = (NSCacheData *) provider;
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));
175 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
177 NS_VERIFY_NOT_NULL_V(provider);
180 NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
181 //NS_VERIFY_NOT_NULL_V(providerCacheData == NULL ? (void *)1 : NULL);
182 if (providerCacheData == NULL)
188 NSProviderConnectionInfo * infos = providerCacheData->connection;
189 OCTransportAdapter newAdapter = provider->connection->addr->adapter;
192 if (infos->addr->adapter == newAdapter)
194 NS_LOG(DEBUG, "This provider already discovered.");
201 NSResult ret = NSProviderCacheUpdate(provider);
202 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
204 if (isAdded == false)
206 NS_LOG(DEBUG, "New provider is discovered");
210 provider = providerCacheData;
211 NS_LOG(DEBUG, "provider's connection is updated.");
215 if (provider->accessPolicy == NS_ACCESS_DENY && isAdded == false)
217 NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
218 NSDiscoveredProvider((NSProvider *) provider);
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);
226 NSConsumerPushEvent(task);
230 void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage_consumer * msg)
232 NS_VERIFY_NOT_NULL_V(msg);
234 NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
235 NS_VERIFY_NOT_NULL_V(provider);
237 if (provider->connection->next == NULL)
239 NSSubscriptionAccepted((NSProvider *) provider);
243 void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
245 NS_VERIFY_NOT_NULL_V(msg);
247 NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
248 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
250 NSMessagePost((NSMessage *) msg);
253 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
255 NS_VERIFY_NOT_NULL_V(sync);
257 NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
258 NS_VERIFY_NOT_NULL_V(provider);
260 char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
261 snprintf(msgId, NS_DEVICE_ID_LENGTH, "%lu", sync->messageId);
263 NSMessage_consumer * msg = NSMessageCacheFind(msgId);
264 NS_VERIFY_NOT_NULL_V(msg);
266 NSResult ret = NSMessageCacheUpdate(msg, sync->state);
267 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
269 NSNotificationSync(sync);
272 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
274 NS_VERIFY_NOT_NULL_V(sync);
276 NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
277 NS_VERIFY_NOT_NULL_V (provider);
279 NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
280 NS_VERIFY_NOT_NULL_V (connections);
282 NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
283 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections));
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;
290 NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
291 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
293 NSConsumerPushEvent(syncTask);
298 void NSConsumerInternalTaskProcessing(NSTask * task)
300 NS_VERIFY_NOT_NULL_V(task);
302 NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
303 switch (task->taskType)
305 case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
307 NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
308 NSConsumerHandleRecvSubscriptionConfirmed((NSMessage_consumer *)task->taskData);
311 case TASK_CONSUMER_RECV_MESSAGE:
313 NS_LOG(DEBUG, "Receive New Notification");
314 NSConsumerHandleRecvMessage((NSMessage_consumer *)task->taskData);
318 case TASK_CONSUMER_PROVIDER_DISCOVERED:
320 NS_LOG(DEBUG, "Receive New Provider is discovered.");
321 NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
324 case TASK_RECV_SYNCINFO:
326 NS_LOG(DEBUG, "Receive SyncInfo.");
327 NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
330 case TASK_MAKE_SYNCINFO:
332 NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
333 NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
338 NS_LOG(ERROR, "Unknown TASK Type");