replace : iotivity -> iotivity-sec

[platform/upstream/iotivity.git] / service / resource-encapsulation / src / resourceClient / RCSDiscoveryManagerImpl.cpp

diff --git a/service/resource-encapsulation/src/resourceClient/RCSDiscoveryManagerImpl.cpp b/service/resource-encapsulation/src/resourceClient/RCSDiscoveryManagerImpl.cpp
index 6ed5e90..319c9b8 100755 (executable)
--- a/service/resource-encapsulation/src/resourceClient/RCSDiscoveryManagerImpl.cpp
+++ b/service/resource-encapsulation/src/resourceClient/RCSDiscoveryManagerImpl.cpp
@@ -34,6 +34,19 @@ namespace
     {
         return resource->getSid() + resource->getUri();
     }
+
+    void validateTypes(const std::vector< std::string >& resourceTypes) {
+        if (resourceTypes.size() == 1) return;
+
+        for (const auto& type : resourceTypes)
+        {
+            if (type == OIC::Service::RCSDiscoveryManagerImpl::ALL_RESOURCE_TYPE)
+            {
+                throw OIC::Service::RCSBadRequestException{
+                    "resource types must have no empty string!" };
+            }
+        }
+    }
 }
 
 namespace OIC
@@ -41,12 +54,14 @@ namespace OIC
     namespace Service
     {
         constexpr RCSDiscoveryManagerImpl::ID RCSDiscoveryManagerImpl::INVALID_ID;
+        constexpr char const* RCSDiscoveryManagerImpl::ALL_RESOURCE_TYPE;
 
         RCSDiscoveryManagerImpl::RCSDiscoveryManagerImpl()
         {
-            subscribePresenceWithMuticast();
+            subscribePresenceWithMulticast();
 
-            m_timer.post(POLLING_INTERVAL_TIME, std::bind(&RCSDiscoveryManagerImpl::onPolling, this));
+            m_timer.post(POLLING_INTERVAL_TIME,
+                    std::bind(&RCSDiscoveryManagerImpl::onPolling, this));
         }
 
         RCSDiscoveryManagerImpl* RCSDiscoveryManagerImpl::getInstance()
@@ -55,11 +70,12 @@ namespace OIC
             return &instance;
         }
 
-        void RCSDiscoveryManagerImpl::onResourceFound(std::shared_ptr<PrimitiveResource> resource,
-                ID discoveryId, const RCSDiscoveryManager::ResourceDiscoveredCallback& discoverCB)
+        void RCSDiscoveryManagerImpl::onResourceFound(
+                std::shared_ptr< PrimitiveResource > resource, ID discoveryId,
+                const RCSDiscoveryManager::ResourceDiscoveredCallback& discoverCB)
         {
             {
-                std::lock_guard< std::mutex > lock(m_mutex);
+                std::lock_guard < std::mutex > lock(m_mutex);
                 auto it = m_discoveryMap.find(discoveryId);
 
                 if (it == m_discoveryMap.end()) return;
@@ -67,27 +83,31 @@ namespace OIC
 
                 it->second.addKnownResource(resource);
             }
-            discoverCB(std::make_shared< RCSRemoteResourceObject > (resource));
+            discoverCB(std::make_shared < RCSRemoteResourceObject > (resource));
         }
 
         RCSDiscoveryManager::DiscoveryTask::Ptr RCSDiscoveryManagerImpl::startDiscovery(
                 const RCSAddress& address, const std::string& relativeUri,
-                const std::string& resourceType, RCSDiscoveryManager::ResourceDiscoveredCallback cb)
+                const std::vector< std::string >& resourceTypes,
+                RCSDiscoveryManager::ResourceDiscoveredCallback cb)
         {
             if (!cb)
             {
                 throw RCSInvalidParameterException{ "Callback is empty" };
             }
 
+            validateTypes(resourceTypes);
+
             const ID discoveryId = createId();
 
-            DiscoveryRequestInfo discoveryInfo(address, relativeUri, resourceType,
+            DiscoveryRequestInfo discoveryInfo(address, relativeUri, resourceTypes,
                     std::bind(&RCSDiscoveryManagerImpl::onResourceFound, this,
                             std::placeholders::_1, discoveryId, std::move(cb)));
+
             discoveryInfo.discover();
 
             {
-                std::lock_guard< std::mutex > lock(m_mutex);
+                std::lock_guard < std::mutex > lock(m_mutex);
                 m_discoveryMap.insert(std::make_pair(discoveryId, std::move(discoveryInfo)));
             }
 
@@ -95,7 +115,7 @@ namespace OIC
                     new RCSDiscoveryManager::DiscoveryTask(discoveryId));
         }
 
-        void RCSDiscoveryManagerImpl::subscribePresenceWithMuticast()
+        void RCSDiscoveryManagerImpl::subscribePresenceWithMulticast()
         {
             using namespace std::placeholders;
 
@@ -110,14 +130,15 @@ namespace OIC
         void RCSDiscoveryManagerImpl::onPolling()
         {
             {
-                std::lock_guard< std::mutex > lock(m_mutex);
+                std::lock_guard < std::mutex > lock(m_mutex);
 
                 for (const auto& it : m_discoveryMap)
                 {
                     it.second.discover();
                 }
             }
-            m_timer.post(POLLING_INTERVAL_TIME, std::bind(&RCSDiscoveryManagerImpl::onPolling, this));
+            m_timer.post(POLLING_INTERVAL_TIME,
+                    std::bind(&RCSDiscoveryManagerImpl::onPolling, this));
         }
 
         void RCSDiscoveryManagerImpl::onPresence(OCStackResult result, const unsigned int /*seq*/,
@@ -125,7 +146,7 @@ namespace OIC
         {
             if (result != OC_STACK_OK && result != OC_STACK_RESOURCE_CREATED) return;
 
-            std::lock_guard< std::mutex > lock(m_mutex);
+            std::lock_guard < std::mutex > lock(m_mutex);
             for (const auto& it : m_discoveryMap)
             {
                 if (it.second.isMatchedAddress(address))
@@ -139,7 +160,7 @@ namespace OIC
         {
             static ID s_nextId = INVALID_ID + 1;
 
-            std::lock_guard< std::mutex > lock(m_mutex);
+            std::lock_guard < std::mutex > lock(m_mutex);
 
             while (s_nextId == INVALID_ID || m_discoveryMap.find(s_nextId) != m_discoveryMap.end())
             {
@@ -153,24 +174,36 @@ namespace OIC
 
         void RCSDiscoveryManagerImpl::cancel(ID id)
         {
-            std::lock_guard< std::mutex > lock(m_mutex);
+            std::lock_guard < std::mutex > lock(m_mutex);
             m_discoveryMap.erase(id);
         }
 
         DiscoveryRequestInfo::DiscoveryRequestInfo(const RCSAddress& address,
-                const std::string& relativeUri, const std::string& resourceType,
+                const std::string& relativeUri, const std::vector< std::string >& resourceTypes,
                 DiscoverCallback cb) :
                 m_address{ address },
                 m_relativeUri{ relativeUri },
-                m_resourceType{ resourceType },
+                m_resourceTypes{ resourceTypes },
                 m_knownResourceIds{ },
                 m_discoverCb{ std::move(cb) }
         {
+            if (m_resourceTypes.empty())
+            {
+                m_resourceTypes.push_back(RCSDiscoveryManagerImpl::ALL_RESOURCE_TYPE);
+            }
         }
 
         void DiscoveryRequestInfo::discover() const
         {
-            discoverResource(m_address, m_relativeUri + "?rt=" + m_resourceType, m_discoverCb);
+            for (const auto& it : m_resourceTypes)
+            {
+                std::string uri = std::string(OC_RSRVD_WELL_KNOWN_URI);
+                if (!it.empty())
+                {
+                    uri = std::string(OC_RSRVD_WELL_KNOWN_URI) + "?rt=" + it;
+                }
+                discoverResource(m_address, uri, m_discoverCb);
+            }
         }
 
         bool DiscoveryRequestInfo::isKnownResource(
@@ -187,8 +220,8 @@ namespace OIC
 
         bool DiscoveryRequestInfo::isMatchedAddress(const std::string& address) const
         {
-            return RCSAddressDetail::getDetail(m_address)->isMulticast() ||
-                    RCSAddressDetail::getDetail(m_address)->getAddress() == address;
+            return RCSAddressDetail::getDetail(m_address)->isMulticast()
+                    || RCSAddressDetail::getDetail(m_address)->getAddress() == address;
         }
     }
 }