void NSConsumerHandleRecvMessage(NSMessage * msg)
{
NS_VERIFY_NOT_NULL_V(msg);
NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
NSMessagePost((NSMessage *) msg);
}
void NSConsumerHandleProviderDeleted(NSProvider_internal * provider)
{
NS_VERIFY_NOT_NULL_V(provider);
NSCacheList * providerCache = *(NSGetProviderCacheList());
NS_VERIFY_NOT_NULL_V(providerCache);
NSResult ret = NSStorageDelete(providerCache, provider->providerId);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
}
void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage * msg)
{
NS_VERIFY_NOT_NULL_V(msg);
NS_LOG_V(DEBUG, "confirmed by : %s", msg->providerId);
NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
NS_VERIFY_NOT_NULL_V(provider);
if (provider->connection->next == NULL)
{
NS_LOG(DEBUG, "call back to user");
NSSubscriptionAccepted((NSProvider *) provider);
}
}
void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
{
NS_VERIFY_NOT_NULL_V(sync);
char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
snprintf(msgId, NS_DEVICE_ID_LENGTH, "%lld", (long long int)sync->messageId);
NSMessage * msg = NSMessageCacheFind(msgId);
NS_VERIFY_NOT_NULL_V(msg);
NSResult ret = NSMessageCacheUpdate(msg, sync->state);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
NSRemoveMessage(msg);
NSNotificationSync(sync);
}
void NSConsumerInternalTaskProcessing(NSTask * task)
{
NS_VERIFY_NOT_NULL_V(task);
NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
switch (task->taskType)
{
case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
{
NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
NSConsumerHandleRecvSubscriptionConfirmed((NSMessage *)task->taskData);
NSRemoveMessage((NSMessage *)task->taskData);
break;
}
case TASK_CONSUMER_RECV_MESSAGE:
{
NS_LOG(DEBUG, "Receive New Notification");
NSConsumerHandleRecvMessage((NSMessage *)task->taskData);
NSRemoveMessage((NSMessage *)task->taskData);
break;
}
case TASK_CONSUMER_PROVIDER_DISCOVERED:
{
NS_LOG(DEBUG, "Receive New Provider is discovered.");
NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
NSRemoveProvider((NSProvider_internal *)task->taskData);
break;
}
case TASK_RECV_SYNCINFO:
{
NS_LOG(DEBUG, "Receive SyncInfo.");
NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
NSOICFree(task->taskData);
break;
}
case TASK_MAKE_SYNCINFO:
{
NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
NSOICFree(task->taskData);
break;
}
case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
{
NS_LOG(DEBUG, "Make Subscribe cancel from provider.");
NSConsumerHandleProviderDeleted((NSProvider_internal *)task->taskData);
NSRemoveProvider((NSProvider_internal *)task->taskData);
break;
}
default :
{
NS_LOG(ERROR, "Unknown TASK Type");
return ;
}
}
NSOICFree(task);
}
void NSDestroyThreadHandle(NSConsumerThread * handle)
{
NS_VERIFY_NOT_NULL_V(handle);
pthread_mutex_destroy(&(handle->mutex));
pthread_mutexattr_destroy(&(handle->mutex_attr));
pthread_mutex_unlock(&g_create_mutex);
}
void NSThreadStop(NSConsumerThread * handle)
{
NS_VERIFY_NOT_NULL_V(handle);
handle->isStarted = false;
NSThreadJoin(handle);
NSDestroyThreadHandle(handle);
}
void NSThreadJoin(NSConsumerThread * handle)
{
NS_VERIFY_NOT_NULL_V(handle);
if (handle->thread_id)
{
void * retData = NULL;
pthread_join(handle->thread_id, & retData);
NSOICFree(retData);
}
}
void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
{
NS_VERIFY_NOT_NULL_V(sync);
NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
NS_VERIFY_NOT_NULL_V (provider);
NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
NS_VERIFY_NOT_NULL_V (connections);
NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections));
OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
syncInfo->messageId = sync->messageId;
syncInfo->state = sync->state;
syncInfo->connection = connections;
NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
NSConsumerPushEvent(syncTask);
}
void NSCancelAllSubscription()
{
NSCacheList * ProviderCache = *(NSGetProviderCacheList());
if (!ProviderCache)
{
NS_LOG(DEBUG, "Provider Cache Init");
ProviderCache = NSStorageCreate();
NS_VERIFY_NOT_NULL_V(ProviderCache);
ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
NSSetProviderCacheList(ProviderCache);
}
NSCacheElement * obj = NULL;
while ((obj = NSPopProviderCacheList(ProviderCache)))
{
NS_LOG(DEBUG, "build NSTask");
NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, (void *) obj->data);
NS_VERIFY_NOT_NULL_V(task);
NSConsumerPushEvent(task);
}
}
void NSDestroyQueue(NSConsumerQueue * queue)
{
NS_VERIFY_NOT_NULL_V(queue);
NSConsumerQueueObject * node = NSPopQueue(queue);
while(node)
{
NSConsumerQueueObject * next = (NSConsumerQueueObject *)node->next;
NSOICFree(node->data);
NSOICFree(node);
node = next;
}
NSOICFree(queue);
}
void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
{
NS_VERIFY_NOT_NULL_V(provider);
bool isAdded = true;
bool isSubscribing = false;
NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
if (providerCacheData == NULL)
{
isAdded = false;
}
else
{
providerCacheData->accessPolicy = provider->accessPolicy;
NSProviderConnectionInfo * infos = providerCacheData->connection;
OCTransportAdapter newAdapter = provider->connection->addr->adapter;
while (infos)
{
isSubscribing |= infos->isSubscribing;
if (infos->addr->adapter == newAdapter && infos->isSubscribing == true)
{
NS_LOG_V(DEBUG, "This provider already discovered : %s:%d",
infos->addr->addr, infos->addr->port);
NS_LOG_V(DEBUG, "Subscription : %d", infos->isSubscribing);
return;
}
infos = infos->next;
}
}
NSResult ret = NSProviderCacheUpdate(provider);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
if (isAdded == false)
{
NS_LOG(DEBUG, "New provider is discovered");
}
else
{
provider = providerCacheData;
NS_LOG(DEBUG, "provider's connection is updated.");
}
if (provider->accessPolicy == NS_SELECTION_CONSUMER && isSubscribing == false)
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
NSDiscoveredProvider((NSProvider *) provider);
}
else
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
NSProvider_internal * subProvider = NSCopyProvider(provider);
NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
NS_VERIFY_NOT_NULL_V(task);
NSConsumerPushEvent(task);
}
NSRemoveProvider(providerCacheData);
}
void NSThreadUnlock(NSConsumerThread * handle)
{
NS_VERIFY_NOT_NULL_V(handle);
pthread_mutex_unlock(&(handle->mutex));
}
