modify scene manager(remote) for exception handling

- add exception handling for callback null check
- add mutex for name of scenelist, scenecollection
- remove unused code

Change-Id: Ib2c1c260cc9efc8372393dd08331be435d2c5c7e
Signed-off-by: Minji Park <minjii.park@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/5309
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>

diff --git a/service/scene-manager/include/RemoteScene.h b/service/scene-manager/include/RemoteScene.h
index 93a87ca..95b2e2f 100644 (file)
--- a/service/scene-manager/include/RemoteScene.h
+++ b/service/scene-manager/include/RemoteScene.h
@@ -78,12 +78,12 @@ namespace OIC
                 RemoteScene(
                     const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor >);
 
-                RemoteSceneAction::Ptr createRemoteSceneActionInstance(
+                RemoteSceneAction::Ptr createRemoteSceneAction(
                     const std::string &,  const RCSResourceAttributes &);
 
                 void addExistingRemoteSceneAction(const std::string &, const std::string &,
-                                                  const std::string &, const std::string &key,
-                                                  const RCSResourceAttributes::Value &);
+                    RCSRemoteResourceObject::Ptr, const std::string &key,
+                    const RCSResourceAttributes::Value &);
 
                 void onSceneActionAdded(
                     int, RCSRemoteResourceObject::Ptr,

diff --git a/service/scene-manager/include/RemoteSceneAction.h b/service/scene-manager/include/RemoteSceneAction.h
index 9f1dde2..8372cbb 100644 (file)
--- a/service/scene-manager/include/RemoteSceneAction.h
+++ b/service/scene-manager/include/RemoteSceneAction.h
@@ -39,14 +39,15 @@ namespace OIC
             public:
                 typedef std::shared_ptr< RemoteSceneAction > Ptr;
 
-                typedef std::function< void(int eCode) > UpdateCallback;
+                typedef std::function< void(int eCode) > setExecutionParameterCallback;
 
             public:
                 ~RemoteSceneAction() = default;
 
                 void setExecutionParameter(const std::string &key,
-                    const RCSResourceAttributes::Value &value, UpdateCallback);
-                void setExecutionParameter(const RCSResourceAttributes &attr, UpdateCallback);
+                    const RCSResourceAttributes::Value &value, setExecutionParameterCallback);
+                void setExecutionParameter(
+                    const RCSResourceAttributes &attr, setExecutionParameterCallback);
 
                 RCSResourceAttributes getExecutionParameter() const;
 
@@ -59,11 +60,12 @@ namespace OIC
                                   const std::string &sceneName,
                                   const std::string &key, const RCSResourceAttributes::Value &);
 
-                void onUpdated(int, const RCSResourceAttributes &, const UpdateCallback &);
+                void onExecutionParameterSet(int, const RCSResourceAttributes &,
+                    const setExecutionParameterCallback &);
 
             private:
                 std::string m_sceneName;
-                std::mutex m_attributeLock;
+                mutable std::mutex m_attributeLock;
                 RCSResourceAttributes m_attributes;
                 std::shared_ptr< SceneMemberResourceRequestor > m_requestor;
 

diff --git a/service/scene-manager/include/RemoteSceneCollection.h b/service/scene-manager/include/RemoteSceneCollection.h
index f4b7436..b0f86ba 100644 (file)
--- a/service/scene-manager/include/RemoteSceneCollection.h
+++ b/service/scene-manager/include/RemoteSceneCollection.h
@@ -73,7 +73,7 @@ namespace OIC
                 void initializeRemoteScenes(const std::vector< RCSResourceAttributes > &,
                                                      const std::string &);
 
-                RemoteScene::Ptr createRemoteSceneInstance(const std::string &);
+                RemoteScene::Ptr createRemoteScene(const std::string &);
 
                 void onSceneAddedRemoved(int, const std::string &name, int,
                                          const AddNewSceneCallback &, const RemoveSceneCallback &);
@@ -83,6 +83,7 @@ namespace OIC
             private:
                 std::string m_id;
                 std::string m_name;
+                mutable std::mutex m_nameLock;
                 mutable std::mutex m_sceneLock;
                 std::unordered_map< std::string, RemoteScene::Ptr > m_remoteScenes;
                 std::shared_ptr< SceneCollectionResourceRequestor > m_requestor;

diff --git a/service/scene-manager/include/RemoteSceneList.h b/service/scene-manager/include/RemoteSceneList.h
index 398eb4f..d02ce33 100644 (file)
--- a/service/scene-manager/include/RemoteSceneList.h
+++ b/service/scene-manager/include/RemoteSceneList.h
@@ -65,47 +65,19 @@ namespace OIC
                 std::string getName() const;
 
             private:
-                class GetResponseHandler
-                {
-                    public:
-                        typedef std::shared_ptr< GetResponseHandler > Ptr;
-
-                        typedef std::function< void(int eCode) >
-                            GetCallback;
-
-                        GetResponseHandler(std::shared_ptr< RemoteSceneList >);
-                        ~GetResponseHandler() = default;
-
-                        int m_numOfCollections;
-                        int m_respondedCollections;
-                        int m_errorCode;
-                        std::weak_ptr< RemoteSceneList > m_owner;
-                        GetCallback m_cb;
-
-                        void startGetResponseHandler(const std::string &host, GetCallback cb);
-
-                        void onGetListAttrs(const RCSRepresentation &, int, const std::string &);
-                        
-                        void onGetCollectionAttrs(const RCSRepresentation &, int eCode,
-                            RemoteSceneCollection::Ptr, const std::string &);
-                };
-                
-            private:
                 RemoteSceneList(std::shared_ptr< SceneListResourceRequestor >);
 
                 static void onInstanceCreated(const RCSRepresentation &, int, const std::string &,
                     std::shared_ptr< SceneListResourceRequestor >, const CreateInstanceCallback &);
 
-                static RemoteSceneList::Ptr buildSceneList(std::shared_ptr< SceneListResourceRequestor >,
-                    const RCSResourceAttributes &);
+                static RemoteSceneList::Ptr buildSceneList(
+                    std::shared_ptr< SceneListResourceRequestor >, const RCSResourceAttributes &);
 
-                RemoteSceneCollection::Ptr createRemoteSceneCollectionInstance(
+                RemoteSceneCollection::Ptr createRemoteSceneCollection(
                     const std::string &link, const std::string &id, const std::string &name);
 
                 std::shared_ptr< SceneListResourceRequestor > getListResourceRequestor() const;
                 
-                void setGetResponseHandler(const std::string &, GetResponseHandler::GetCallback);
-
                 std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
                     parseSceneListFromAttributes(const RCSResourceAttributes &);
 
@@ -120,13 +92,10 @@ namespace OIC
 
             private:
                 std::string m_name;
-                std::mutex m_collectionLock;
                 std::vector< RemoteSceneCollection::Ptr > m_remoteSceneCollections;
+                mutable std::mutex m_nameLock;
+                mutable std::mutex m_collectionLock;
                 std::shared_ptr< SceneListResourceRequestor > m_requestorPtr;
-
-                GetResponseHandler::Ptr m_getResponseHandler;
-
-                friend class GetResponseHandler;
         };
 
     }

diff --git a/service/scene-manager/src/RemoteScene.cpp b/service/scene-manager/src/RemoteScene.cpp
index 03ddc9f..d5230b4 100644 (file)
--- a/service/scene-manager/src/RemoteScene.cpp
+++ b/service/scene-manager/src/RemoteScene.cpp
@@ -33,8 +33,8 @@ namespace OIC
     namespace Service
     {
 
-        RemoteScene::RemoteScene
-        (const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor > requestor)
+        RemoteScene::RemoteScene(
+            const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor > requestor)
             : m_name{ name }, m_requestor{ requestor }
         {
             assert(requestor);
@@ -52,6 +52,10 @@ namespace OIC
             {
                 throw RCSInvalidParameterException("RCSResourceAttributes is empty");
             }
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "addNewSceneAction : Callback is NULL" };
+            }
 
             SceneCollectionResourceRequestor::InternalAddMemberCallback internalCB
                 = std::bind(&RemoteScene::onSceneActionAdded, this,
@@ -74,6 +78,10 @@ namespace OIC
             {
                 throw RCSInvalidParameterException("Scene action key value is empty");
             }
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "addNewSceneAction : Callback is NULL" };
+            }
 
             RCSResourceAttributes attrs;
             attrs[key] = RCSResourceAttributes::Value(value);
@@ -132,6 +140,11 @@ namespace OIC
 
         void RemoteScene::execute(RemoteSceneExecuteCallback clientCB)
         {
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "execute : Callback is NULL" };
+            }
+
             SceneCollectionResourceRequestor::InternalSceneRequestCallback internalCB
                 = std::bind(&RemoteScene::onSceneExecuted, this, std::placeholders::_2,
                             std::placeholders::_3, std::move(clientCB));
@@ -139,8 +152,8 @@ namespace OIC
             m_requestor->requestSceneExecution(m_name, internalCB);
         }
 
-        RemoteSceneAction::Ptr RemoteScene::createRemoteSceneActionInstance
-        (const std::string &targetHref, const RCSResourceAttributes &attrs)
+        RemoteSceneAction::Ptr RemoteScene::createRemoteSceneAction(
+            const std::string &targetHref, const RCSResourceAttributes &attrs)
         {
             SceneMemberResourceRequestor::Ptr memRequestor
                 = m_requestor->getSceneMemberResourceRequestor(targetHref);
@@ -162,20 +175,21 @@ namespace OIC
         }
 
         void RemoteScene::addExistingRemoteSceneAction(
-            const std::string &href, const std::string &targetHref,
-            const std::string &id, const std::string &key,
-            const RCSResourceAttributes::Value &value)
+            const std::string &href, const std::string &id, RCSRemoteResourceObject::Ptr target,
+            const std::string &key, const RCSResourceAttributes::Value &value)
         {
+            std::string targetHref = target->getAddress() + target->getUri();
+            
             SceneMemberResourceRequestor::Ptr foundMemberRequestor
                 = m_requestor->getSceneMemberResourceRequestor(targetHref);
 
             if (foundMemberRequestor == nullptr)
-                m_requestor->createSceneMemberResourceRequestor(href, id, targetHref);
+                m_requestor->createSceneMemberResourceRequestor(href, id, target);
 
             RCSResourceAttributes attrs;
             attrs[key] = RCSResourceAttributes::Value(value);
 
-            createRemoteSceneActionInstance(targetHref, attrs);
+            createRemoteSceneAction(targetHref, attrs);
         }
 
         void RemoteScene::onSceneActionAdded(
@@ -189,7 +203,7 @@ namespace OIC
             {
                 std::string targetLink = target->getAddress() + target->getUri();
 
-                newAction = createRemoteSceneActionInstance(targetLink, attrs);
+                newAction = createRemoteSceneAction(targetLink, attrs);
 
                 if (newAction)
                     result = SCENE_RESPONSE_SUCCESS;

diff --git a/service/scene-manager/src/RemoteSceneAction.cpp b/service/scene-manager/src/RemoteSceneAction.cpp
index 780370d..8c7b5be 100644 (file)
--- a/service/scene-manager/src/RemoteSceneAction.cpp
+++ b/service/scene-manager/src/RemoteSceneAction.cpp
@@ -49,12 +49,16 @@ namespace OIC
 
         void RemoteSceneAction::setExecutionParameter(const std::string &key,
                                        const RCSResourceAttributes::Value &value,
-                                       UpdateCallback clientCB)
+                                       setExecutionParameterCallback clientCB)
         {
             if (key.empty())
             {
                 throw RCSInvalidParameterException("Scene action key value is empty");
             }
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "setExecutionParameter : Callback is NULL" };
+            }
 
             RCSResourceAttributes attr;
             attr[key] = RCSResourceAttributes::Value(value);
@@ -63,15 +67,19 @@ namespace OIC
         }
 
         void RemoteSceneAction::setExecutionParameter(const RCSResourceAttributes &attr,
-            UpdateCallback clientCB)
+            setExecutionParameterCallback clientCB)
         {
             if (attr.empty())
             {
                 throw RCSInvalidParameterException("RCSResourceAttributes is empty");
             }
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "setExecutionParameter : Callback is NULL" };
+            }
 
             SceneMemberResourceRequestor::InternalAddSceneActionCallback internalCB
-                = std::bind(&RemoteSceneAction::onUpdated, this,
+                = std::bind(&RemoteSceneAction::onExecutionParameterSet, this,
                 std::placeholders::_1, attr, std::move(clientCB));
 
             m_requestor->requestSceneActionCreation(
@@ -80,6 +88,7 @@ namespace OIC
 
         RCSResourceAttributes RemoteSceneAction::getExecutionParameter() const
         {
+            std::lock_guard< std::mutex > lock(m_attributeLock);
             return m_attributes;
         }
 
@@ -88,8 +97,8 @@ namespace OIC
             return m_requestor->getRemoteResourceObject();
         }
 
-        void RemoteSceneAction::onUpdated(int eCode, const RCSResourceAttributes &attr,
-                                          const UpdateCallback &clientCB)
+        void RemoteSceneAction::onExecutionParameterSet(int eCode, const RCSResourceAttributes &attr,
+            const setExecutionParameterCallback &clientCB)
         {
             int result = SCENE_CLIENT_BADREQUEST;
             if (eCode == SCENE_RESPONSE_SUCCESS)

diff --git a/service/scene-manager/src/RemoteSceneCollection.cpp b/service/scene-manager/src/RemoteSceneCollection.cpp
index 79642a0..0bb51b2 100644 (file)
--- a/service/scene-manager/src/RemoteSceneCollection.cpp
+++ b/service/scene-manager/src/RemoteSceneCollection.cpp
@@ -47,6 +47,10 @@ namespace OIC
             {
                 throw RCSInvalidParameterException("Scene name is an empty string");
             }
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "addNewScene : Callback is NULL" };
+            }
 
             SceneCollectionResourceRequestor::InternalSceneRequestCallback internalCB
                 = std::bind(&RemoteSceneCollection::onSceneAddedRemoved, this,
@@ -65,6 +69,7 @@ namespace OIC
         std::unordered_map< std::string, RemoteScene::Ptr >
             RemoteSceneCollection::getRemoteScenes() const
         {
+            std::lock_guard< std::mutex > scenelock(m_sceneLock);
             return m_remoteScenes;
         }
 
@@ -83,6 +88,11 @@ namespace OIC
 
         void RemoteSceneCollection::setName(const std::string &name, SetNameCallback clientCB)
         {
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "setName : Callback is NULL" };
+            }
+
             SceneCollectionResourceRequestor::InternalSetNameCallback internalCB
                 = std::bind(&RemoteSceneCollection::onNameSet, this,
                             std::placeholders::_1, name, std::move(clientCB));
@@ -92,6 +102,7 @@ namespace OIC
 
         std::string RemoteSceneCollection::getName() const
         {
+            std::lock_guard< std::mutex > lock(m_nameLock);
             return m_name;
         }
 
@@ -104,7 +115,7 @@ namespace OIC
         {
             for (const auto &scenename : scenes)
             {
-                createRemoteSceneInstance(scenename);
+                createRemoteScene(scenename);
             }
         }
 
@@ -113,34 +124,38 @@ namespace OIC
         {
             try
             {
-                for (const auto &itr : MemberReps)
+                for (const auto &attrs : MemberReps)
                 {
-                    RCSResourceAttributes attrs = itr;
-
                     for (const auto &mappingInfo :
                             attrs.at(SCENE_KEY_SCENEMAPPINGS).get
                                 <std::vector< RCSResourceAttributes > >())
                     {
                         std::string sceneName
                             = mappingInfo.at(SCENE_KEY_SCENE).get< std::string >();
-                        RemoteScene::Ptr pRemoteScene = nullptr;
 
                         auto remoteScene = m_remoteScenes.find(sceneName);
-                        if (remoteScene == m_remoteScenes.end()) return;
+                        if (remoteScene == m_remoteScenes.end()) continue;
+
+                        RemoteScene::Ptr pRemoteScene = m_remoteScenes.at(sceneName);
 
-                        pRemoteScene = m_remoteScenes.at(sceneName);
+                        RCSResourceAttributes targetLinkAttrs
+                            = attrs.at(SCENE_KEY_PAYLOAD_LINK).get< RCSResourceAttributes >();
 
-                        std::string targetHref
-                            = attrs.at(SCENE_KEY_PAYLOAD_LINK).get< RCSResourceAttributes >().
-                                at(SCENE_KEY_HREF).get< std::string >();
+                        RCSRemoteResourceObject::Ptr targetResource
+                            = SceneUtils::createRCSResourceObject(
+                            targetLinkAttrs.at(SCENE_KEY_HREF).get< std::string >(),
+                            SCENE_CONNECTIVITY,
+                            targetLinkAttrs.at(SCENE_KEY_RT).get< std::vector< std::string > >(),
+                            targetLinkAttrs.at(SCENE_KEY_IF).get< std::vector< std::string > >());
+                            
                         std::string mappingInfoKey
                             = mappingInfo.at(SCENE_KEY_MEMBERPROPERTY).get< std::string >();
                         RCSResourceAttributes::Value mappingInfoValue
                             = mappingInfo.at(SCENE_KEY_MEMBERVALUE);
 
                         pRemoteScene->addExistingRemoteSceneAction(
-                            host + attrs.at("uri").get< std::string >(),
-                            targetHref, attrs.at(SCENE_KEY_ID).get< std::string >(),
+                            host + attrs.at(SCENE_KEY_URI).get< std::string >(),
+                            attrs.at(SCENE_KEY_ID).get< std::string >(), targetResource,
                             mappingInfoKey, mappingInfoValue);
                     }
                 }
@@ -151,8 +166,7 @@ namespace OIC
             }
         }
 
-        RemoteScene::Ptr RemoteSceneCollection::createRemoteSceneInstance(
-            const std::string &name)
+        RemoteScene::Ptr RemoteSceneCollection::createRemoteScene(const std::string &name)
         {
             std::lock_guard< std::mutex > scenelock(m_sceneLock);
             RemoteScene::Ptr pNewRemoteScene(new RemoteScene(name, m_requestor));
@@ -172,7 +186,7 @@ namespace OIC
                 {
                     if (eCode == SCENE_RESPONSE_SUCCESS)
                     {
-                        addCB(createRemoteSceneInstance(name), SCENE_RESPONSE_SUCCESS);
+                        addCB(createRemoteScene(name), SCENE_RESPONSE_SUCCESS);
                     }
                     else
                     {
@@ -192,6 +206,7 @@ namespace OIC
             int result = SCENE_CLIENT_BADREQUEST;
             if (eCode == SCENE_RESPONSE_SUCCESS)
             {
+                std::lock_guard< std::mutex > lock(m_nameLock);
                 m_name = name;
                 result = SCENE_RESPONSE_SUCCESS;
             }

diff --git a/service/scene-manager/src/RemoteSceneList.cpp b/service/scene-manager/src/RemoteSceneList.cpp
index 54378d9..9778ed7 100644 (file)
--- a/service/scene-manager/src/RemoteSceneList.cpp
+++ b/service/scene-manager/src/RemoteSceneList.cpp
@@ -35,7 +35,7 @@ namespace OIC
     {
 
         RemoteSceneList::RemoteSceneList(SceneListResourceRequestor::Ptr requestor)
-            : m_requestorPtr{ requestor }, m_getResponseHandler{}
+            : m_requestorPtr{ requestor }
         {
 
         }
@@ -43,6 +43,11 @@ namespace OIC
         void RemoteSceneList::createInstance(RCSRemoteResourceObject::Ptr sceneListResource,
                                              CreateInstanceCallback clientCB)
         {
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "createInstance : Callback is NULL" };
+            }
+
             if (sceneListResource == nullptr)
             {
                 throw RCSInvalidParameterException("Scene List resource object is null");
@@ -68,6 +73,11 @@ namespace OIC
 
         void RemoteSceneList::addNewSceneCollection(AddNewSceneCollectionCallback clientCB)
         {
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "addNewSceneCollection : Callback is NULL" };
+            }
+
             SceneListResourceRequestor::InternalCreateSceneCollectionCallback internalCB
                 = std::bind(&RemoteSceneList::onSceneCollectionCreated, this,
                 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
@@ -84,11 +94,17 @@ namespace OIC
         std::vector< RemoteSceneCollection::Ptr >
             RemoteSceneList::getRemoteSceneCollections() const
         {
+            std::lock_guard< std::mutex > collectionlock(m_collectionLock);
             return m_remoteSceneCollections;
         }
 
         void RemoteSceneList::setName(const std::string &name, SetNameCallback clientCB)
         {
+            if (!clientCB)
+            {
+                throw RCSInvalidParameterException{ "setName : Callback is NULL" };
+            }
+
             SceneListResourceRequestor::InternalSetNameCallback internalCB
                 = std::bind(&RemoteSceneList::onNameSet, this,
                 std::placeholders::_1, name, std::move(clientCB));
@@ -98,6 +114,7 @@ namespace OIC
 
         std::string RemoteSceneList::getName() const
         {
+            std::lock_guard< std::mutex > lock(m_nameLock);
             return m_name;
         }
 
@@ -127,11 +144,12 @@ namespace OIC
             SceneListResourceRequestor::Ptr requestor, const RCSResourceAttributes &attrs)
         {
             RemoteSceneList::Ptr newList(new RemoteSceneList(requestor));
-
             auto collections = newList->parseSceneListFromAttributes(attrs);
 
             try
             {
+                newList->m_name = attrs.at(SCENE_KEY_NAME).get< std::string >();
+
                 for (const auto &itr : collections)
                 {
                     auto collection = itr.first;
@@ -139,7 +157,7 @@ namespace OIC
                                     ->getRemoteResourceObject()->getAddress();
 
                     RemoteSceneCollection::Ptr newCollection
-                        = newList->createRemoteSceneCollectionInstance(
+                        = newList->createRemoteSceneCollection(
                                     host + collection.at("uri").get< std::string >(),
                                     collection.at(SCENE_KEY_ID).get< std::string >(),
                                     collection.at(SCENE_KEY_NAME).get< std::string >());
@@ -158,7 +176,7 @@ namespace OIC
             return std::move(newList);
         }
 
-        RemoteSceneCollection::Ptr RemoteSceneList::createRemoteSceneCollectionInstance(
+        RemoteSceneCollection::Ptr RemoteSceneList::createRemoteSceneCollection(
             const std::string &link, const std::string &id, const std::string &name)
         {
             try
@@ -194,13 +212,6 @@ namespace OIC
             return m_requestorPtr;
         }
 
-        void RemoteSceneList::setGetResponseHandler(
-            const std::string &host, GetResponseHandler::GetCallback cb)
-        {
-            m_getResponseHandler.reset(new GetResponseHandler(shared_from_this()));
-            m_getResponseHandler->startGetResponseHandler(host, std::move(cb));
-        }
-
         std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
             RemoteSceneList::parseSceneListFromAttributes(const RCSResourceAttributes & listAttrs)
         {
@@ -246,7 +257,7 @@ namespace OIC
             if (eCode == SCENE_RESPONSE_SUCCESS)
             {
                 newCollection =
-                    createRemoteSceneCollectionInstance(link, id, name);
+                    createRemoteSceneCollection(link, id, name);
 
                 if (newCollection)
                     result = SCENE_RESPONSE_SUCCESS;
@@ -261,6 +272,7 @@ namespace OIC
             int result = SCENE_CLIENT_BADREQUEST;
             if (eCode == SCENE_RESPONSE_SUCCESS)
             {
+                std::lock_guard< std::mutex > lock(m_nameLock);
                 m_name = name;
                 result = SCENE_RESPONSE_SUCCESS;
             }
@@ -268,114 +280,5 @@ namespace OIC
             clientCB(result);
         }
 
-        RemoteSceneList::GetResponseHandler::GetResponseHandler(
-            std::shared_ptr< RemoteSceneList > ptr)
-                :m_numOfCollections{ 0 }, m_respondedCollections{ 0 },
-                    m_errorCode{ SCENE_RESPONSE_SUCCESS }, m_owner{ ptr }
-        {
-
-        }
-
-        void RemoteSceneList::GetResponseHandler::startGetResponseHandler(
-            const std::string &host, GetCallback cb)
-        {
-            RCSRemoteResourceObject::GetCallback ListGetCB
-                = std::bind(&GetResponseHandler::onGetListAttrs, this,
-                            std::placeholders::_2, std::placeholders::_3, host);
-
-            m_cb = cb;
-
-            std::shared_ptr< RemoteSceneList > list = m_owner.lock();
-
-            if (list)
-            {
-                list->getListResourceRequestor()
-                    ->requestGet(SCENE_CLIENT_CREATE_REQ_IF, ListGetCB);
-            }
-        }
-
-        void RemoteSceneList::GetResponseHandler::onGetListAttrs(
-            const RCSRepresentation &rep, int eCode, const std::string &host)
-        {
-            if (eCode == OC_STACK_OK)
-            {
-                std::shared_ptr< RemoteSceneList > list = m_owner.lock();
-
-                if (list == nullptr)
-                {
-                    SCENE_CLIENT_PRINT_LOG("remote scene list deleted.");
-                    return;
-                }
-
-                list->m_name
-                    = rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >();
-
-                std::vector< RCSRepresentation > childReps = rep.getChildren();
-
-                if (childReps.size() > 0)
-                {
-                    for (const auto &itr : childReps)
-                    {
-                        std::vector< std::string > childRTs = itr.getResourceTypes();
-                        if (std::find(childRTs.begin(), childRTs.end(), SCENE_COLLECTION_RT)
-                                != childRTs.end())
-                        {
-                            RCSResourceAttributes attrs = itr.getAttributes();
-                            RemoteSceneCollection::Ptr newCollection
-                                = list->createRemoteSceneCollectionInstance(
-                                            host + rep.getUri(),
-                                            attrs.at(SCENE_KEY_ID).get< std::string >(),
-                                            attrs.at(SCENE_KEY_NAME).get< std::string >());
-
-                            if (newCollection == nullptr) continue;
-
-                            RCSRemoteResourceObject::GetCallback handlerGetCB
-                                = std::bind(&GetResponseHandler::onGetCollectionAttrs,
-                                            this, std::placeholders::_2, std::placeholders::_3,
-                                            newCollection, host);
-
-                            newCollection->m_requestor
-                                ->requestGet(SCENE_CLIENT_REQ_IF, handlerGetCB);
-                        }
-                    }
-                }
-            }
-            else
-            {
-                // TODO error
-            }
-        }
-
-        void RemoteSceneList::GetResponseHandler::onGetCollectionAttrs(
-            const RCSRepresentation &reps, int eCode,
-            RemoteSceneCollection::Ptr collection, const std::string &host)
-        {
-            m_respondedCollections++;
-            if (eCode == OC_STACK_OK)
-            {
-                auto children = reps.getChildren();
-                std::vector< RCSResourceAttributes > childrenAttr;
-
-                std::for_each(children.begin(), children.end(),
-                    [&childrenAttr](const RCSRepresentation & rep)
-                {
-                    childrenAttr.push_back(rep.getAttributes());
-                });
-
-                collection->
-                    initializeRemoteScenes(childrenAttr, host);
-            }
-            else
-            {
-                // TODO error
-                m_errorCode = SCENE_CLIENT_BADREQUEST;
-            }
-
-            if (m_respondedCollections == m_numOfCollections)
-            {
-                m_cb(m_errorCode);
-            }
-        }
-
     }
 }
\ No newline at end of file

diff --git a/service/scene-manager/src/SceneCollectionResourceRequestor.cpp b/service/scene-manager/src/SceneCollectionResourceRequestor.cpp
index 418f2a4..f36d3bc 100644 (file)
--- a/service/scene-manager/src/SceneCollectionResourceRequestor.cpp
+++ b/service/scene-manager/src/SceneCollectionResourceRequestor.cpp
@@ -107,7 +107,7 @@ namespace OIC
             RCSRemoteResourceObject::SetCallback setRequestCB
                 = std::bind(&SceneCollectionResourceRequestor::onSceneMemberAdded,
                             std::placeholders::_2, std::placeholders::_3,
-                            targetResource->getAddress() + targetResource->getUri(),
+                            targetResource,
                             std::move(addMemberCB),
                             SceneCollectionResourceRequestor::wPtr(shared_from_this()));
 
@@ -152,7 +152,7 @@ namespace OIC
 
         SceneMemberResourceRequestor::Ptr
         SceneCollectionResourceRequestor::createSceneMemberResourceRequestor(
-            const std::string &memHref, const std::string &id, const std::string &targetHref)
+            const std::string &memHref, const std::string &id, RCSRemoteResourceObject::Ptr target)
         {
             try
             {
@@ -166,9 +166,11 @@ namespace OIC
                 SceneMemberResourceRequestor::Ptr pMemRequestor =
                     std::make_shared< SceneMemberResourceRequestor >(pResource, id);
 
+                pMemRequestor->setRemoteResourceObject(target);
+                
                 {
                     std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
-                    m_memberRequestors[targetHref] = pMemRequestor;
+                    m_memberRequestors[target->getAddress() + target->getUri()] = pMemRequestor;
                 }
 
                 return pMemRequestor;
@@ -259,7 +261,7 @@ namespace OIC
 
         void SceneCollectionResourceRequestor::onSceneMemberAdded(
             const RCSRepresentation &rep, int eCode,
-            const std::string &targetHref, const InternalAddMemberCallback &internalCB,
+            RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB,
             SceneCollectionResourceRequestor::wPtr ptr)
         {
             SceneCollectionResourceRequestor::Ptr collection = ptr.lock();
@@ -267,13 +269,13 @@ namespace OIC
             if (collection)
             {
                 collection->onSceneMemberAdded_impl(
-                    std::move(rep), eCode, targetHref, std::move(internalCB));
+                    std::move(rep), eCode, target, std::move(internalCB));
             }
         }
 
         void SceneCollectionResourceRequestor::onSceneMemberAdded_impl(
             const RCSRepresentation &rep, int eCode,
-            const std::string &targetHref, const InternalAddMemberCallback &internalCB)
+            RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB)
         {
             // TODO error code
             int result = SCENE_CLIENT_BADREQUEST;
@@ -288,10 +290,13 @@ namespace OIC
                     memRequestor
                         = createSceneMemberResourceRequestor(
                               receivedAttrs.at(SCENE_KEY_CREATEDLINK).get< std::string >(),
-                              receivedAttrs.at(SCENE_KEY_ID).get< std::string >(),
-                              targetHref);
+                              receivedAttrs.at(SCENE_KEY_ID).get< std::string >(), target);
 
-                    if (memRequestor) result = SCENE_RESPONSE_SUCCESS;
+                    if (memRequestor)
+                    {
+                        memRequestor->setRemoteResourceObject(target);
+                        result = SCENE_RESPONSE_SUCCESS;
+                    }
                 }
                 catch (const std::exception &e)
                 {

diff --git a/service/scene-manager/src/SceneCollectionResourceRequestor.h b/service/scene-manager/src/SceneCollectionResourceRequestor.h
index 080d47e..1975f80 100644 (file)
--- a/service/scene-manager/src/SceneCollectionResourceRequestor.h
+++ b/service/scene-manager/src/SceneCollectionResourceRequestor.h
@@ -76,7 +76,7 @@ namespace OIC
 
                 SceneMemberResourceRequestor::Ptr createSceneMemberResourceRequestor(
                     const std::string &memHref, const std::string &id,
-                    const std::string &targetHref);
+                    RCSRemoteResourceObject::Ptr target);
 
                 SceneMemberResourceRequestor::Ptr getSceneMemberResourceRequestor(
                     const std::string &targetHref) const;
@@ -94,12 +94,12 @@ namespace OIC
 
                 static void onSceneMemberAdded(
                     const RCSRepresentation &, int eCode,
-                    const std::string &, const InternalAddMemberCallback &,
+                    RCSRemoteResourceObject::Ptr, const InternalAddMemberCallback &,
                     SceneCollectionResourceRequestor::wPtr);
 
                 void onSceneMemberAdded_impl(
                     const RCSRepresentation &, int eCode,
-                    const std::string &, const InternalAddMemberCallback &);
+                    RCSRemoteResourceObject::Ptr, const InternalAddMemberCallback &);
 
                 static void onNameSet(const RCSRepresentation &, int eCode, const std::string &,
                     const InternalSetNameCallback &, SceneCollectionResourceRequestor::wPtr);

diff --git a/service/scene-manager/src/SceneMemberResourceRequestor.cpp b/service/scene-manager/src/SceneMemberResourceRequestor.cpp
index 70e9d84..eaad4b5 100644 (file)
--- a/service/scene-manager/src/SceneMemberResourceRequestor.cpp
+++ b/service/scene-manager/src/SceneMemberResourceRequestor.cpp
@@ -71,9 +71,15 @@ namespace OIC
             m_sceneMemberResource->get(params, cb);
         }
 
+        void SceneMemberResourceRequestor::setRemoteResourceObject(
+            RCSRemoteResourceObject::Ptr target)
+        {
+            m_remoteResource = target;
+        }
+
         RCSRemoteResourceObject::Ptr SceneMemberResourceRequestor::getRemoteResourceObject() const
         {
-            return m_sceneMemberResource;
+            return m_remoteResource;
         }
 
         void SceneMemberResourceRequestor::onSceneActionCreated(

diff --git a/service/scene-manager/src/SceneMemberResourceRequestor.h b/service/scene-manager/src/SceneMemberResourceRequestor.h
index b5224f3..76c1b5e 100644 (file)
--- a/service/scene-manager/src/SceneMemberResourceRequestor.h
+++ b/service/scene-manager/src/SceneMemberResourceRequestor.h
@@ -49,6 +49,8 @@ namespace OIC
 
                 void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
 
+                void setRemoteResourceObject(RCSRemoteResourceObject::Ptr);
+
                 RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
 
             private:
@@ -64,6 +66,7 @@ namespace OIC
 
             private:
                 std::string m_id;
+                RCSRemoteResourceObject::Ptr m_remoteResource;
                 RCSRemoteResourceObject::Ptr m_sceneMemberResource;
         };