Modified Scene Manager Local-side Interface

- SceneList / SceneCollection / Scene / SceneAction
- Add getScenes() Logic in Scene
- Some API name is changed in SceneAction

Change-Id: I00e1652f164119901688fd0e4210b6d10dd50366
Signed-off-by: ChaJiWon <jw_wonny.cha@samsung.com>
Signed-off-by: jyong2.kim <jyong2.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/5183
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>

diff --git a/service/scene-manager/include/Scene.h b/service/scene-manager/include/Scene.h
index 8433a05..8dd774c 100755 (executable)
--- a/service/scene-manager/include/Scene.h
+++ b/service/scene-manager/include/Scene.h
@@ -33,19 +33,18 @@ namespace OIC
         class Scene
         {
         public:
-//            class InvalidRemoteResourceObjectException: public RCSException
-//            {
-//            public:
-//                InvalidRemoteResourceObjectException(std::string&& what) :
-//                    RCSException{ std::move(what) } {}
-//            };
-
             class InvalidExecuteCallbackException: public RCSException
             {
             public:
                 InvalidExecuteCallbackException(std::string&& what) :
                     RCSException{ std::move(what) } {}
             };
+            class InvalidAddMemberRequestException: public RCSException
+            {
+            public:
+                InvalidAddMemberRequestException(std::string&& what) :
+                    RCSException{ std::move(what) } {}
+            };
 
             typedef std::shared_ptr< Scene > Ptr;
             typedef std::function< void(int) >  ExecuteCallback;
@@ -58,10 +57,11 @@ namespace OIC
         public:
             SceneAction::Ptr addNewSceneAction(const RCSRemoteResourceObject::Ptr&,
                     const RCSResourceAttributes&);
-            SceneAction::Ptr addNewSceneAction(const RCSRemoteResourceObject::Ptr&, const std::string&,
-                    const RCSResourceAttributes::Value&);
+            SceneAction::Ptr addNewSceneAction(const RCSRemoteResourceObject::Ptr&,
+                    const std::string&, const RCSResourceAttributes::Value&);
 
-            std::vector<SceneAction::Ptr> getSceneAction(const RCSRemoteResourceObject::Ptr&) const;
+            SceneAction::Ptr getSceneAction(
+                    const RCSRemoteResourceObject::Ptr&) const;
             std::vector<SceneAction::Ptr> getSceneActions() const ;
 
             std::string getName() const;

diff --git a/service/scene-manager/include/SceneAction.h b/service/scene-manager/include/SceneAction.h
index 772749a..a563a05 100755 (executable)
--- a/service/scene-manager/include/SceneAction.h
+++ b/service/scene-manager/include/SceneAction.h
@@ -24,8 +24,6 @@
 #include "RCSRemoteResourceObject.h"
 #include "RCSResourceAttributes.h"
 
-#include <memory>
-
 namespace OIC
 {
     namespace Service
@@ -45,17 +43,16 @@ namespace OIC
             friend class Scene;
 
         public:
-            void update(const std::string&, RCSResourceAttributes::Value);
-            void update(const RCSResourceAttributes&);
+            void setExecutionParameter(const std::string&, RCSResourceAttributes::Value);
+            void setExecutionParameter(const RCSResourceAttributes&);
 
-            const RCSResourceAttributes getAction();
+            const RCSResourceAttributes getExecutionParameter();
             RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
 
         private:
             RCSRemoteResourceObject::Ptr m_pRemoteResourceObject;
             std::string m_sceneName;
             std::shared_ptr< SceneMemberResource > m_sceneMemberResourceObj;
-            RCSResourceAttributes m_attr;
         };
     } /* namespace Service */
 } /* namespace OIC */

diff --git a/service/scene-manager/include/SceneCollection.h b/service/scene-manager/include/SceneCollection.h
index 217f296..e128c51 100755 (executable)
--- a/service/scene-manager/include/SceneCollection.h
+++ b/service/scene-manager/include/SceneCollection.h
@@ -22,8 +22,7 @@
 #define SM_SCENECOLLECTION_H_
 
 #include "Scene.h"
-#include <functional>
-#include <map>
+#include <unordered_map>
 
 namespace OIC
 {
@@ -48,7 +47,7 @@ namespace OIC
 
         public:
             Scene::Ptr addNewScene(const std::string&);
-            std::map< const std::string, Scene::Ptr > getScenes() const;
+            std::unordered_map< std::string, Scene::Ptr > getScenes() const;
             Scene::Ptr getScene(const std::string&) const;
 
             void removeScene(Scene::Ptr);
@@ -58,7 +57,6 @@ namespace OIC
             std::string getId() const;
 
         private:
-            std::map< const std::string, Scene::Ptr > m_scenes;
             std::shared_ptr< SceneCollectionResource > m_sceneCollectionResourceObj;
 
         };

diff --git a/service/scene-manager/include/SceneList.h b/service/scene-manager/include/SceneList.h
index 9789aaa..56898fe 100755 (executable)
--- a/service/scene-manager/include/SceneList.h
+++ b/service/scene-manager/include/SceneList.h
@@ -29,7 +29,7 @@ namespace OIC
 {
     namespace Service
     {
-        class SceneListResourceObject;
+        class SceneListResource;
         class SceneList
         {
         private:

diff --git a/service/scene-manager/sampleapp/linux/sceneserver.cpp b/service/scene-manager/sampleapp/linux/sceneserver.cpp
index 996d980..11d523e 100755 (executable)
--- a/service/scene-manager/sampleapp/linux/sceneserver.cpp
+++ b/service/scene-manager/sampleapp/linux/sceneserver.cpp
@@ -201,19 +201,19 @@ void getSceneAction()
     {
         std::cout << it.use_count() << std::endl;
         std::cout << it->getRemoteResourceObject()->getUri() << std::endl;
-        auto attr = it->getAction();
+        auto attr = it->getExecutionParameter();
         for(const auto &att : attr)
         {
             std::cout << att.key() << " : "  << att.value().toString() << std::endl;
         }
     }
-    auto sceneActions = g_scene->getSceneAction(g_foundResourceList.at(0));
-    g_sceneAction = sceneActions.at(0);
+
+    g_sceneAction = g_scene->getSceneAction(g_foundResourceList.at(0));
 }
 
 void updateSceneAction()
 {
-    g_sceneAction->update("power", "on");
+    g_sceneAction->setExecutionParameter("power", "on");
     executeScene();
 }
 

diff --git a/service/scene-manager/src/Scene.cpp b/service/scene-manager/src/Scene.cpp
index 51d413f..ecca8c3 100755 (executable)
--- a/service/scene-manager/src/Scene.cpp
+++ b/service/scene-manager/src/Scene.cpp
@@ -19,8 +19,9 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #include "Scene.h"
-#include <algorithm>
 #include "SceneCollectionResource.h"
+#include <iostream>
+#include <algorithm>
 
 namespace OIC
 {
@@ -36,7 +37,6 @@ namespace OIC
         {
             RCSResourceAttributes resAttr;
             resAttr[key] = RCSResourceAttributes::Value(value);
-
             return addNewSceneAction(RCSRemoteResourceObjectPtr, resAttr);
         }
 
@@ -50,71 +50,81 @@ namespace OIC
             }
 
             SceneMemberResource::Ptr sceneMemberResObj;
-            auto members = m_sceneCollectionResourceObj->getSceneMembers();
-            auto check = std::find_if(members.begin(), members.end(), [&RCSRemoteResourceObjectPtr] (
-                    const SceneMemberResource::Ptr it){
-                return it->getRemoteResourceObject() == RCSRemoteResourceObjectPtr;});
-
-            if(check != members.end())
+            sceneMemberResObj = SceneMemberResource::createSceneMemberResource(
+                    RCSRemoteResourceObjectPtr);
+            try
             {
-                sceneMemberResObj = *check;
+                m_sceneCollectionResourceObj->addSceneMember(sceneMemberResObj);
             }
-
-            else
+            catch(...)
             {
-                sceneMemberResObj = SceneMemberResource::createSceneMemberResource(
-                        RCSRemoteResourceObjectPtr);
-                m_sceneCollectionResourceObj->addSceneMember(sceneMemberResObj);
+                throw InvalidAddMemberRequestException("Already existed Member!");
             }
 
-            SceneAction::Ptr sceneActionPtr(new SceneAction(sceneMemberResObj, m_name, attr));
-            return sceneActionPtr;
+            return SceneAction::Ptr(new SceneAction(sceneMemberResObj, m_name, attr));
         }
-
-        std::vector< SceneAction::Ptr > Scene::getSceneAction( // need to confirm return type vector or Ptr
+//        TODO : need to confirm return type vector or Pointer
+        SceneAction::Ptr Scene::getSceneAction(
                 const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr) const
         {
-            std::vector<SceneAction::Ptr> actions;
             auto sceneMemberResObjs = m_sceneCollectionResourceObj->getSceneMembers();
-            for(const auto& member: sceneMemberResObjs)
-            {
-                if(member->getRemoteResourceObject() == RCSRemoteResourceObjectPtr)
-                {
-                    auto mappingInfo = member->getMappingInfo();
-                    for(const auto& it: mappingInfo)
+
+            RCSResourceAttributes actionParam;
+            SceneMemberResource::Ptr foundMember;
+
+            std::for_each (sceneMemberResObjs.begin(), sceneMemberResObjs.end(),
+                    [&, RCSRemoteResourceObjectPtr](
+                            const SceneMemberResource::Ptr& member)
                     {
-                        if(it.sceneName == m_name)
+                        if(RCSRemoteResourceObjectPtr == member->getRemoteResourceObject())
                         {
-                            SceneAction::Ptr sceneActionPtr(new SceneAction(
-                                    member, m_name, it.key, it.value));
-                            actions.push_back(sceneActionPtr);
+                            foundMember = member;
+                            for(const auto &it: member->getMappingInfo())
+                            {
+                                if(it.sceneName == m_name)
+                                {
+                                    actionParam[it.key] = it.value;
+                                }
+                            }
                         }
-                    }
-                }
+                    });
+
+            if(actionParam.empty())
+            {
+                throw RCSInvalidParameterException("Unknown Remote Resource!");
             }
-            return actions;
+
+            return SceneAction::Ptr(new SceneAction(foundMember, m_name, actionParam));
         }
 
-        std::vector< SceneAction::Ptr > Scene::getSceneActions() const
+        std::vector<SceneAction::Ptr> Scene::getSceneActions() const
         {
             std::vector<SceneAction::Ptr> actions;
             auto sceneMemberResObjs = m_sceneCollectionResourceObj->getSceneMembers();
-            for(const auto& member: sceneMemberResObjs)
-            {
-                auto mappingInfo = member->getMappingInfo();
-                for(const auto& it : mappingInfo)
-                {
-                    if(it.sceneName == m_name)
+
+            RCSResourceAttributes actionParam;
+
+            std::for_each (sceneMemberResObjs.begin(), sceneMemberResObjs.end(),
+                    [&](const SceneMemberResource::Ptr& member)
                     {
-                        SceneAction::Ptr sceneActionPtr(new SceneAction(
-                                member, m_name, it.key, it.value));
-//                        SceneAction::WeakPtr sceneActionWeakPtr(sceneActionPtr);
-                        actions.push_back(sceneActionPtr);
-                    }
-                }
-            }
+//                        actionParam = getActionParamofMappingInfo(mappingInfo);
+                        for(const auto &it: member->getMappingInfo())
+                        {
+                            if(it.sceneName == m_name)
+                            {
+                                actionParam[it.key] = it.value;
+                            }
+                        }
+                        if(!actionParam.empty())
+                        {
+                            actions.push_back(SceneAction::Ptr(
+                                    new SceneAction(member, m_name, actionParam)));
+                            actionParam.clear();
+                        }
+                    });
+
             return actions;
-        }
+         }
 
         std::string Scene::getName() const
         {
@@ -123,18 +133,40 @@ namespace OIC
 
         void Scene::removeSceneAction(const SceneAction::Ptr& sceneActionPtr)
         {
-//            TODO
+//            TODO : need to implement
         }
 
         void Scene::removeSceneAction(
                 const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr)
         {
-//            TODO
+//            TODO : : need to implement
         }
 
         void Scene::execute(ExecuteCallback cb)
         {
+            if(cb == nullptr)
+            {
+                throw RCSInvalidParameterException("Callback is empty!");
+            }
+
             m_sceneCollectionResourceObj->execute(m_name, cb);
         }
+
+//        RCSResourceAttributes Scene::getActionParamofMappingInfo(
+//                std::vector<SceneMemberResource::MappingInfo> mappingInfo)
+//        {
+//            RCSResourceAttributes actionParam;
+//
+//            std::for_each (mappingInfo.begin(), mappingInfo.end(),
+//                [& actionParam](const SCeneCollectionResource::MappingInfo & mInfo)
+//                {
+//                    if (mInfo.sceneName == m_name)
+//                    {
+//                        actionParam[mInfo.key] = mInfo.value;
+//                    }
+//                });
+//
+//            return actionParam;
+//        }
     } /* namespace Service */
 } /* namespace OIC */

diff --git a/service/scene-manager/src/SceneAction.cpp b/service/scene-manager/src/SceneAction.cpp
index 3a685d7..8fc78da 100755 (executable)
--- a/service/scene-manager/src/SceneAction.cpp
+++ b/service/scene-manager/src/SceneAction.cpp
@@ -19,7 +19,6 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #include "SceneAction.h"
-
 #include "SceneMemberResource.h"
 
 namespace OIC
@@ -49,14 +48,15 @@ namespace OIC
                                 SceneMemberResource::MappingInfo(m_sceneName, key, value));
         }
 
-        void SceneAction::update(const std::string& key,
+        void SceneAction::setExecutionParameter(const std::string& key,
                 RCSResourceAttributes::Value value)
         {
-            m_attr[key] = value;
-            update(m_attr);
+            RCSResourceAttributes attr;
+            attr[key] = value;
+            setExecutionParameter(attr);
         }
 
-        void SceneAction::update(const RCSResourceAttributes& attr)
+        void SceneAction::setExecutionParameter(const RCSResourceAttributes& attr)
         {
             for(const auto& it : attr)
             {
@@ -65,18 +65,17 @@ namespace OIC
             }
         }
 
-        const RCSResourceAttributes SceneAction::getAction()
+        const RCSResourceAttributes SceneAction::getExecutionParameter()
         {
-            m_attr.clear();
-            auto mappingInfo = m_sceneMemberResourceObj->getMappingInfo();
-            for(const auto& it : mappingInfo)
+            RCSResourceAttributes attr;
+            for(const auto& it : m_sceneMemberResourceObj->getMappingInfo())
             {
                 if(it.sceneName == m_sceneName)
                 {
-                    m_attr[it.key] = RCSResourceAttributes::Value(it.value);
+                    attr[it.key] = RCSResourceAttributes::Value(it.value);
                 }
             }
-            return m_attr;
+            return attr;
         }
 
         RCSRemoteResourceObject::Ptr SceneAction::getRemoteResourceObject() const

diff --git a/service/scene-manager/src/SceneCollection.cpp b/service/scene-manager/src/SceneCollection.cpp
index df94244..3b6c3ae 100755 (executable)
--- a/service/scene-manager/src/SceneCollection.cpp
+++ b/service/scene-manager/src/SceneCollection.cpp
@@ -19,8 +19,6 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #include "SceneCollection.h"
-#include "octypes.h"
-#include "ocrandom.h"
 #include "SceneCollectionResource.h"
 
 namespace OIC
@@ -39,37 +37,36 @@ namespace OIC
             }
 
             m_sceneCollectionResourceObj->addScene(sceneName);
-
-            for (const auto& it : m_scenes)
-            {
-                if (it.first.compare(sceneName) == 0)
-                {
-                    return it.second;
-                }
-            }
-
-            Scene::Ptr scenePtr(new Scene(sceneName, m_sceneCollectionResourceObj));
-            m_scenes.insert(std::pair<const std::string, Scene::Ptr>(sceneName, scenePtr));
-
-            return scenePtr;
+            return Scene::Ptr(new Scene(sceneName, m_sceneCollectionResourceObj));
         }
 
-        std::map< const std::string, Scene::Ptr > SceneCollection::getScenes() const
+        std::unordered_map< std::string, Scene::Ptr > SceneCollection::getScenes() const
         {
-            return m_scenes;
+            std::unordered_map< std::string, Scene::Ptr > scenes;
+            auto sceneValues = m_sceneCollectionResourceObj->getSceneValues();
+
+            for(const auto &it : sceneValues)
+            {
+                Scene::Ptr scenePtr(new Scene(it, m_sceneCollectionResourceObj));
+                scenes.insert(std::pair< std::string, Scene::Ptr >(it, scenePtr));
+            }
+            return scenes;
         }
 
         Scene::Ptr SceneCollection::getScene(const std::string& sceneName) const
         {
-            auto it = m_scenes.find(sceneName);
-            if (it != m_scenes.end())
+            auto sceneValues = m_sceneCollectionResourceObj->getSceneValues();
+            auto it = std::find(sceneValues.begin(), sceneValues.end(), sceneName);
+            if(it != sceneValues.end())
             {
-                return it->second;
+                throw RCSInvalidParameterException("Scene Name is Invalid!");
             }
+            return Scene::Ptr(new Scene(sceneName, m_sceneCollectionResourceObj));
         }
 
         void SceneCollection::removeScene(Scene::Ptr scenePtr)
         {
+//            TODO : : need to implement
             if (scenePtr == nullptr)
             {
                 throw RCSInvalidParameterException("Scene Ptr is empty!");

diff --git a/service/scene-manager/src/SceneList.cpp b/service/scene-manager/src/SceneList.cpp
index 8329858..b99d3c5 100755 (executable)
--- a/service/scene-manager/src/SceneList.cpp
+++ b/service/scene-manager/src/SceneList.cpp
@@ -19,11 +19,12 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #include "SceneList.h"
+#include "SceneListResource.h"
+#include "SceneCollectionResource.h"
+
 #include "RCSRequest.h"
 #include "PrimitiveResource.h"
 #include "OCPlatform.h"
-#include "SceneCollectionResource.h"
-#include "SceneListResource.h"
 
 namespace OIC
 {
@@ -41,8 +42,7 @@ namespace OIC
                     SceneCollectionResource::createSceneCollectionObject();
             SceneListResource::getInstance()->addSceneCollectionResource(sceneCollectionResObj);
 
-            SceneCollection::Ptr sceneCollectionPtr(new SceneCollection(sceneCollectionResObj));
-            return sceneCollectionPtr;
+            return SceneCollection::Ptr(new SceneCollection(sceneCollectionResObj));
         }
 
         std::vector< SceneCollection::Ptr > SceneList::getSceneCollections() const
@@ -59,12 +59,12 @@ namespace OIC
 
         void SceneList::removeSceneCollection(SceneCollection::Ptr sceneCollectionPtr)
         {
-//            TODO : remove logic
-//            if (sceneCollectionPtr == nullptr)
-//            {
-//                throw RCSInvalidParameterException
-//                { "Scene Collection Ptr is empty!" };
-//            }
+//            TODO : need to implement
+            if (sceneCollectionPtr == nullptr)
+            {
+                throw RCSInvalidParameterException
+                { "Scene Collection Ptr is empty!" };
+            }
         }
 
         void SceneList::setName(const std::string& sceneListName)