SCENE_SRC_DIR = './src/'
scenemanager_src = [
SCENE_SRC_DIR + 'SceneCollection.cpp',
- SCENE_SRC_DIR + 'SceneMemberObject.cpp',
SCENE_SRC_DIR + 'SceneAction.cpp',
SCENE_SRC_DIR + 'Scene.cpp',
SCENE_SRC_DIR + 'SceneList.cpp',
#ifndef SM_SCENE_H_
#define SM_SCENE_H_
-#include "RCSRemoteResourceObject.h"
-#include "RCSResourceObject.h"
#include "SceneAction.h"
#include <vector>
-#include <memory>
namespace OIC
{
namespace Service
{
+ class SceneCollectionResourceObject;
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) } {}
+ };
+
typedef std::shared_ptr< Scene > Ptr;
- typedef std::function< void(const RCSResourceAttributes&, int) > ExecuteCallback;
- public:
- Scene (const std::string&);
- Scene(const std::string&, ExecuteCallback);
- ~Scene();
+ typedef std::function< void(int) > ExecuteCallback;
- bool addSceneAction(const std::shared_ptr< SceneAction >&);
- bool removeSceneAction(const std::shared_ptr< SceneAction >&);
+ private:
+ Scene(const Scene&) = default;
+ Scene(const std::string&, std::shared_ptr<SceneCollectionResourceObject>);
+ friend class SceneCollection;
- bool execute();
+ public:
+ SceneAction::Ptr addNewSceneAction(const RCSRemoteResourceObject::Ptr&,
+ const RCSResourceAttributes&);
+ SceneAction::Ptr addNewSceneAction(const RCSRemoteResourceObject::Ptr&, const std::string&,
+ const RCSResourceAttributes::Value&);
- void setCallback(ExecuteCallback);
+ std::vector<SceneAction::Ptr> getSceneAction(const RCSRemoteResourceObject::Ptr&) const;
+ std::vector<SceneAction::Ptr> getSceneActions() const ;
std::string getName() const;
- void setName(const std::string);
- private:
- void onSceneActionExecuteResult(const RCSResourceAttributes& attributes, int);
+ void removeSceneAction(const SceneAction::Ptr&);
+ void removeSceneAction(const RCSRemoteResourceObject::Ptr&);
+
+ void execute(ExecuteCallback);
private:
- std::string m_sceneName;
- std::vector< std::shared_ptr< SceneAction > > m_sceneActionList;
- ExecuteCallback m_callback;
- };
+ std::string m_name;
+ std::shared_ptr< SceneCollectionResourceObject > m_sceneCollectionResourceObj;
+ };
} /* namespace Service */
} /* namespace OIC */
-
-#endif /* RH_HOSTINGOBJECT_H_ */
+#endif /* SM_SCENE_H_ */
#ifndef SM_SCENEACTION_H_
#define SM_SCENEACTION_H_
-#include "SceneMemberObject.h"
+#include "RCSRemoteResourceObject.h"
+#include "RCSResourceAttributes.h"
+
+#include <memory>
namespace OIC
{
namespace Service
{
+ class SceneMemberResourceObject;
class SceneAction
{
public:
typedef std::shared_ptr< SceneAction > Ptr;
- typedef std::function< void(const RCSResourceAttributes&, int) > ExecuteCallback;
- public:
- SceneAction(const SceneMemberObject::Ptr&, const std::string&,
+ private:
+ SceneAction(const std::shared_ptr< SceneMemberResourceObject >,
+ const std::string&, const RCSResourceAttributes&);
+ SceneAction(const std::shared_ptr< SceneMemberResourceObject >,
+ const std::string&, const std::string&,
const RCSResourceAttributes::Value&);
+ friend class Scene;
- bool execute();
+ public:
+ void update(const std::string&, RCSResourceAttributes::Value);
+ void update(const RCSResourceAttributes&);
- void setCallback(ExecuteCallback);
+ const RCSResourceAttributes getAction();
+ RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
private:
+ RCSRemoteResourceObject::Ptr m_pRemoteResourceObject;
+ std::string m_sceneName;
+ std::shared_ptr< SceneMemberResourceObject > m_sceneMemberResourceObj;
RCSResourceAttributes m_attr;
- SceneMemberObject::Ptr m_sceneMemberPtr;
- ExecuteCallback m_callback;
};
} /* namespace Service */
} /* namespace OIC */
-
#endif /* SM_SCENEACTION_H_ */
-
#ifndef SM_SCENECOLLECTION_H_
#define SM_SCENECOLLECTION_H_
-#include <functional>
-#include <memory>
-
-#include "RCSResourceObject.h"
-#include "RCSRemoteResourceObject.h"
-#include "SceneMemberObject.h"
#include "Scene.h"
+#include <functional>
+#include <map>
namespace OIC
{
namespace Service
{
- class Scene;
+ class SceneCollectionResourceObject;
class SceneCollection
{
public:
+ class InvalidSceneNameException: public RCSException
+ {
+ public:
+ InvalidSceneNameException(std::string&& what) :
+ RCSException{ std::move(what) } {}
+ };
+
typedef std::shared_ptr< SceneCollection > Ptr;
+ private:
+ SceneCollection(const std::shared_ptr< SceneCollectionResourceObject >&);
+ friend class SceneList;
+
public:
- SceneCollection();
+ Scene::Ptr addNewScene(const std::string&);
+ std::map< const std::string, Scene::Ptr > getScenes() const;
+ Scene::Ptr getScene(const std::string&) const;
+
+ void removeScene(Scene::Ptr);
void setName(const std::string&);
std::string getName() const;
-
- std::string getUri() const;
std::string getId() const;
- Scene::Ptr addScene(const std::string&);
- const std::vector< Scene::Ptr >& getSceneList();
- bool removeScene(const Scene::Ptr&);
-
- SceneMemberObject::Ptr addSceneMember(const RCSRemoteResourceObject::Ptr&);
- const std::vector< SceneMemberObject::Ptr >& getSceneMemberList();
- bool removeSceneMember(SceneMemberObject::Ptr);
-
private:
- RCSSetResponse setRequestHandler(const RCSRequest&, RCSResourceAttributes&);
- RCSSetResponse createSceneRequestHandler(const RCSRequest&, RCSResourceAttributes&);
- RCSSetResponse executeSceneRequestHandler(const RCSRequest&, RCSResourceAttributes&);
- RCSSetResponse createSceneMemberRequestHandler(const RCSRequest&,
- RCSResourceAttributes&);
-
- private:
- std::string m_Id;
- std::string m_Uri;
-
- std::vector< Scene::Ptr > m_SceneList;
- std::vector< SceneMemberObject::Ptr > m_SceneMemberObjectList;
+ std::map< const std::string, Scene::Ptr > m_scenes;
+ std::shared_ptr< SceneCollectionResourceObject > m_sceneCollectionResourceObj;
- RCSResourceObject::Ptr m_sceneCollectionResourcePtr;
};
} /* namespace Service */
} /* namespace OIC */
#ifndef SM_SCENELIST_H_
#define SM_SCENELIST_H_
-#include <SceneCollection.h>
+#include "SceneCollection.h"
#include <string>
-#include <memory>
namespace OIC
{
namespace Service
{
-// class RCSResourceObject;
- class RCSRemoteResourceObject;
-
+ class SceneListResourceObject;
class SceneList
{
- public:
- typedef std::shared_ptr< RCSRemoteResourceObject > RemoteObjectPtr;
-
private:
- SceneList();
~SceneList() = default;
public:
- static SceneList * getInstance();
- SceneCollection::Ptr createSceneCollection();
+ static SceneList* getInstance();
+ SceneCollection::Ptr addNewSceneCollection();
+ std::vector<SceneCollection::Ptr> getSceneCollections() const;
+ void removeSceneCollection(SceneCollection::Ptr);
void setName(const std::string&);
std::string getName() const;
# Source files and Targets
######################################################################
sceneserver = scenemanager_sample_env.Program('sceneserver', 'sceneserver.cpp')
+fanserver = scenemanager_sample_env.Program('fanserver', 'fanserver.cpp')
lightserver = scenemanager_sample_env.Program('lightserver', 'lightserver.cpp')
#groupclient = scenemanager_sample_env.Program('groupclient', 'groupclient.cpp')
--- /dev/null
+//******************************************************************
+//
+// Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
+// Copyright 2014 Samsung Electronics All Rights Reserved.
+//
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+///
+/// This sample provides steps to define an interface for a resource
+/// (properties and methods) and host this resource on the server.
+///
+
+#include <functional>
+
+#include <pthread.h>
+#include <mutex>
+#include <condition_variable>
+
+#include "OCPlatform.h"
+#include "OCApi.h"
+
+using namespace OC;
+using namespace std;
+namespace PH = std::placeholders;
+
+int gObservation = 0;
+void * ChangeLightRepresentation(void *param);
+void * handleSlowResponse(void *param, std::shared_ptr< OCResourceRequest > pRequest);
+
+// Specifies secure or non-secure
+// false: non-secure resource
+// true: secure resource
+bool isSecure = false;
+
+/// Specifies whether Entity handler is going to do slow response or not
+bool isSlowResponse = false;
+
+// Forward declaring the entityHandler
+
+/// This class represents a single resource named 'lightResource'. This resource has
+/// two simple properties named 'state' and 'power'
+
+class FanResource
+{
+
+public:
+ /// Access this property from a TB client
+ std::string m_speed;
+ std::string m_fanUri;
+ OCResourceHandle m_resourceHandle;
+ OCRepresentation m_fanRep;
+
+public:
+ /// Constructor
+ FanResource() :
+ m_speed("10"), m_fanUri("/a/fan"), m_resourceHandle(0)
+ {
+ // Initialize representation
+ m_fanRep.setUri(m_fanUri);
+
+ m_fanRep.setValue("speed", m_speed);
+ }
+
+ /* Note that this does not need to be a member function: for classes you do not have
+ access to, you can accomplish this with a free function: */
+
+ /// This function internally calls registerResource API.
+ void createResource()
+ {
+ std::string resourceURI = m_fanUri; //URI of the resource
+ std::string resourceTypeName = "core.fan"; //resource type name. In this case, it is light
+ std::string resourceInterface = DEFAULT_INTERFACE; // resource interface.
+
+ EntityHandler cb = std::bind(&FanResource::entityHandler, this, PH::_1);
+
+ // This will internally create and register the resource.
+ OCStackResult result = OCPlatform::registerResource(m_resourceHandle, resourceURI,
+ resourceTypeName, resourceInterface, cb, OC_DISCOVERABLE | OC_OBSERVABLE);
+
+ if (OC_STACK_OK != result)
+ {
+ cout << "Resource creation was unsuccessful\n";
+ }
+ else
+ {
+ cout << "Resource URI : " << resourceURI << endl;
+ cout << "\tResource Type Name : " << resourceTypeName << endl;
+ cout << "\tResource Interface : " << DEFAULT_INTERFACE << endl;
+ cout << "\tResource creation is successful with resource handle : " << m_resourceHandle
+ << endl;
+ }
+ }
+
+ OCResourceHandle getHandle()
+ {
+ return m_resourceHandle;
+ }
+
+ // Puts representation.
+ // Gets values from the representation and
+ // updates the internal state
+ void put(OCRepresentation& rep)
+ {
+ try
+ {
+ if (rep.getValue("speed", m_speed))
+ {
+ cout << "\t\t\t\t" << "speed: " << m_speed << endl;
+ }
+ else
+ {
+ cout << "\t\t\t\t" << "speed not found in the representation" << endl;
+ }
+ }
+ catch (exception& e)
+ {
+ cout << e.what() << endl;
+ }
+
+ }
+
+ // Post representation.
+ // Post can create new resource or simply act like put.
+ // Gets values from the representation and
+ // updates the internal state
+ OCRepresentation post(OCRepresentation& rep)
+ {
+ put(rep);
+ return get();
+ }
+
+ // gets the updated representation.
+ // Updates the representation with latest internal state before
+ // sending out.
+ OCRepresentation get()
+ {
+ m_fanRep.setValue("speed", m_speed);
+
+ return m_fanRep;
+ }
+
+ void addType(const std::string& type) const
+ {
+ OCStackResult result = OCPlatform::bindTypeToResource(m_resourceHandle, type);
+ if (OC_STACK_OK != result)
+ {
+ cout << "Binding TypeName to Resource was unsuccessful\n";
+ }
+ }
+
+ void addInterface(const std::string& interface) const
+ {
+ OCStackResult result = OCPlatform::bindInterfaceToResource(m_resourceHandle, interface);
+ if (OC_STACK_OK != result)
+ {
+ cout << "Binding TypeName to Resource was unsuccessful\n";
+ }
+ }
+
+private:
+// This is just a sample implementation of entity handler.
+// Entity handler can be implemented in several ways by the manufacturer
+ OCEntityHandlerResult entityHandler(std::shared_ptr< OCResourceRequest > request)
+ {
+ cout << "\tIn Server CPP entity handler:\n";
+ OCEntityHandlerResult ehResult = OC_EH_ERROR;
+ if (request)
+ {
+ // Get the request type and request flag
+ std::string requestType = request->getRequestType();
+ int requestFlag = request->getRequestHandlerFlag();
+
+ if (requestFlag & RequestHandlerFlag::RequestFlag)
+ {
+ cout << "\t\trequestFlag : Request\n";
+ auto pResponse = std::make_shared< OC::OCResourceResponse >();
+ pResponse->setRequestHandle(request->getRequestHandle());
+ pResponse->setResourceHandle(request->getResourceHandle());
+
+ // If the request type is GET
+ if (requestType == "GET")
+ {
+ cout << "\t\t\trequestType : GET\n";
+ if (isSlowResponse) // Slow response case
+ {
+ static int startedThread = 0;
+ if (!startedThread)
+ {
+ std::thread t(handleSlowResponse, (void *) this, request);
+ startedThread = 1;
+ t.detach();
+ }
+ ehResult = OC_EH_SLOW;
+ }
+ else // normal response case.
+ {
+ pResponse->setErrorCode(200);
+ pResponse->setResponseResult(OC_EH_OK);
+ pResponse->setResourceRepresentation(get());
+ if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
+ {
+ ehResult = OC_EH_OK;
+ }
+ }
+ }
+ else if (requestType == "PUT")
+ {
+ cout << "\t\t\trequestType : PUT\n";
+ OCRepresentation rep = request->getResourceRepresentation();
+
+ // Do related operations related to PUT request
+ // Update the lightResource
+ put(rep);
+ pResponse->setErrorCode(200);
+ pResponse->setResponseResult(OC_EH_OK);
+ pResponse->setResourceRepresentation(get());
+ if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
+ {
+ ehResult = OC_EH_OK;
+ }
+ }
+ else if (requestType == "POST")
+ {
+ cout << "\t\t\trequestType : POST\n";
+
+ OCRepresentation rep = request->getResourceRepresentation();
+
+ // Do related operations related to POST request
+ OCRepresentation rep_post = post(rep);
+ pResponse->setResourceRepresentation(rep_post);
+ pResponse->setErrorCode(200);
+ if (rep_post.hasAttribute("createduri"))
+ {
+ pResponse->setResponseResult(OC_EH_RESOURCE_CREATED);
+ pResponse->setNewResourceUri(
+ rep_post.getValue< std::string >("createduri"));
+ }
+
+ if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
+ {
+ ehResult = OC_EH_OK;
+ }
+ }
+ else if (requestType == "DELETE")
+ {
+ // DELETE request operations
+ }
+ }
+ }
+ else
+ {
+ std::cout << "Request invalid" << std::endl;
+ }
+
+ return ehResult;
+ }
+};
+
+void * handleSlowResponse(void *param, std::shared_ptr< OCResourceRequest > pRequest)
+{
+ // This function handles slow response case
+ FanResource* fanPtr = (FanResource*) param;
+ // Induce a case for slow response by using sleep
+ std::cout << "SLOW response" << std::endl;
+ sleep(10);
+
+ auto pResponse = std::make_shared< OC::OCResourceResponse >();
+ pResponse->setRequestHandle(pRequest->getRequestHandle());
+ pResponse->setResourceHandle(pRequest->getResourceHandle());
+ pResponse->setResourceRepresentation(fanPtr->get());
+ pResponse->setErrorCode(200);
+ pResponse->setResponseResult(OC_EH_OK);
+
+ // Set the slow response flag back to false
+ isSlowResponse = false;
+ OCPlatform::sendResponse(pResponse);
+ return NULL;
+}
+
+int main()
+{
+ // Create PlatformConfig object
+ PlatformConfig cfg
+ { OC::ServiceType::InProc, OC::ModeType::Server, "0.0.0.0",
+ // By setting to "0.0.0.0", it binds to all available interfaces
+ 0,// Uses randomly available port
+ OC::QualityOfService::LowQos };
+
+ OCPlatform::Configure(cfg);
+ try
+ {
+ // Create the instance of the resource class
+ // (in this case instance of class 'LightResource').
+ FanResource myFan;
+
+ // Invoke createResource function of class light.
+ myFan.createResource();
+
+ // A condition variable will free the mutex it is given, then do a non-
+ // intensive block until 'notify' is called on it. In this case, since we
+ // don't ever call cv.notify, this should be a non-processor intensive version
+ // of while(true);
+ std::mutex blocker;
+ std::condition_variable cv;
+ std::unique_lock < std::mutex > lock(blocker);
+ cv.wait(lock);
+ }
+ catch (OCException e)
+ {
+ //log(e.what());
+ }
+
+ // No explicit call to stop the platform.
+ // When OCPlatform::destructor is invoked, internally we do platform cleanup
+
+ return 0;
+}
#include "RCSDiscoveryManager.h"
#include "RCSRemoteResourceObject.h"
#include "RCSResourceAttributes.h"
+#include "RCSResourceObject.h"
#include "RCSAddress.h"
#include "SceneList.h"
using namespace OC;
using namespace OIC::Service;
-constexpr int CREATE_SCENE = 1;
-constexpr int EXECUTE_SCENE = 2;
+constexpr int CREATE_SCENE_LIST = 1;
+constexpr int CREATE_SCENE_COLLECTION = 2;
+constexpr int GET_SCENE_COLLECTIONS = 3;
+constexpr int CREATE_SCENE = 4;
+constexpr int GET_SCENE = 5;
+constexpr int EXECUTE_SCENE = 6;
+constexpr int GET_SCENE_ACTION = 7;
+constexpr int UPDATE_SCENE_ACTION = 8;
struct CloseApp {};
-const std::string resourceType = "core.light";
+const std::vector<std::string> resourceTypes{"core.light", "core.fan"};
const std::string relativetUri = OC_RSRVD_WELL_KNOWN_URI;
std::mutex mtx;
std::shared_ptr<RCSRemoteResourceObject> g_discoveredResources;
std::vector<RCSRemoteResourceObject::Ptr> g_foundResourceList;
-
std::vector<RCSResourceObject::Ptr> g_memberResourceList;
SceneCollection::Ptr g_sceneColObj;
Scene::Ptr g_scene;
-std::vector<SceneMemberObject::Ptr> g_sceneMemObj;
+SceneAction::Ptr g_sceneAction;
typedef std::function<void(std::shared_ptr<RCSRemoteResourceObject>)> DiscoveryCallback;
-typedef std::function<void (const RCSResourceAttributes&, int)> ExecuteCallback;
+typedef std::function<void (int)> ExecuteCallback;
-void onExecute(const RCSResourceAttributes& attrs, int /*Code*/)
+void onExecute(int /*Code*/)
{
std::cout << __func__ << std::endl;
}
{
std::cout << "Wait 2 seconds until discovered." << std::endl;
+
try
{
- RCSDiscoveryManager::getInstance()->discoverResourceByType(RCSAddress::multicast(),
- relativetUri, "core.light", &onResourceDiscovered);
+ RCSDiscoveryManager::getInstance()->discoverResourceByTypes(RCSAddress::multicast(),
+ relativetUri, resourceTypes, &onResourceDiscovered);
}
catch(const RCSPlatformException& e)
{
std::cout << e.what() << std::endl;
}
std::unique_lock<std::mutex> lck(mtx);
- cond.wait_for(lck, std::chrono::seconds(2));
+ cond.wait_for(lck, std::chrono::seconds(4));
return g_discoveredResources != nullptr;
}
-void createScene()
+void createSceneList()
+{
+ SceneList::getInstance()->setName("sceneList Name");
+ std::cout << SceneList::getInstance()->getName() << std::endl;
+}
+
+void createSceneCollection()
{
- if(g_foundResourceList.size() == 0)
+ g_sceneColObj = SceneList::getInstance()->addNewSceneCollection();
+ g_sceneColObj->setName("Living Room");
+ std::cout << "Created CollectionName : " << g_sceneColObj->getName() << std::endl;
+ std::cout << "Id : " << g_sceneColObj->getId() << std::endl;
+
+ g_sceneColObj = SceneList::getInstance()->addNewSceneCollection();
+ g_sceneColObj->setName("Kitchen");
+ std::cout << "Created CollectionName : " << g_sceneColObj->getName() << std::endl;
+ std::cout << "Id : " << g_sceneColObj->getId() << std::endl;
+}
+
+void getSceneCollection()
+{
+ auto sceneCollectionList = SceneList::getInstance()->getSceneCollections();
+ int i = 1;
+
+ for(const auto& it : sceneCollectionList)
{
- std::cout << "First, find a light resource" << std::endl;
- return ;
+ std::cout << i++ << "." << it->getName() << std::endl;
}
+}
- g_sceneColObj = SceneList::getInstance()->createSceneCollection();
+void createScene()
+{
+ g_scene = g_sceneColObj->addNewScene("Going Out");
+ g_scene->addNewSceneAction(g_foundResourceList.at(0), "power", "off");
+ g_scene->addNewSceneAction(g_foundResourceList.at(1), "speed", "10");
- g_scene = g_sceneColObj->addScene("allbulbsson");
- g_scene->setCallback(onExecute);
+ g_sceneColObj->addNewScene("Cooking");
- for(const auto &it : g_foundResourceList)
+ auto sceneList = g_sceneColObj->getScenes();
+ for(const auto &it : sceneList)
{
- g_sceneMemObj.push_back(g_sceneColObj->addSceneMember(it));
- g_scene->addSceneAction(std::make_shared< SceneAction >(g_sceneMemObj.at(0), "power", "off"));
+ std::cout << it.first << std::endl;
}
}
+void getScene()
+{
+ auto sceneList = g_sceneColObj->getScenes();
+ for(const auto &it : sceneList)
+ {
+ std::cout << it.first << std::endl;
+ }
+
+ g_scene = g_sceneColObj->getScene("Going Out");
+}
+
void executeScene()
{
- if(g_scene != nullptr)
- g_scene->execute();
+ g_scene->execute(onExecute);
+ std::cout << "execute scene!" << std::endl;
+}
+
+void getSceneAction()
+{
+ auto sceneActionList = g_scene->getSceneActions();
+ std::cout << g_scene->getName() << std::endl;
+ for(const auto &it : sceneActionList)
+ {
+ std::cout << it.use_count() << std::endl;
+ std::cout << it->getRemoteResourceObject()->getUri() << std::endl;
+ auto attr = it->getAction();
+ 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);
+}
+
+void updateSceneAction()
+{
+ g_sceneAction->update("power", "on");
+ executeScene();
}
int main()
try
{
std::cout << "========================================================\n";
- std::cout << CREATE_SCENE << ". Create a Scene \n";
- std::cout << EXECUTE_SCENE << ". Execute a Scene \n";
+ std::cout << CREATE_SCENE_LIST << ". Create a SceneList \n";
+ std::cout << CREATE_SCENE_COLLECTION << ". Create a SceneCollection \n";
+ std::cout << GET_SCENE_COLLECTIONS << ". Get SceneCollections \n";
+ std::cout << CREATE_SCENE << ". Create a Scene \n";
+ std::cout << GET_SCENE << ". Get a Scene \n";
+ std::cout << EXECUTE_SCENE << ". Execute Scene \n";
+ std::cout << GET_SCENE_ACTION << ". Get a SceneAction \n";
+ std::cout << UPDATE_SCENE_ACTION << ". Update SceneAction \n";
std::cout << "========================================================\n";
- command = processUserInput(CREATE_SCENE, EXECUTE_SCENE);
+ command = processUserInput(CREATE_SCENE_LIST, UPDATE_SCENE_ACTION);
switch(command)
{
- case CREATE_SCENE:
- createScene();
- break;
- case EXECUTE_SCENE:
- executeScene();
- break;
+ case CREATE_SCENE_LIST:
+ createSceneList();
+ break;
+ case CREATE_SCENE_COLLECTION:
+ createSceneCollection();
+ break;
+ case GET_SCENE_COLLECTIONS:
+ getSceneCollection();
+ break;
+ case CREATE_SCENE:
+ createScene();
+ break;
+ case GET_SCENE:
+ getScene();
+ break;
+ case EXECUTE_SCENE:
+ executeScene();
+ break;
+ case GET_SCENE_ACTION:
+ getSceneAction();
+ break;
+ case UPDATE_SCENE_ACTION:
+ updateSceneAction();
+ break;
}
}
catch (const std::exception& e)
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "Scene.h"
+#include "SceneCollectionResourceObject.h"
-#include <iostream>
+#include <algorithm>
namespace OIC
{
namespace Service
{
+ Scene::Scene(const std::string& sceneName,
+ SceneCollectionResourceObject::Ptr sceneCollectionResource) :
+ m_name(sceneName), m_sceneCollectionResourceObj(sceneCollectionResource) {}
- Scene::Scene(const std::string& sceneName, ExecuteCallback cb) :
- m_sceneName(sceneName), m_callback(std::move(cb))
+ SceneAction::Ptr Scene::addNewSceneAction(
+ const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr,
+ const std::string& key, const RCSResourceAttributes::Value& value)
{
- }
+ RCSResourceAttributes resAttr;
+ resAttr[key] = RCSResourceAttributes::Value(value);
- Scene::Scene(const std::string& sceneName) :
- m_sceneName(sceneName)
- {
+ return addNewSceneAction(RCSRemoteResourceObjectPtr, resAttr);
}
- Scene::~Scene()
+ SceneAction::Ptr Scene::addNewSceneAction(
+ const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr,
+ const RCSResourceAttributes& attr)
{
- m_sceneActionList.clear();
- }
+ if(RCSRemoteResourceObjectPtr == nullptr)
+ {
+ throw RCSInvalidParameterException("RCSRemoteResoureObjectPtr value is null");
+ }
- bool Scene::addSceneAction(const SceneAction::Ptr& newSceneAction)
- {
- if(newSceneAction == nullptr)
+ SceneMemberResourceObject::Ptr sceneMemberResObj;
+ auto members = m_sceneCollectionResourceObj->getSceneMembers();
+ auto check = std::find_if(members.begin(), members.end(), [&RCSRemoteResourceObjectPtr] (
+ const SceneMemberResourceObject::Ptr it){
+ return it->getRemoteResourceObject() == RCSRemoteResourceObjectPtr;});
+
+ if(check != members.end())
{
- throw RCSInvalidParameterException { "SceneAction is empty!" };
+ sceneMemberResObj = *check;
}
- newSceneAction->setCallback(
- std::bind(&Scene::onSceneActionExecuteResult, this, std::placeholders::_1,
- std::placeholders::_2));
- m_sceneActionList.push_back(newSceneAction);
+ else
+ {
+ sceneMemberResObj = SceneMemberResourceObject::createSceneMemberResource(
+ RCSRemoteResourceObjectPtr);
+ m_sceneCollectionResourceObj->addSceneMember(sceneMemberResObj);
+ }
- return true;
- }
- bool Scene::removeSceneAction(const SceneAction::Ptr& sceneAction)
- {
- // TODO
+ SceneAction::Ptr sceneActionPtr(new SceneAction(sceneMemberResObj, m_name, attr));
+ return sceneActionPtr;
}
- void Scene::setCallback(ExecuteCallback cb)
+ std::vector< SceneAction::Ptr > Scene::getSceneAction( // need to confirm return type vector or Ptr
+ const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr) const
{
- if(cb == nullptr)
+ std::vector<SceneAction::Ptr> actions;
+ auto sceneMemberResObjs = m_sceneCollectionResourceObj->getSceneMembers();
+ for(const auto& member: sceneMemberResObjs)
{
- throw RCSInvalidParameterException { "callback is empty!" };
+ if(member->getRemoteResourceObject() == RCSRemoteResourceObjectPtr)
+ {
+ auto mappingInfo = member->getMappingInfo();
+ for(const auto& it: mappingInfo)
+ {
+ if(it.sceneName == m_name)
+ {
+ SceneAction::Ptr sceneActionPtr(new SceneAction(
+ member, m_name, it.key, it.value));
+ actions.push_back(sceneActionPtr);
+ }
+ }
+ }
}
-
- m_callback = std::move(cb);
+ return actions;
}
- bool Scene::execute()
+ std::vector< SceneAction::Ptr > Scene::getSceneActions() const
{
- for (const auto& it : m_sceneActionList)
+ std::vector<SceneAction::Ptr> actions;
+ auto sceneMemberResObjs = m_sceneCollectionResourceObj->getSceneMembers();
+ for(const auto& member: sceneMemberResObjs)
{
- if (it->execute() == false)
+ auto mappingInfo = member->getMappingInfo();
+ for(const auto& it : mappingInfo)
{
- return false;
+ if(it.sceneName == m_name)
+ {
+ SceneAction::Ptr sceneActionPtr(new SceneAction(
+ member, m_name, it.key, it.value));
+// SceneAction::WeakPtr sceneActionWeakPtr(sceneActionPtr);
+ actions.push_back(sceneActionPtr);
+ }
}
}
- return true;
+ return actions;
}
std::string Scene::getName() const
{
- return m_sceneName;
+ return m_name;
}
- void Scene::setName(const std::string name)
+ void Scene::removeSceneAction(const SceneAction::Ptr& sceneActionPtr)
{
- m_sceneName = name;
+// TODO
}
- void Scene::onSceneActionExecuteResult(const RCSResourceAttributes& attributes, int eCode)
+ void Scene::removeSceneAction(
+ const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr)
{
- if (attributes.empty())
- {
- std::cout << "\tattributes is empty" << std::endl;
- }
-
- for (const auto& attr : attributes)
- {
- std::cout << "\tkey : " << attr.key() << std::endl << "\tvalue : "
- << attr.value().toString() << std::endl;
-
- if (m_callback != nullptr)
- {
- m_callback(attributes, eCode);
- }
- }
+// TODO
}
+ void Scene::execute(ExecuteCallback cb)
+ {
+ m_sceneCollectionResourceObj->execute(m_name, cb);
+ }
} /* namespace Service */
} /* namespace OIC */
-
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneAction.h"
+#include "SceneMemberResourceObject.h"
namespace OIC
{
namespace Service
{
- SceneAction::SceneAction(const SceneMemberObject::Ptr& SceneMemberObjectPtr,
- const std::string& key, const RCSResourceAttributes::Value& value) :
- m_sceneMemberPtr(SceneMemberObjectPtr)
+ SceneAction::SceneAction(const SceneMemberResourceObject::Ptr SceneMemberResource,
+ const std::string& sceneName, const RCSResourceAttributes& attr) :
+ m_pRemoteResourceObject(SceneMemberResource->getRemoteResourceObject()),
+ m_sceneName(sceneName),
+ m_sceneMemberResourceObj(SceneMemberResource)
{
- m_attr[key] = RCSResourceAttributes::Value(value);
+ for (const auto& it : attr)
+ {
+ m_sceneMemberResourceObj->addMappingInfo(
+ SceneMemberResourceObject::MappingInfo(m_sceneName, it.key(), it.value()));
+ }
}
- void SceneAction::setCallback(ExecuteCallback cb)
+ SceneAction::SceneAction(const SceneMemberResourceObject::Ptr SceneMemberResource,
+ const std::string& sceneName, const std::string& key,
+ const RCSResourceAttributes::Value& value) :
+ m_pRemoteResourceObject(SceneMemberResource->getRemoteResourceObject()),
+ m_sceneName(sceneName), m_sceneMemberResourceObj(SceneMemberResource)
{
- if (cb == nullptr)
+ m_sceneMemberResourceObj->addMappingInfo(
+ SceneMemberResourceObject::MappingInfo(m_sceneName, key, value));
+ }
+
+ void SceneAction::update(const std::string& key,
+ RCSResourceAttributes::Value value)
+ {
+ m_attr[key] = value;
+ update(m_attr);
+ }
+
+ void SceneAction::update(const RCSResourceAttributes& attr)
+ {
+ for(const auto& it : attr)
{
- throw RCSInvalidParameterException { "Callback is empty!" };
+ m_sceneMemberResourceObj->addMappingInfo(
+ SceneMemberResourceObject::MappingInfo(m_sceneName, it.key(), it.value()));
}
+ }
- m_callback = std::move(cb);
+ const RCSResourceAttributes SceneAction::getAction()
+ {
+ m_attr.clear();
+ auto mappingInfo = m_sceneMemberResourceObj->getMappingInfo();
+ for(const auto& it : mappingInfo)
+ {
+ if(it.sceneName == m_sceneName)
+ {
+ m_attr[it.key] = RCSResourceAttributes::Value(it.value);
+ }
+ }
+ return m_attr;
}
- bool SceneAction::execute()
+ RCSRemoteResourceObject::Ptr SceneAction::getRemoteResourceObject() const
{
- m_sceneMemberPtr->getRemoteResourceObject()->setRemoteAttributes(m_attr, m_callback);
- return true;
+ return m_pRemoteResourceObject;
}
+
} /* namespace Service */
} /* namespace OIC */
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneCollection.h"
+#include "SceneCollectionResourceObject.h"
-#include "uuid/uuid.h"
#include "octypes.h"
#include "ocrandom.h"
{
namespace Service
{
- namespace
- {
- unsigned int numSceneCollection = 0;
-
- const std::string PREFIX_SCENE_COLLECTION_URI = "/a/sceneCollection/";
- const std::string LAST_SCENE = "lastScene";
- const std::string SCENE_VALUES = "sceneValues";
- const std::string SCENE_COLLECTION_NAME = "n";
- const std::string SCENE_COLLECTION_ID = "id";
- const std::string SCENE_RTS = "rts";
- const std::string SCENE_RTS_VALUE = "oic.r.scenemember";
- const std::string SCENE_PAYLOAD_LINK = "link";
+ SceneCollection::SceneCollection(
+ const SceneCollectionResourceObject::Ptr& sceneCollectionResource) :
+ m_sceneCollectionResourceObj(sceneCollectionResource) {}
- const std::string SCENE_COLLECTION_RT = "oic.wk.scenecollection";
+ Scene::Ptr SceneCollection::addNewScene(const std::string& sceneName)
+ {
+ if(sceneName.empty())
+ {
+ throw RCSInvalidParameterException("Scene name is an empty string");
+ }
+ m_sceneCollectionResourceObj->addScene(sceneName);
- std::string OICGenerateUUIDStr()
+ for (const auto& it : m_scenes)
{
- uint8_t uuid[UUID_SIZE] = { 0, };
- char uuidStr[UUID_STRING_SIZE] = { 0, };
- if(RAND_UUID_OK == OCGenerateUuid(uuid))
+ if (it.first.compare(sceneName) == 0)
{
- if(RAND_UUID_OK == OCConvertUuidToString(uuid, uuidStr))
- {
- return std::string(uuidStr);
- }
+ return it.second;
}
- return "";
}
- }
-
- SceneCollection::SceneCollection()
- : m_Id(), m_Uri(PREFIX_SCENE_COLLECTION_URI + std::to_string(numSceneCollection++))
- {
- m_Id = OICGenerateUUIDStr();
- if(m_Id == "")
- {
- // TODO handle uuid creation fail.
- }
-
- m_sceneCollectionResourcePtr = RCSResourceObject::Builder(m_Uri, SCENE_COLLECTION_RT,
- OC_RSRVD_INTERFACE_DEFAULT).setDiscoverable(true).setObservable(true).build();
-
- m_sceneCollectionResourcePtr->setAttribute(LAST_SCENE, "");
- m_sceneCollectionResourcePtr->setAttribute(SCENE_VALUES, std::vector<std::string>());
- m_sceneCollectionResourcePtr->setAttribute(SCENE_COLLECTION_NAME, "");
- m_sceneCollectionResourcePtr->setAttribute(SCENE_COLLECTION_ID, m_Id);
- m_sceneCollectionResourcePtr->setAttribute(SCENE_RTS, SCENE_RTS_VALUE);
-
-
- m_sceneCollectionResourcePtr->setSetRequestHandler(
- std::bind(
- &SceneCollection::setRequestHandler, this,
- std::placeholders::_1, std::placeholders::_2));
- }
-
- const std::vector< Scene::Ptr >& SceneCollection::getSceneList()
- {
- return m_SceneList;
- }
- void SceneCollection::setName(const std::string& sceneCollectionName)
- {
- m_sceneCollectionResourcePtr->setAttribute(SCENE_COLLECTION_NAME, sceneCollectionName);
- }
+ Scene::Ptr scenePtr(new Scene(sceneName, m_sceneCollectionResourceObj));
+ m_scenes.insert(std::pair<const std::string, Scene::Ptr>(sceneName, scenePtr));
- std::string SceneCollection::getName() const
- {
- return m_sceneCollectionResourcePtr->
- getAttributeValue(SCENE_COLLECTION_NAME).get<std::string>();
+ return scenePtr;
}
- std::string SceneCollection::getUri() const
- {
- return m_Uri;
- }
-
- std::string SceneCollection::getId() const
+ std::map< const std::string, Scene::Ptr > SceneCollection::getScenes() const
{
- return m_Id;
+ return m_scenes;
}
- Scene::Ptr SceneCollection::addScene(const std::string& sceneName)
+ Scene::Ptr SceneCollection::getScene(const std::string& sceneName) const
{
- Scene::Ptr m_scene = std::make_shared < Scene > (sceneName);
- m_SceneList.push_back(m_scene);
- return m_scene;
- }
-
- bool SceneCollection::removeScene(const Scene::Ptr& it)
- {
- // remove scene
- // remove scene Name list
- }
-
- SceneMemberObject::Ptr SceneCollection::addSceneMember(
- const RCSRemoteResourceObject::Ptr& it)
- {
- auto newSceneMemberObj = std::make_shared < SceneMemberObject > (it);
- m_SceneMemberObjectList.push_back(newSceneMemberObj);
- return newSceneMemberObj;
- }
-
- bool SceneCollection::removeSceneMember(SceneMemberObject::Ptr it)
- {
- }
-
- const std::vector< SceneMemberObject::Ptr >& SceneCollection::getSceneMemberList()
- {
- return m_SceneMemberObjectList;
- }
-
- RCSSetResponse
- SceneCollection::setRequestHandler(
- const RCSRequest & request, RCSResourceAttributes & attributes)
- {
- if(attributes.contains(SCENE_PAYLOAD_LINK))
+ auto it = m_scenes.find(sceneName);
+ if (it != m_scenes.end())
{
- return createSceneMemberRequestHandler(request, attributes);
- }
-
- if(attributes.contains(SCENE_VALUES))
- {
- return createSceneRequestHandler(request, attributes);
+ return it->second;
}
+ }
- if(attributes.contains(LAST_SCENE))
+ void SceneCollection::removeScene(Scene::Ptr scenePtr)
+ {
+ if (scenePtr == nullptr)
{
- return executeSceneRequestHandler(request, attributes);
+ throw RCSInvalidParameterException("Scene Ptr is empty!");
}
-
-
- return RCSSetResponse::create(attributes, (int)OC_STACK_ERROR)
- .setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- RCSSetResponse
- SceneCollection::createSceneMemberRequestHandler(
- const RCSRequest &, RCSResourceAttributes & attributes)
+ void SceneCollection::setName(const std::string& name)
{
- std::string request_key = attributes.at(SCENE_PAYLOAD_LINK).get<std::string>();
- // TODO create scene member
-
- attributes.at(SCENE_COLLECTION_ID) = m_Id;
-
- return RCSSetResponse::create(attributes)
- .setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ m_sceneCollectionResourceObj->setName(name);
}
- RCSSetResponse
- SceneCollection::createSceneRequestHandler(
- const RCSRequest &, RCSResourceAttributes & attributes)
+ std::string SceneCollection::getName() const
{
- std::vector<std::string> request_key
- = attributes.at(SCENE_VALUES).get<std::vector<std::string>>();
-
- std::vector<std::string> newScene;
- std::vector<std::string>::iterator iter = request_key.begin();
- std::vector<Scene::Ptr>::iterator foundScene;
-
- struct FindSceneName
- {
- bool operator()(Scene::Ptr scene) const { return scene->getName() == name; }
- std::string name;
- };
-
- while(iter != request_key.end())
- {
- FindSceneName fScene;
- fScene.name = *iter;
- foundScene = std::find_if(m_SceneList.begin(), m_SceneList.end(), fScene);
- if(foundScene == m_SceneList.end())
- {
- newScene.push_back(*iter);
- }
- iter++;
- }
-
- for(unsigned int i = 0; i < newScene.size(); ++i)
- {
- // TODO create scene
- newScene[i]; //Scene Value
- }
-
-
- // success
- return RCSSetResponse::create(attributes)
- .setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ return m_sceneCollectionResourceObj->getName();
}
- RCSSetResponse
- SceneCollection::executeSceneRequestHandler(
- const RCSRequest &, RCSResourceAttributes & attributes)
+ std::string SceneCollection::getId() const
{
- std::string request_key = attributes.at(LAST_SCENE).get<std::string>();
- m_sceneCollectionResourcePtr->setAttribute(LAST_SCENE, request_key);
-
- // TODO execute scene
-
- // success
- return RCSSetResponse::create(attributes)
- .setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ return m_sceneCollectionResourceObj->getId();
}
} /* namespace Service */
} /* namespace OIC */
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneList.h"
+#include "SceneListResourceObject.h"
+#include "SceneCollectionResourceObject.h"
#include "RCSRequest.h"
#include "PrimitiveResource.h"
{
namespace Service
{
- namespace
+ SceneList * SceneList::getInstance()
{
- const std::string SCENE_LIST_NAME = "n";
- const std::string SCENE_LIST_ID = "id";
- const std::string SCENE_LIST_LINK = "link";
- const std::string SCENE_LIST_RTS = "rts";
- const std::string SCENE_LIST_RTS_VALUE = "oic.wk.scenecollection";
- const std::string SCENE_LIST_RT_NAME = "oic.wk.scenelist";
- const std::string SCENE_LIST_URI = "/SceneListResURI";
- const std::string SCENE_LIST_DEFAULT_NAME = "list of scene Collections";
- const std::string COAP_TAG = "coap://";
-
- RCSResourceObject::Ptr sceneListResourcePtr;
- // < std::string uri, SceneCollection::Ptr collection_instance >
- std::map< std::string, SceneCollection::Ptr > sceneCollections;
-
- RCSSetResponse setRequestHandler(const RCSRequest & /*request*/,
- RCSResourceAttributes & attributes)
- {
- auto newObject = SceneList::getInstance()->createSceneCollection();
-
- if (newObject == nullptr)
- {
- return RCSSetResponse::create(attributes, (int) OC_STACK_ERROR).setAcceptanceMethod(
- RCSSetResponse::AcceptanceMethod::IGNORE);
- }
-
- newObject->setName(attributes.at(SCENE_LIST_NAME).get< std::string >());
-
- attributes.at(SCENE_LIST_ID) = newObject->getId();
- attributes.at(SCENE_LIST_LINK) = COAP_TAG + newObject->getUri();
-
- return RCSSetResponse::create(attributes).setAcceptanceMethod(
- RCSSetResponse::AcceptanceMethod::IGNORE);
- }
+ static SceneList instance;
+ return &instance;
}
- SceneList::SceneList()
+ SceneCollection::Ptr SceneList::addNewSceneCollection()
{
- sceneListResourcePtr = RCSResourceObject::Builder(SCENE_LIST_URI, SCENE_LIST_RT_NAME,
- OC_RSRVD_INTERFACE_DEFAULT).setDiscoverable(true).setObservable(false).build();
+ auto sceneCollectionResObj =
+ SceneCollectionResourceObject::createSceneCollectionObject();
+ SceneListResourceObject::getInstance()->addSceneCollectionResource(sceneCollectionResObj);
- sceneListResourcePtr->setAttribute(SCENE_LIST_NAME, SCENE_LIST_DEFAULT_NAME);
- sceneListResourcePtr->setAttribute(SCENE_LIST_RTS, SCENE_LIST_RTS_VALUE);
- sceneListResourcePtr->setSetRequestHandler(&setRequestHandler);
+ SceneCollection::Ptr sceneCollectionPtr(new SceneCollection(sceneCollectionResObj));
+ return sceneCollectionPtr;
}
- SceneList* SceneList::getInstance()
+ std::vector< SceneCollection::Ptr > SceneList::getSceneCollections() const
{
- static SceneList instance;
- return &instance;
+ std::vector<SceneCollection::Ptr> sceneCollections;
+ auto sceneCollectionResObjs = SceneListResourceObject::getInstance()->getSceneCollections();
+ for(const auto& it : sceneCollectionResObjs)
+ {
+ SceneCollection::Ptr sceneCollectionPtr(new SceneCollection(it));
+ sceneCollections.push_back(sceneCollectionPtr);
+ }
+ return sceneCollections;
}
- SceneCollection::Ptr SceneList::createSceneCollection()
+ void SceneList::removeSceneCollection(SceneCollection::Ptr sceneCollectionPtr)
{
- auto newSceneCollectionObj = std::make_shared< SceneCollection >();
-
- if (newSceneCollectionObj != nullptr)
- {
- sceneCollections.insert(
- std::make_pair(newSceneCollectionObj->getUri(), newSceneCollectionObj));
- // TODO : bind resource!!
- return newSceneCollectionObj;
- }
- return nullptr;
+// TODO : remove logic
+// if (sceneCollectionPtr == nullptr)
+// {
+// throw RCSInvalidParameterException
+// { "Scene Collection Ptr is empty!" };
+// }
}
- void SceneList::setName(const std::string& name)
+ void SceneList::setName(const std::string& sceneListName)
{
- sceneListResourcePtr->setAttribute(SCENE_LIST_NAME, name);
+ SceneListResourceObject::getInstance()->setName(sceneListName);
}
std::string SceneList::getName() const
{
- return sceneListResourcePtr->getAttributeValue(SCENE_LIST_NAME).toString();
+ return SceneListResourceObject::getInstance()->getName();
}
-
} /* namespace Service */
} /* namespace OIC */
+++ /dev/null
-//******************************************************************
-//
-// Copyright 2016 Samsung Electronics All Rights Reserved.
-//
-//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-#include "SceneMemberObject.h"
-
-namespace OIC
-{
- namespace Service
- {
- namespace
- {
- unsigned int m_numSceneMember = 0;
-
- const std::string SCENE_MEMBER_RT = "oic.r.scenemember";
- }
-
- SceneMemberObject::SceneMemberObject(RCSRemoteResourceObject::Ptr it) :
- link{ it->getUri() }
- {
- RemoteObjectPtr = it;
-
- std::string resourceUri = "/a/sceneMember" + std::to_string(m_numSceneMember++);
- sceneMemberResourcePtr = RCSResourceObject::Builder(resourceUri, SCENE_MEMBER_RT,
- OC_RSRVD_INTERFACE_DEFAULT).setDiscoverable(true).setObservable(true).build();
-
- sceneMemberResourcePtr->setAutoNotifyPolicy(RCSResourceObject::AutoNotifyPolicy::NEVER);
- sceneMemberResourcePtr->setSetRequestHandlerPolicy(
- RCSResourceObject::SetRequestHandlerPolicy::NEVER);
-
- sceneMemberResourcePtr->setAttribute("link", it->getUri());
- }
-
- void SceneMemberObject::setName(std::string sceneMemberName)
- {
- name = sceneMemberName;
- sceneMemberResourcePtr->setAttribute("name", sceneMemberName);
- }
-
- std::string SceneMemberObject::getName()
- {
- return name;
- }
-
- RCSResourceAttributes SceneMemberObject::getSceneMappingItem(std::string sceneName)
- {
- for (const auto& it : sceneMapping)
- {
- if (it.first == sceneName)
- return it.second;
- }
- }
-
- std::map< std::string, RCSResourceAttributes > SceneMemberObject::getSceneMapping()
- {
- return sceneMapping;
- }
-
- bool SceneMemberObject::hasSceneMappingitem(std::string sceneName)
- {
- if (sceneMapping.find(sceneName) == sceneMapping.end())
- return false;
- return true;
- }
-
- RCSRemoteResourceObject::Ptr SceneMemberObject::getRemoteResourceObject()
- {
- return RemoteObjectPtr;
- }
-
- } /* namespace Service */
-} /* namespace OIC */
-
+++ /dev/null
-//******************************************************************
-//
-// Copyright 2016 Samsung Electronics All Rights Reserved.
-//
-//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-#ifndef SM_SCENEMEMBEROBJECT_H_
-#define SM_SCENEMEMBEROBJECT_H_
-
-#include <cstdbool>
-#include <list>
-#include <functional>
-#include <string>
-#include <map>
-
-#include "octypes.h"
-
-#include "RCSRemoteResourceObject.h"
-#include "RCSResourceObject.h"
-
-namespace OIC
-{
- namespace Service
- {
- class SceneMemberObject
- {
- public:
- typedef std::shared_ptr< SceneMemberObject > Ptr;
-
- public:
- SceneMemberObject(RCSRemoteResourceObject::Ptr);
-
- public:
- void setName(std::string);
- std::string getName();
-
- RCSResourceAttributes getSceneMappingItem(std::string);
- std::map< std::string, RCSResourceAttributes > getSceneMapping();
- bool hasSceneMappingitem(std::string);
- RCSRemoteResourceObject::Ptr getRemoteResourceObject();
-
- private:
- unsigned int Id;
- std::string name;
- std::string link;
- std::map< std::string, RCSResourceAttributes > sceneMapping;
-
- RCSRemoteResourceObject::Ptr RemoteObjectPtr;
- RCSResourceObject::Ptr sceneMemberResourcePtr;
- };
- } /* namespace Service */
-} /* namespace OIC */
-#endif /* SM_SCENEMEMBEROBJECT_H_ */
projects / platform / upstream / iotivity.git / commitdiff