X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=service%2Fnotification%2Fcpp-wrapper%2Fprovider%2Fsrc%2FNSProviderService.cpp;h=c6332ccab34018bb4d3d3e4825ccfaeb834a296b;hb=8229635f6d207516ccbbdf23b13be164e0fc1787;hp=af34fa66dd3bb630f34a140a50910b6f7af0886b;hpb=09b0b69187794abd4ff8ab9e30de3114f366885d;p=platform%2Fupstream%2Fiotivity.git

diff --git a/service/notification/cpp-wrapper/provider/src/NSProviderService.cpp b/service/notification/cpp-wrapper/provider/src/NSProviderService.cpp
index af34fa6..c6332cc 100755
--- a/service/notification/cpp-wrapper/provider/src/NSProviderService.cpp
+++ b/service/notification/cpp-wrapper/provider/src/NSProviderService.cpp
@@ -23,154 +23,263 @@
 #include <cstring>
 #include "NSCommon.h"
 #include "NSProviderInterface.h"
-#include "oic_string.h"
+#include "NSAcceptedConsumers.h"
 #include "NSConsumer.h"
 #include "NSSyncInfo.h"
 #include "NSConstants.h"
+#include "OCRepresentation.h"
+#include "ocpayload.h"
+#include "oic_string.h"
+#include "oic_malloc.h"
 
 namespace OIC
 {
     namespace Service
     {
-        void onConsumerSubscribedCallback(::NSConsumer *consumer)
+        void NSProviderService::onConsumerSubscribedCallback(::NSConsumer *consumer)
         {
             NS_LOG(DEBUG, "onConsumerSubscribedCallback - IN");
-            NSConsumer *nsConsumer = new NSConsumer(consumer);
+            std::shared_ptr<NSConsumer> nsConsumer = std::make_shared<NSConsumer>(consumer);
+            NSProviderService::getInstance()->getAcceptedConsumers()->addConsumer(nsConsumer);
             if (NSProviderService::getInstance()->getProviderConfig().m_subscribeRequestCb != NULL)
+            {
+                NS_LOG(DEBUG, "initiating the callback for consumer subscribed");
                 NSProviderService::getInstance()->getProviderConfig().m_subscribeRequestCb(nsConsumer);
-            delete nsConsumer;
+            }
             NS_LOG(DEBUG, "onConsumerSubscribedCallback - OUT");
         }
 
-        void onMessageSynchronizedCallback(::NSSyncInfo *syncInfo)
+        void NSProviderService::onMessageSynchronizedCallback(::NSSyncInfo *syncInfo)
         {
             NS_LOG(DEBUG, "onMessageSynchronizedCallback - IN");
-            NSSyncInfo *nsSyncInfo = new NSSyncInfo(syncInfo);
+            NSSyncInfo nsSyncInfo(syncInfo);
             if (NSProviderService::getInstance()->getProviderConfig().m_syncInfoCb != NULL)
+            {
+                NS_LOG(DEBUG, "initiating the callback for synchronized");
                 NSProviderService::getInstance()->getProviderConfig().m_syncInfoCb(nsSyncInfo);
-            delete nsSyncInfo;
+            }
             NS_LOG(DEBUG, "onMessageSynchronizedCallback - OUT");
         }
 
-        ::NSMessage *NSProviderService::getNSMessage(NSMessage *msg)
+        ::NSMessage *NSProviderService::getNSMessage(const NSMessage &msg)
         {
             ::NSMessage *nsMsg = new ::NSMessage;
-            nsMsg->messageId = msg->getMessageId();
-            OICStrcpy(nsMsg->providerId, msg->getProviderId().length(), msg->getProviderId().c_str());
-            nsMsg->sourceName = OICStrdup(msg->getSourceName().c_str());
-            nsMsg->type = (::NSMessageType) msg->getType();
-            nsMsg->dateTime = OICStrdup(msg->getTime().c_str());
-            nsMsg->ttl = msg->getTTL();
-            nsMsg->title = OICStrdup(msg->getTitle().c_str());
-            nsMsg->contentText = OICStrdup(msg->getContentText().c_str());
-
-            nsMsg->mediaContents = new ::NSMediaContents;
-            if (msg->getMediaContents() != nullptr)
-                nsMsg->mediaContents->iconImage = OICStrdup(msg->getMediaContents()->getIconImage().c_str());
+            nsMsg->messageId = msg.getMessageId();
+            OICStrcpy(nsMsg->providerId, NS_UTILS_UUID_STRING_SIZE, msg.getProviderId().c_str());
+            nsMsg->sourceName = OICStrdup(msg.getSourceName().c_str());
+            nsMsg->type = (::NSMessageType) msg.getType();
+            nsMsg->dateTime = OICStrdup(msg.getTime().c_str());
+            nsMsg->ttl = msg.getTTL();
+            nsMsg->title = OICStrdup(msg.getTitle().c_str());
+            nsMsg->contentText = OICStrdup(msg.getContentText().c_str());
+            nsMsg->topic = OICStrdup(msg.getTopic().c_str());
+
+            if (msg.getMediaContents() != nullptr)
+            {
+                nsMsg->mediaContents = new ::NSMediaContents;
+                nsMsg->mediaContents->iconImage = OICStrdup(msg.getMediaContents()->getIconImage().c_str());
+            }
             else
-                nsMsg->mediaContents->iconImage = nullptr;
+            {
+                nsMsg->mediaContents = nullptr;
+            }
+            nsMsg->extraInfo = msg.getExtraInfo().getPayload();
             return nsMsg;
         }
 
+        NSProviderService::NSProviderService()
+        {
+            m_config.m_subscribeRequestCb = NULL;
+            m_config.m_syncInfoCb = NULL;
+            m_acceptedConsumers = new NSAcceptedConsumers();
+        }
+
+        NSProviderService::~NSProviderService()
+        {
+            m_config.m_subscribeRequestCb = NULL;
+            m_config.m_syncInfoCb = NULL;
+            m_acceptedConsumers->removeConsumers();
+            delete m_acceptedConsumers;
+        }
+
         NSProviderService *NSProviderService::getInstance()
         {
             static NSProviderService s_instance;
             return &s_instance;
         }
 
-        NSResult NSProviderService::Start(NSProviderService::ProviderConfig config)
+        NSResult NSProviderService::start(NSProviderService::ProviderConfig config)
         {
-            NS_LOG(DEBUG, "Start - IN");
+            NS_LOG(DEBUG, "start - IN");
+            m_acceptedConsumers->removeConsumers();
 
             m_config = config;
             NSProviderConfig nsConfig;
             nsConfig.subRequestCallback = onConsumerSubscribedCallback;
             nsConfig.syncInfoCallback = onMessageSynchronizedCallback;
-            nsConfig.policy = config.policy;
+            nsConfig.subControllability = config.subControllability;
             nsConfig.userInfo = OICStrdup(config.userInfo.c_str());
+            nsConfig.resourceSecurity = config.resourceSecurity;
 
             NSResult result = (NSResult) NSStartProvider(nsConfig);
-            NS_LOG(DEBUG, "Start - OUT");
+            OICFree(nsConfig.userInfo);
+            NS_LOG(DEBUG, "start - OUT");
             return result;
         }
 
-        NSResult NSProviderService::Stop()
+        NSResult NSProviderService::stop()
         {
-            NS_LOG(DEBUG, "Stop - IN");
+            NS_LOG(DEBUG, "stop - IN");
+
+            m_config.m_subscribeRequestCb = NULL;
+            m_config.m_syncInfoCb = NULL;
+            m_acceptedConsumers->removeConsumers();
+
             NSResult result = (NSResult) NSStopProvider();
-            NS_LOG(DEBUG, "Stop - OUT");
+            NS_LOG(DEBUG, "stop - OUT");
             return result;
         }
 
-        NSResult NSProviderService::EnableRemoteService(const std::string &serverAddress)
+        NSResult NSProviderService::enableRemoteService(const std::string &serverAddress)
         {
-            NS_LOG(DEBUG, "EnableRemoteService - IN");
+            NS_LOG(DEBUG, "enableRemoteService - IN");
+            NS_LOG_V(INFO_PRIVATE, "Server Address : %s", serverAddress.c_str());
             NSResult result = NSResult::ERROR;
 #ifdef WITH_CLOUD
             result = (NSResult) NSProviderEnableRemoteService(OICStrdup(serverAddress.c_str()));
 #else
+            (void) serverAddress;
             NS_LOG(ERROR, "Remote Services feature is not enabled in the Build");
 #endif
-            NS_LOG(DEBUG, "EnableRemoteService - OUT");
+            NS_LOG(DEBUG, "enableRemoteService - OUT");
             return result;
         }
 
-        NSResult NSProviderService::DisableRemoteService(const std::string &serverAddress)
+        NSResult NSProviderService::disableRemoteService(const std::string &serverAddress)
         {
-            NS_LOG(DEBUG, "DisableRemoteService - IN");
+            NS_LOG(DEBUG, "disableRemoteService - IN");
+            NS_LOG_V(INFO_PRIVATE, "Server Address : %s", serverAddress.c_str());
             NSResult result = NSResult::ERROR;
 #ifdef WITH_CLOUD
             result = (NSResult) NSProviderDisableRemoteService(OICStrdup(serverAddress.c_str()));
 #else
+            (void) serverAddress;
             NS_LOG(ERROR, "Remote Services feature is not enabled in the Build");
 #endif
-            NS_LOG(DEBUG, "DisableRemoteService - OUT");
+            NS_LOG(DEBUG, "disableRemoteService - OUT");
             return result;
         }
 
-        NSResult NSProviderService::SendMessage(NSMessage *msg)
+        NSResult NSProviderService::subscribeMQService(const std::string &serverAddress,
+                const std::string &topicName)
         {
-            NS_LOG(DEBUG, "SendMessage - IN");
+            NS_LOG(DEBUG, "subscribeMQService - IN");
+            NS_LOG_V(INFO_PRIVATE, "Server Address : %s", serverAddress.c_str());
             NSResult result = NSResult::ERROR;
-            if (msg != nullptr)
+#ifdef WITH_MQ
+            result = (NSResult) NSProviderSubscribeMQService(
+                         serverAddress.c_str(), topicName.c_str());
+#else
+            NS_LOG(ERROR, "MQ Services feature is not enabled in the Build");
+            (void) serverAddress;
+            (void) topicName;
+#endif
+            NS_LOG(DEBUG, "subscribeMQService - OUT");
+            return result;
+        }
+
+        NSResult NSProviderService::sendMessage(const NSMessage &msg)
+        {
+            NS_LOG(DEBUG, "sendMessage - IN");
+            NSResult result = NSResult::ERROR;
+
+            ::NSMessage *nsMsg = getNSMessage(msg);
+
+            NS_LOG_V(INFO_PRIVATE, "nsMsg->providerId : %s", nsMsg->providerId);
+            result = (NSResult) NSSendMessage(nsMsg);
+            OICFree(nsMsg->dateTime);
+            OICFree(nsMsg->title);
+            OICFree(nsMsg->contentText);
+            OICFree(nsMsg->sourceName);
+            OICFree(nsMsg->topic);
+            if (nsMsg->mediaContents != NULL)
             {
-                ::NSMessage * nsMsg = getNSMessage(msg);
-                result = (NSResult) NSSendMessage(nsMsg);
+                if (nsMsg->mediaContents->iconImage != NULL)
+                {
+                    OICFree(nsMsg->mediaContents->iconImage);
+                }
                 delete nsMsg->mediaContents;
-                delete nsMsg;
             }
-            else
-                NS_LOG(DEBUG, "Empty Message");
-            NS_LOG(DEBUG, "SendMessage - OUT");
+            OCPayloadDestroy((OCPayload *) nsMsg->extraInfo);
+            delete nsMsg;
+
+            NS_LOG(DEBUG, "sendMessage - OUT");
             return result;
         }
 
-        void NSProviderService::SendSyncInfo(uint64_t messageId,
-                                             NSSyncInfo::NSSyncType type)
+        NSResult NSProviderService::sendSyncInfo(uint64_t messageId,
+                NSSyncInfo::NSSyncType type)
         {
-            NS_LOG(DEBUG, "SendSyncInfo - IN");
-            NSProviderSendSyncInfo(messageId, (NSSyncType)type);
-            NS_LOG(DEBUG, "SendSyncInfo - OUT");
-            return;
+            NS_LOG(DEBUG, "sendSyncInfo - IN");
+            NSResult result = (NSResult) NSProviderSendSyncInfo(messageId, (NSSyncType)type);
+            NS_LOG(DEBUG, "sendSyncInfo - OUT");
+            return result;
         }
 
-        NSMessage *NSProviderService::CreateMessage()
+        NSMessage NSProviderService::createMessage()
         {
-            NS_LOG(DEBUG, "CreateMessage - IN");
+            NS_LOG(DEBUG, "createMessage - IN");
 
             ::NSMessage *message = NSCreateMessage();
-            NSMessage *nsMessage = new NSMessage(message);
+            NSMessage nsMessage(message);
 
-            NS_LOG_V(DEBUG, "Message ID : %lld", nsMessage->getMessageId());
-            NS_LOG_V(DEBUG, "Provider ID : %s", nsMessage->getProviderId().c_str());
-            NS_LOG(DEBUG, "CreateMessage - OUT");
+            NS_LOG_V(DEBUG, "Message ID : %lld", (long long int) nsMessage.getMessageId());
+            NS_LOG_V(INFO_PRIVATE, "Provider ID : %s", nsMessage.getProviderId().c_str());
+            NS_LOG(DEBUG, "createMessage - OUT");
 
+            OICFree(message);
             return nsMessage;
         }
 
+        NSResult NSProviderService::registerTopic(const std::string &topicName)
+        {
+            NS_LOG(DEBUG, "registerTopic - IN");
+            NSResult result = (NSResult) NSProviderRegisterTopic(topicName.c_str());
+            NS_LOG(DEBUG, "registerTopic - OUT");
+            return result;
+        }
+
+        NSResult NSProviderService::unregisterTopic(const std::string &topicName)
+        {
+            NS_LOG(DEBUG, "unregisterTopic - IN");
+            NSResult result = (NSResult) NSProviderUnregisterTopic(topicName.c_str());
+            NS_LOG(DEBUG, "unregisterTopic - OUT");
+            return result;
+        }
+
+        std::shared_ptr<NSTopicsList> NSProviderService::getRegisteredTopicList()
+        {
+            NS_LOG(DEBUG, "getRegisteredTopicList - IN");
+            ::NSTopicLL *topics = NSProviderGetTopics();
+
+            std::shared_ptr<NSTopicsList> nsTopics = std::make_shared<NSTopicsList>(topics, false);
+            NS_LOG(DEBUG, "getRegisteredTopicList - OUT");
+            return nsTopics;
+        }
+
         NSProviderService::ProviderConfig NSProviderService::getProviderConfig()
         {
             return m_config;
         }
+
+        std::shared_ptr<NSConsumer> NSProviderService::getConsumer(const std::string &id)
+        {
+            return m_acceptedConsumers->getConsumer(id);
+        }
+
+        NSAcceptedConsumers *NSProviderService::getAcceptedConsumers()
+        {
+            return m_acceptedConsumers;
+        }
     }
 }