X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fsrc%2FInProcServerWrapper.cpp;h=06591165fbfe2421438dbcd855e7c38ad31703da;hb=refs%2Ftags%2Faccepted%2Ftizen%2Funified%2F20171010.063815;hp=3d0ad0a555898a4ed10d3541f3426f49d96eeac8;hpb=4ed8d73b591a245d828e97f79a47a2e572475bd3;p=platform%2Fupstream%2Fiotivity.git

diff --git a/resource/src/InProcServerWrapper.cpp b/resource/src/InProcServerWrapper.cpp
index 3d0ad0a..0659116 100644
--- a/resource/src/InProcServerWrapper.cpp
+++ b/resource/src/InProcServerWrapper.cpp
@@ -32,14 +32,15 @@
 #include <OCResourceRequest.h>
 #include <OCResourceResponse.h>
 #include <ocstack.h>
+#include <ocpayload.h>
+
 #include <OCApi.h>
 #include <oic_malloc.h>
 #include <OCPlatform.h>
 #include <OCUtilities.h>
+#include "logger.h"
 
-#ifdef RD_CLIENT
-#include <oicresourcedirectory.h>
-#endif
+#define TAG "OIC_SERVER_WRAPPER"
 
 using namespace std;
 using namespace OC;
@@ -256,19 +257,27 @@ namespace OC
 {
     InProcServerWrapper::InProcServerWrapper(
         std::weak_ptr<std::recursive_mutex> csdkLock, PlatformConfig cfg)
-     : m_csdkLock(csdkLock)
+     : m_threadRun(false),
+       m_csdkLock(csdkLock),
+       m_cfg { cfg }       
     {
-        OCMode initType;
+        start();
+    }
 
-        if(cfg.mode == ModeType::Server)
+    OCStackResult InProcServerWrapper::start()
+    {
+        OIC_LOG_V(INFO, TAG, "start ocplatform for server : %d", m_cfg.transportType);
+
+        OCMode initType;
+        if(m_cfg.mode == ModeType::Server)
         {
             initType = OC_SERVER;
         }
-        else if (cfg.mode == ModeType::Both)
+        else if (m_cfg.mode == ModeType::Both)
         {
             initType = OC_CLIENT_SERVER;
         }
-        else if (cfg.mode == ModeType::Gateway)
+        else if (m_cfg.mode == ModeType::Gateway)
         {
             initType = OC_GATEWAY;
         }
@@ -279,18 +288,43 @@ namespace OC
         }
 
         OCTransportFlags serverFlags =
-                            static_cast<OCTransportFlags>(cfg.serverConnectivity & CT_MASK_FLAGS);
+                            static_cast<OCTransportFlags>(m_cfg.serverConnectivity & CT_MASK_FLAGS);
         OCTransportFlags clientFlags =
-                            static_cast<OCTransportFlags>(cfg.clientConnectivity & CT_MASK_FLAGS);
-        OCStackResult result = OCInit1(initType, serverFlags, clientFlags);
+                            static_cast<OCTransportFlags>(m_cfg.clientConnectivity & CT_MASK_FLAGS);
+        OCStackResult result = OCInit2(initType, serverFlags, clientFlags,
+                                       m_cfg.transportType);
 
         if(OC_STACK_OK != result)
         {
             throw InitializeException(OC::InitException::STACK_INIT_ERROR, result);
         }
 
-        m_threadRun = true;
-        m_processThread = std::thread(&InProcServerWrapper::processFunc, this);
+        if (false == m_threadRun)
+        {
+            m_threadRun = true;
+            m_processThread = std::thread(&InProcServerWrapper::processFunc, this);
+        }
+        return OC_STACK_OK;
+    }
+
+    OCStackResult InProcServerWrapper::stop()
+    {
+        OIC_LOG(INFO, TAG, "stop");
+
+        if(m_processThread.joinable())
+        {
+            m_threadRun = false;
+            m_processThread.join();
+        }
+
+        OCStackResult res = OCStop();
+
+        if (OC_STACK_OK != res)
+        {
+           throw InitializeException(OC::InitException::STACK_TERMINATE_ERROR, res);
+        }
+
+        return OC_STACK_OK;
     }
 
     void InProcServerWrapper::processFunc()
@@ -327,7 +361,7 @@ namespace OC
         return result;
     }
 
-     OCStackResult InProcServerWrapper::registerPlatformInfo(const OCPlatformInfo platformInfo)
+    OCStackResult InProcServerWrapper::registerPlatformInfo(const OCPlatformInfo platformInfo)
     {
         auto cLock = m_csdkLock.lock();
         OCStackResult result = OC_STACK_ERROR;
@@ -339,6 +373,32 @@ namespace OC
         return result;
     }
 
+    OCStackResult InProcServerWrapper::setPropertyValue(OCPayloadType type, const std::string& propName,
+        const std::string& propValue)
+    {
+        auto cLock = m_csdkLock.lock();
+        OCStackResult result = OC_STACK_ERROR;
+        if (cLock)
+        {
+            std::lock_guard<std::recursive_mutex> lock(*cLock);
+            result = OCSetPropertyValue(type, propName.c_str(), (void *)propValue.c_str());
+        }
+        return result;
+    }
+
+    OCStackResult InProcServerWrapper::getPropertyValue(OCPayloadType type, const std::string& propName,
+        std::string& propValue)
+    {
+        auto cLock = m_csdkLock.lock();
+        OCStackResult result = OC_STACK_ERROR;
+        if (cLock)
+        {
+            std::lock_guard<std::recursive_mutex> lock(*cLock);
+            result = OCGetPropertyValue(type, propName.c_str(), (void **)propValue.c_str());
+        }
+        return result;
+    }
+
     OCStackResult InProcServerWrapper::registerResource(
                     OCResourceHandle& resourceHandle,
                     std::string& resourceURI,
@@ -588,7 +648,6 @@ namespace OC
             }
             else
             {
-                OICFree(response.payload);
                 result = OC_STACK_ERROR;
             }
 
@@ -596,161 +655,67 @@ namespace OC
             {
                 oclog() << "Error sending response\n";
             }
-            return result;
-        }
-    }
-#ifdef RD_CLIENT
-    OCRepresentation parseRDResponseCallback(OCClientResponse* clientResponse)
-    {
-        if (nullptr == clientResponse || nullptr == clientResponse->payload ||
-                    PAYLOAD_TYPE_RD != clientResponse->payload->type)
-        {
-            return OCRepresentation();
-        }
-
-        MessageContainer oc;
-        oc.setPayload(clientResponse->payload);
-
-        std::vector<OCRepresentation>::const_iterator it = oc.representations().begin();
-        if (it == oc.representations().end())
-        {
-            return OCRepresentation();
-        }
-
-        // first one is considered the root, everything else is considered a child of this one.
-        OCRepresentation root = *it;
-        root.setDevAddr(clientResponse->devAddr);
-        root.setUri(clientResponse->resourceUri);
-        ++it;
-
-        std::for_each(it, oc.representations().end(),
-                [&root](const OCRepresentation& repItr)
-                {root.addChild(repItr);});
-        return root;
-
-    }
-
-    OCStackApplicationResult publishResourceToRDCallback(void* ctx, OCDoHandle /*handle*/,
-                                                         OCClientResponse* clientResponse)
-    {
-        ServerCallbackContext::PublishContext* context =
-        static_cast<ServerCallbackContext::PublishContext*>(ctx);
 
-        try
-        {
-            // Update resource unique id in stack.
-            if (clientResponse)
-            {
-                if (clientResponse->payload)
-                {
-                    OCRDPayload *rdPayload = (OCRDPayload *) clientResponse->payload;
-                    OCLinksPayload *links = rdPayload->rdPublish->setLinks;
-
-                    while (links)
-                    {
-                        OCResourceHandle handle = OCGetResourceHandleAtUri(links->href);
-                        OCBindResourceInsToResource(handle, links->ins);
-                        links = links->next;
-                    }
-
-                }
-            }
-
-            OCRepresentation rep = parseRDResponseCallback(clientResponse);
-            std::thread exec(context->callback, rep, clientResponse->result);
-            exec.detach();
-        }
-        catch (OC::OCException& e)
-        {
-            oclog() <<"Exception in publishResourceToRDCallback, ignoring response: "
-                <<e.what() <<std::flush;
+            OCPayloadDestroy(response.payload);
+            return result;
         }
-
-        return OC_STACK_KEEP_TRANSACTION;
     }
 
-    OCStackResult InProcServerWrapper::publishResourceToRD(const std::string& host,
-                                                           OCConnectivityType connectivityType,
-                                                           ResourceHandles& resourceHandles,
-                                                           PublishResourceCallback& callback,
-                                                           OCQualityOfService qos)
+    OCStackResult InProcServerWrapper::notifyAllObservers(OCResourceHandle resourceHandle,
+                                                          QualityOfService QoS)
     {
-        ServerCallbackContext::PublishContext* ctx =
-            new ServerCallbackContext::PublishContext(callback);
-        OCCallbackData cbdata(
-                static_cast<void*>(ctx),
-                publishResourceToRDCallback,
-                [](void* c)
-                {delete static_cast<ServerCallbackContext::PublishContext*>(c);}
-                );
-
         auto cLock = m_csdkLock.lock();
         OCStackResult result = OC_STACK_ERROR;
         if (cLock)
         {
             std::lock_guard<std::recursive_mutex> lock(*cLock);
-            result = OCRDPublish(host.c_str(), connectivityType, &resourceHandles[0],
-                                 resourceHandles.size(), &cbdata, qos);
+            result = OCNotifyAllObservers(resourceHandle, static_cast<OCQualityOfService>(QoS));
         }
 
-        if (OC_STACK_OK != result)
-        {
-            throw OCException(OC::Exception::PUBLISH_RESOURCE_FAILED, result);
-        }
         return result;
     }
 
-    OCStackApplicationResult deleteResourceFromRDCallback(void* ctx, OCDoHandle /*handle*/,
-                                                          OCClientResponse* clientResponse)
+    OCStackResult InProcServerWrapper::notifyListOfObservers(OCResourceHandle resourceHandle,
+                                               ObservationIds& observationIds,
+                                               const std::shared_ptr<OCResourceResponse> pResponse,
+                                               QualityOfService QoS)
     {
-        ServerCallbackContext::DeleteContext* context =
-        static_cast<ServerCallbackContext::DeleteContext*>(ctx);
-
-        std::thread exec(context->callback, clientResponse->result);
-        exec.detach();
-        return OC_STACK_DELETE_TRANSACTION;
-    }
-
-    OCStackResult InProcServerWrapper::deleteResourceFromRD(const std::string& host,
-                                                            OCConnectivityType connectivityType,
-                                                            ResourceHandles& resourceHandles,
-                                                            DeleteResourceCallback& callback,
-                                                            OCQualityOfService qos)
-    {
-        ServerCallbackContext::DeleteContext* ctx =
-            new ServerCallbackContext::DeleteContext(callback);
-        OCCallbackData cbdata(
-                static_cast<void*>(ctx),
-                deleteResourceFromRDCallback,
-                [](void* c)
-                {delete static_cast<ServerCallbackContext::DeleteContext*>(c);}
-                );
+        if (!pResponse)
+        {
+            return OC_STACK_ERROR;
+        }
 
         auto cLock = m_csdkLock.lock();
         OCStackResult result = OC_STACK_ERROR;
         if (cLock)
         {
             std::lock_guard<std::recursive_mutex> lock(*cLock);
-            result = OCRDDelete(host.c_str(), connectivityType, &resourceHandles[0],
-                                resourceHandles.size(), &cbdata, qos);
+
+            OCRepPayload* pl = pResponse->getResourceRepresentation().getPayload();
+            result = OCNotifyListOfObservers(resourceHandle,
+                                             &observationIds[0],
+                                             observationIds.size(),
+                                             pl,
+                                             static_cast<OCQualityOfService>(QoS));
+            OCRepPayloadDestroy(pl);
         }
 
-        if (OC_STACK_OK != result)
+        if (result != OC_STACK_OK)
         {
-            throw OCException(OC::Exception::PUBLISH_RESOURCE_FAILED, result);
+            throw OCException(OC::Exception::NOTIFY_LIST_OBSERVERS_FAILED, result);
         }
         return result;
     }
-#endif
+
     InProcServerWrapper::~InProcServerWrapper()
     {
-        if(m_processThread.joinable())
+        try
         {
-            m_threadRun = false;
-            m_processThread.join();
+            stop();
+        }
+        catch (InitializeException &e)
+        {
+            oclog() << "Exception in stop"<< e.what() << std::flush;
         }
-
-        OCStop();
     }
 }
-