#include <memory>
#include <string>
-#include <map>
+#include <unordered_map>
+#include <mutex>
#include "RemoteSceneAction.h"
#include "RCSRemoteResourceObject.h"
public:
typedef std::shared_ptr< RemoteScene > Ptr;
- typedef std::function< void(RemoteSceneAction::Ptr, int) >
- AddNewSceneActionCallback;
+ typedef std::function< void(RemoteSceneAction::Ptr, int eCode) >
+ AddNewSceneActionCallback;
typedef std::function< void(const int eCode) >
- RemoveSceneActionCallback;
+ RemoveSceneActionCallback;
typedef std::function< void(const std::string &sceneName, int eCode) >
- RemoteSceneExecuteCallback;
-
+ RemoteSceneExecuteCallback;
public:
~RemoteScene() = default;
- void addNewSceneAction(RCSRemoteResourceObject::Ptr pTargetResource,
- const RCSResourceAttributes &attrs,
+ void addNewSceneAction(RCSRemoteResourceObject::Ptr targetResource,
+ const RCSResourceAttributes &,
AddNewSceneActionCallback);
- void addNewSceneAction(RCSRemoteResourceObject::Ptr pTargetResource,
+ void addNewSceneAction(RCSRemoteResourceObject::Ptr targetResource,
const std::string &key,
- const RCSResourceAttributes::Value &value,
+ const RCSResourceAttributes::Value &,
AddNewSceneActionCallback);
- void removeSceneAction(RemoteSceneAction::Ptr pRemoteSceneAction,
+ void removeSceneAction(RemoteSceneAction::Ptr remoteSceneAction,
RemoveSceneActionCallback);
- void removeSceneAction(RCSRemoteResourceObject::Ptr pTargetResource,
+ void removeSceneAction(RCSRemoteResourceObject::Ptr targetResource,
RemoveSceneActionCallback);
std::vector< RemoteSceneAction::Ptr > getRemoteSceneActions() const;
- std::vector< RemoteSceneAction::Ptr > getRemoteSceneAction
- (const RCSRemoteResourceObject::Ptr pTargetResource) const;
+ RemoteSceneAction::Ptr getRemoteSceneAction(
+ const RCSRemoteResourceObject::Ptr targetResource) const;
std::string getName() const;
void execute(RemoteSceneExecuteCallback);
-
private:
- RemoteScene
- (const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor >);
+ RemoteScene(
+ const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor >);
- RemoteSceneAction::Ptr createRemoteSceneActionInstance
- (const std::string &, const RCSResourceAttributes &);
+ RemoteSceneAction::Ptr createRemoteSceneActionInstance(
+ const std::string &, const RCSResourceAttributes &);
void addExistingRemoteSceneAction(const std::string &, const std::string &,
const std::string &, const std::string &key,
const RCSResourceAttributes::Value &);
void onSceneActionAdded(
- std::shared_ptr< SceneMemberResourceRequestor >,
- int eCode, RCSRemoteResourceObject::Ptr,
- const RCSResourceAttributes &, AddNewSceneActionCallback);
-
- void onSceneExecuted(const int &reqType, const std::string &name,
- int eCode, RemoteSceneExecuteCallback);
+ int, RCSRemoteResourceObject::Ptr,
+ const RCSResourceAttributes &, const AddNewSceneActionCallback &);
+ void onSceneExecuted(const std::string &name, int,
+ const RemoteSceneExecuteCallback &);
private:
std::string m_name;
- std::map < const std::string, std::vector< RemoteSceneAction::Ptr > >
- m_remoteSceneActions;
+ mutable std::mutex m_sceneActionLock;
+ std::unordered_map < std::string, RemoteSceneAction::Ptr >
+ m_remoteSceneActions;
- std::shared_ptr< SceneCollectionResourceRequestor > m_requestorPtr;
+ std::shared_ptr< SceneCollectionResourceRequestor > m_requestor;
friend class RemoteSceneCollection;
};
#include <memory>
#include <string>
+#include <mutex>
#include "RCSRemoteResourceObject.h"
public:
typedef std::shared_ptr< RemoteSceneAction > Ptr;
- typedef std::function< void(int eCode) >
- UpdateCallback;
-
+ typedef std::function< void(int eCode) > UpdateCallback;
public:
~RemoteSceneAction() = default;
- void update(const RCSResourceAttributes &attr, UpdateCallback);
- void update(const std::string &key,
- const RCSResourceAttributes::Value &value,
- UpdateCallback);
+ void setExecutionParameter(const std::string &key,
+ const RCSResourceAttributes::Value &value, UpdateCallback);
+ void setExecutionParameter(const RCSResourceAttributes &attr, UpdateCallback);
- RCSResourceAttributes getAction() const;
+ RCSResourceAttributes getExecutionParameter() const;
RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
-
private:
RemoteSceneAction(std::shared_ptr< SceneMemberResourceRequestor >,
const std::string &sceneName, const RCSResourceAttributes &);
void onUpdated(int, const RCSResourceAttributes &, const UpdateCallback &);
-
private:
std::string m_sceneName;
+ std::mutex m_attributeLock;
RCSResourceAttributes m_attributes;
- std::shared_ptr< SceneMemberResourceRequestor > m_requestorPtr;
+ std::shared_ptr< SceneMemberResourceRequestor > m_requestor;
friend class RemoteScene;
};
#include <memory>
#include <functional>
#include <string>
-#include <map>
+#include <unordered_map>
+#include <mutex>
#include "RemoteScene.h"
#include "RCSRemoteResourceObject.h"
public:
typedef std::shared_ptr< RemoteSceneCollection > Ptr;
- typedef std::function< void(RemoteScene::Ptr, int) >
- AddNewSceneCallback;
+ typedef std::function< void(RemoteScene::Ptr, int eCode) >
+ AddNewSceneCallback;
- typedef std::function< void(int eCode) >
- RemoveSceneCallback;
-
- typedef std::function< void(int eCode) >
- SetNameCallback;
+ typedef std::function< void(int eCode) > RemoveSceneCallback;
+ typedef std::function< void(int eCode) > SetNameCallback;
public:
~RemoteSceneCollection() = default;
void addNewScene(const std::string &name, AddNewSceneCallback);
- void removeScene(const std::string &name, RemoveSceneCallback);
+ void removeScene(RemoteScene::Ptr, RemoveSceneCallback);
- std::map< const std::string, RemoteScene::Ptr > getRemoteScenes() const;
+ std::unordered_map< std::string, RemoteScene::Ptr > getRemoteScenes() const;
RemoteScene::Ptr getRemoteScene(const std::string &sceneName) const;
void setName(const std::string &name, SetNameCallback);
std::string getId() const;
-
private:
- RemoteSceneCollection
- (std::shared_ptr< SceneCollectionResourceRequestor > pRequestor,
- const std::string &id, const std::string &name);
+ RemoteSceneCollection(
+ std::shared_ptr< SceneCollectionResourceRequestor >,
+ const std::string &id, const std::string &name);
- void initializeRemoteSceneCollection(const std::vector< RCSRepresentation > &,
+ void initializeRemoteSceneCollection(const std::vector< RCSResourceAttributes > &,
const std::string &);
RemoteScene::Ptr createRemoteSceneInstance(const std::string &);
- void onSceneAddedRemoved(const int &reqType, const std::string &name, int eCode,
+ void onSceneAddedRemoved(int, const std::string &name, int,
const AddNewSceneCallback &, const RemoveSceneCallback &);
void onNameSet(int, const std::string &, const SetNameCallback &);
-
private:
std::string m_id;
std::string m_name;
- std::map< const std::string, RemoteScene::Ptr > m_remoteScenes;
-
- std::shared_ptr< SceneCollectionResourceRequestor > m_requestorPtr;
+ mutable std::mutex m_sceneLock;
+ std::unordered_map< std::string, RemoteScene::Ptr > m_remoteScenes;
+ std::shared_ptr< SceneCollectionResourceRequestor > m_requestor;
friend class RemoteSceneList;
};
#include <memory>
#include <vector>
#include <functional>
+#include <mutex>
#include "RemoteSceneCollection.h"
#include "RCSRemoteResourceObject.h"
public:
typedef std::unique_ptr< RemoteSceneList > Ptr;
- typedef std::function< void(RemoteSceneList::Ptr, int) >
- CreateInstanceCallback;
+ typedef std::function< void(RemoteSceneList::Ptr, int eCode) >
+ CreateInstanceCallback;
- typedef std::function< void(RemoteSceneCollection::Ptr, int) >
- AddNewSceneCollectionCallback;
-
- typedef std::function< void(int eCode) >
- SetNameCallback;
+ typedef std::function< void(RemoteSceneCollection::Ptr, int eCode) >
+ AddNewSceneCollectionCallback;
+ typedef std::function< void(int eCode) > SetNameCallback;
public:
~RemoteSceneList() = default;
- static void createInstance
- (RCSRemoteResourceObject::Ptr pSceneListResource, CreateInstanceCallback);
+ static void createInstance(
+ RCSRemoteResourceObject::Ptr sceneListResource, CreateInstanceCallback);
void addNewSceneCollection(AddNewSceneCollectionCallback);
void removeSceneCollection(RemoteSceneCollection::Ptr);
void setName(const std::string &name, SetNameCallback);
std::string getName() const;
-
private:
class GetResponseHandler
{
typedef std::shared_ptr< GetResponseHandler > Ptr;
typedef std::function< void(int eCode) >
- GetCallback;
+ GetCallback;
- GetResponseHandler(std::shared_ptr< RemoteSceneList > ptr);
+ GetResponseHandler(std::shared_ptr< RemoteSceneList >);
~GetResponseHandler() = default;
int m_numOfCollections;
void startGetResponseHandler(const std::string &host, GetCallback cb);
- void onGetCollectionAttrs(const HeaderOpts &, const RCSRepresentation &,
- int eCode, RemoteSceneCollection::Ptr,
- const std::string &);
-
- void onGetListAttrs(const HeaderOpts &, const RCSRepresentation &, int,
- const std::string &);
+ 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 > pRequestor);
+ RemoteSceneList(std::shared_ptr< SceneListResourceRequestor >);
- static void onInstanceCreated(int, std::shared_ptr< RemoteSceneList >,
- CreateInstanceCallback);
+ static void onInstanceCreated(const RCSRepresentation &, int, const std::string &,
+ std::shared_ptr< SceneListResourceRequestor >, const CreateInstanceCallback &);
- RemoteSceneCollection::Ptr createRemoteSceneCollectionInstance
- (const std::string &link, const std::string &id, const std::string &name);
+ static RemoteSceneList::Ptr buildSceneList(std::shared_ptr< SceneListResourceRequestor >,
+ const RCSResourceAttributes &);
+ RemoteSceneCollection::Ptr createRemoteSceneCollectionInstance(
+ 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);
- void onSceneCollectionCreated
- (const std::string &link, const std::string &id, const std::string &name,
- int eCode, AddNewSceneCollectionCallback);
+ std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
+ parseSceneListFromAttributes(const RCSResourceAttributes &);
- void onNameSet(int, const std::string &, const SetNameCallback &);
+ std::vector<RCSResourceAttributes> getChildrenAttributes(
+ const RCSResourceAttributes &) const;
+ void onSceneCollectionCreated(
+ const std::string &link, const std::string &id, const std::string &name,
+ int, const AddNewSceneCollectionCallback &);
+
+ void onNameSet(int, const std::string &, const SetNameCallback &);
private:
std::string m_name;
+ std::mutex m_collectionLock;
std::vector< RemoteSceneCollection::Ptr > m_remoteSceneCollections;
std::shared_ptr< SceneListResourceRequestor > m_requestorPtr;
#include "RemoteScene.h"
+#include <utility>
+#include <cassert>
+
#include "SceneCommons.h"
-#include "RemoteSceneUtils.h"
#include "SceneCollectionResourceRequestor.h"
#include "SceneMemberResourceRequestor.h"
#include "OCPlatform.h"
{
RemoteScene::RemoteScene
- (const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor > pRequestor)
- : m_name{ name }, m_requestorPtr{ pRequestor }
+ (const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor > requestor)
+ : m_name{ name }, m_requestor{ requestor }
{
- // TODO: check pRequestor not null
+ assert(requestor);
}
void RemoteScene::addNewSceneAction(
- RCSRemoteResourceObject::Ptr, const RCSResourceAttributes &, AddNewSceneActionCallback)
+ RCSRemoteResourceObject::Ptr targetResource, const RCSResourceAttributes &attrs,
+ AddNewSceneActionCallback clientCB)
{
+ if (targetResource == nullptr)
+ {
+ throw RCSInvalidParameterException("RCSRemoteResoureObject value is null");
+ }
+ if (attrs.empty())
+ {
+ throw RCSInvalidParameterException("RCSResourceAttributes is empty");
+ }
+
+ SceneCollectionResourceRequestor::InternalAddMemberCallback internalCB
+ = std::bind(&RemoteScene::onSceneActionAdded, this,
+ std::placeholders::_1, targetResource, attrs, std::move(clientCB));
+ m_requestor->requestAddSceneMember(
+ targetResource, m_name, attrs, internalCB);
}
- void RemoteScene::addNewSceneAction
- (RCSRemoteResourceObject::Ptr pTargetResource,
- const std::string &key, const RCSResourceAttributes::Value &value,
- AddNewSceneActionCallback clientCB)
+ void RemoteScene::addNewSceneAction(
+ RCSRemoteResourceObject::Ptr targetResource,
+ const std::string &key, const RCSResourceAttributes::Value &value,
+ AddNewSceneActionCallback clientCB)
{
- // TODO: check pTargetResource not null
- // TODO: check key not empty
-
- RCSResourceAttributes attr;
- attr[key] = RCSResourceAttributes::Value(value);
-
- std::string targetLink = pTargetResource->getAddress() + pTargetResource->getUri();
-
- auto sceneActions = m_remoteSceneActions.find(targetLink);
-
- // if the target is not a scene member
- if (sceneActions == m_remoteSceneActions.end())
+ if (targetResource == nullptr)
{
- SceneCollectionResourceRequestor::InternalAddMemberCallback internalCB
- = std::bind(&RemoteScene::onSceneActionAdded, this,
- std::placeholders::_1, std::placeholders::_2,
- pTargetResource, attr, std::move(clientCB));
-
- m_requestorPtr->requestAddSceneMember
- (pTargetResource, m_name, attr, internalCB);
+ throw RCSInvalidParameterException("RCSRemoteResoureObject value is null");
}
- else
+ if (key.empty())
{
- // check if sceneAction already exists
- for (auto itr : sceneActions->second)
- {
- if (itr->getAction().contains(key))
- {
- // throw exception
- break;
- }
- }
-
- SceneMemberResourceRequestor::Ptr pMemberRequestor
- = m_requestorPtr->getSceneMemberResourceRequestor(targetLink);
-
- if (pMemberRequestor)
- {
- SceneMemberResourceRequestor::InternalAddSceneActionCallback internalCB
- = std::bind(&RemoteScene::onSceneActionAdded, this,
- nullptr,
- std::placeholders::_1, pTargetResource,
- attr, std::move(clientCB));
-
- pMemberRequestor->
- requestSceneActionCreation(m_name, attr, internalCB);
- }
+ throw RCSInvalidParameterException("Scene action key value is empty");
}
+
+ RCSResourceAttributes attrs;
+ attrs[key] = RCSResourceAttributes::Value(value);
+
+ addNewSceneAction(targetResource, attrs, clientCB);
}
- void RemoteScene::removeSceneAction(RemoteSceneAction::Ptr/* pRemoteSceneAction */,
- RemoveSceneActionCallback /* clientCB */)
+ void RemoteScene::removeSceneAction(RemoteSceneAction::Ptr, RemoveSceneActionCallback)
{
}
- void RemoteScene::removeSceneAction(RCSRemoteResourceObject::Ptr/* pTargetResource*/,
- RemoveSceneActionCallback /* clientCB */)
+ void RemoteScene::removeSceneAction(RCSRemoteResourceObject::Ptr /* rargetResource*/,
+ RemoveSceneActionCallback)
{
}
std::vector< RemoteSceneAction::Ptr > RemoteScene::getRemoteSceneActions() const
{
- std::vector< RemoteSceneAction::Ptr > vecSceneActions;
+ std::lock_guard< std::mutex > actionlock(m_sceneActionLock);
+ std::vector< RemoteSceneAction::Ptr > sceneActionList;
for (auto itrMap : m_remoteSceneActions)
{
- for (auto itrVec : itrMap.second)
- {
- vecSceneActions.push_back(itrVec);
- }
+ sceneActionList.push_back(itrMap.second);
}
- return vecSceneActions;
+ return sceneActionList;
}
- std::vector< RemoteSceneAction::Ptr > RemoteScene::getRemoteSceneAction
- (const RCSRemoteResourceObject::Ptr pTargetResource) const
+ RemoteSceneAction::Ptr RemoteScene::getRemoteSceneAction(
+ const RCSRemoteResourceObject::Ptr targetResource) const
{
+ if (targetResource == nullptr)
+ {
+ throw RCSInvalidParameterException("RCSRemoteResoureObject value is null");
+ }
+
+ std::lock_guard< std::mutex > actionlock(m_sceneActionLock);
auto itr = m_remoteSceneActions.find(
- pTargetResource->getAddress() + pTargetResource->getUri());
+ targetResource->getAddress() + targetResource->getUri());
if (itr == m_remoteSceneActions.end())
{
- ;
- // TODO: throw unadded scene action exception
+ throw RCSInvalidParameterException("Invalid RCSRemoteResoureObject");
}
return itr->second;
void RemoteScene::execute(RemoteSceneExecuteCallback clientCB)
{
SceneCollectionResourceRequestor::InternalSceneRequestCallback internalCB
- = std::bind(&RemoteScene::onSceneExecuted, this,
- std::placeholders::_1, std::placeholders::_2,
+ = std::bind(&RemoteScene::onSceneExecuted, this, std::placeholders::_2,
std::placeholders::_3, std::move(clientCB));
- m_requestorPtr->requestSceneExecution(m_name, internalCB);
+ m_requestor->requestSceneExecution(m_name, internalCB);
}
RemoteSceneAction::Ptr RemoteScene::createRemoteSceneActionInstance
- (const std::string &targetLink, const RCSResourceAttributes &attrs)
+ (const std::string &targetHref, const RCSResourceAttributes &attrs)
{
- RemoteSceneAction::Ptr pNewSceneAction = nullptr;
- SceneMemberResourceRequestor::Ptr pMemRequestor
- = m_requestorPtr->getSceneMemberResourceRequestor(targetLink);
- if (pMemRequestor)
+ SceneMemberResourceRequestor::Ptr memRequestor
+ = m_requestor->getSceneMemberResourceRequestor(targetHref);
+
+ if (memRequestor == nullptr)
{
- pNewSceneAction.reset(new RemoteSceneAction(pMemRequestor, m_name, attrs));
- m_remoteSceneActions[targetLink].push_back(pNewSceneAction);
+ return nullptr;
}
- return pNewSceneAction;
+ RemoteSceneAction::Ptr newAction(new RemoteSceneAction(memRequestor, m_name, attrs));
+
+ {
+ std::lock_guard< std::mutex > actionlock(m_sceneActionLock);
+ m_remoteSceneActions.insert(
+ std::make_pair(targetHref, newAction));
+ }
+
+ return newAction;
}
- void RemoteScene::addExistingRemoteSceneAction
- (const std::string &address, const std::string &targetLink,
- const std::string &id, const std::string &key, const RCSResourceAttributes::Value &value)
+ void RemoteScene::addExistingRemoteSceneAction(
+ const std::string &href, const std::string &targetHref,
+ const std::string &id, const std::string &key,
+ const RCSResourceAttributes::Value &value)
{
- SceneMemberResourceRequestor::Ptr pfoundMember
- = m_requestorPtr->getSceneMemberResourceRequestor(targetLink);
+ SceneMemberResourceRequestor::Ptr foundMemberRequestor
+ = m_requestor->getSceneMemberResourceRequestor(targetHref);
- if (pfoundMember == nullptr)
- m_requestorPtr->createSceneMemberResourceRequestor(address, id, targetLink);
+ if (foundMemberRequestor == nullptr)
+ m_requestor->createSceneMemberResourceRequestor(href, id, targetHref);
RCSResourceAttributes attrs;
attrs[key] = RCSResourceAttributes::Value(value);
- createRemoteSceneActionInstance(targetLink, attrs);
+ createRemoteSceneActionInstance(targetHref, attrs);
}
- void RemoteScene::onSceneActionAdded
- (SceneMemberResourceRequestor::Ptr, int eCode, RCSRemoteResourceObject::Ptr target,
- const RCSResourceAttributes &attrs,
- AddNewSceneActionCallback clientCB)
+ void RemoteScene::onSceneActionAdded(
+ int eCode, RCSRemoteResourceObject::Ptr target, const RCSResourceAttributes &attrs,
+ const AddNewSceneActionCallback &clientCB)
{
int result = SCENE_CLIENT_BADREQUEST;
- RemoteSceneAction::Ptr pNewRemoteSceneAction = nullptr;
+ RemoteSceneAction::Ptr newAction = nullptr;
if (eCode == SCENE_RESPONSE_SUCCESS)
{
std::string targetLink = target->getAddress() + target->getUri();
- pNewRemoteSceneAction = createRemoteSceneActionInstance(targetLink, attrs);
+ newAction = createRemoteSceneActionInstance(targetLink, attrs);
- if (pNewRemoteSceneAction)
+ if (newAction)
result = SCENE_RESPONSE_SUCCESS;
}
- else
- {
- // error
- }
-
- clientCB(pNewRemoteSceneAction, result);
+
+ clientCB(newAction, result);
}
- void RemoteScene::onSceneExecuted(const int &, const std::string &sceneName,
- const int eCode, RemoteSceneExecuteCallback clientCB)
+ void RemoteScene::onSceneExecuted(const std::string &sceneName, const int eCode,
+ const RemoteSceneExecuteCallback &clientCB)
{
clientCB(sceneName, eCode);
}
#include "RemoteSceneAction.h"
+#include <cassert>
+
#include "SceneCommons.h"
-#include "RemoteSceneUtils.h"
#include "SceneMemberResourceRequestor.h"
namespace OIC
namespace Service
{
- RemoteSceneAction::RemoteSceneAction
- (std::shared_ptr< SceneMemberResourceRequestor > pRequestor,
- const std::string &sceneName, const RCSResourceAttributes &attrs)
- : m_sceneName{ sceneName }, m_attributes{ attrs }, m_requestorPtr{ pRequestor }
+ RemoteSceneAction::RemoteSceneAction(
+ SceneMemberResourceRequestor::Ptr requestor,
+ const std::string &sceneName, const RCSResourceAttributes &attrs)
+ : m_sceneName{ sceneName }, m_attributes{ attrs }, m_requestor{ requestor }
{
- // TODO: check pRequestor not null
+ assert(requestor);
}
- RemoteSceneAction::RemoteSceneAction
- (std::shared_ptr< SceneMemberResourceRequestor > pRequestor,
- const std::string &sceneName,
- const std::string &key, const RCSResourceAttributes::Value &value)
- : m_sceneName{ sceneName }, m_requestorPtr{ pRequestor }
+ RemoteSceneAction::RemoteSceneAction(
+ SceneMemberResourceRequestor::Ptr requestor, const std::string &sceneName,
+ const std::string &key, const RCSResourceAttributes::Value &value)
+ : m_sceneName{ sceneName }, m_requestor{ requestor }
{
- // TODO: check pRequestor not null
+ assert(requestor);
m_attributes[key] = value;
}
- void RemoteSceneAction::update(const RCSResourceAttributes &attr,
+ void RemoteSceneAction::setExecutionParameter(const std::string &key,
+ const RCSResourceAttributes::Value &value,
UpdateCallback clientCB)
{
- SceneMemberResourceRequestor::InternalAddSceneActionCallback internalCB
- = std::bind(&RemoteSceneAction::onUpdated, this,
- std::placeholders::_1, attr, std::move(clientCB));
+ if (key.empty())
+ {
+ throw RCSInvalidParameterException("Scene action key value is empty");
+ }
+
+ RCSResourceAttributes attr;
+ attr[key] = RCSResourceAttributes::Value(value);
- m_requestorPtr->requestSceneActionCreation(m_sceneName,
- attr, internalCB);
+ setExecutionParameter(attr, std::move(clientCB));
}
- void RemoteSceneAction::update(const std::string &key,
- const RCSResourceAttributes::Value &value,
- UpdateCallback clientCB)
+ void RemoteSceneAction::setExecutionParameter(const RCSResourceAttributes &attr,
+ UpdateCallback clientCB)
{
- RCSResourceAttributes attr;
- attr[key] = RCSResourceAttributes::Value(value);
+ if (attr.empty())
+ {
+ throw RCSInvalidParameterException("RCSResourceAttributes is empty");
+ }
+
+ SceneMemberResourceRequestor::InternalAddSceneActionCallback internalCB
+ = std::bind(&RemoteSceneAction::onUpdated, this,
+ std::placeholders::_1, attr, std::move(clientCB));
- update(attr, std::move(clientCB));
+ m_requestor->requestSceneActionCreation(
+ m_sceneName, attr, internalCB);
}
- RCSResourceAttributes RemoteSceneAction::getAction() const
+ RCSResourceAttributes RemoteSceneAction::getExecutionParameter() const
{
return m_attributes;
}
RCSRemoteResourceObject::Ptr RemoteSceneAction::getRemoteResourceObject() const
{
- return m_requestorPtr->getRemoteResourceObject();
+ return m_requestor->getRemoteResourceObject();
}
void RemoteSceneAction::onUpdated(int eCode, const RCSResourceAttributes &attr,
const UpdateCallback &clientCB)
{
+ int result = SCENE_CLIENT_BADREQUEST;
if (eCode == SCENE_RESPONSE_SUCCESS)
{
+ std::lock_guard< std::mutex > lock(m_attributeLock);
m_attributes = attr;
+ result = SCENE_RESPONSE_SUCCESS;
}
- clientCB(eCode);
+ clientCB(result);
}
}
#include "RemoteSceneCollection.h"
+#include <cassert>
+
#include "SceneCommons.h"
#include "RemoteSceneUtils.h"
#include "SceneCollectionResourceRequestor.h"
namespace Service
{
- RemoteSceneCollection::RemoteSceneCollection
- (std::shared_ptr< SceneCollectionResourceRequestor > pRequestor,
- const std::string &id, const std::string &name)
- : m_id{ id }, m_name{ name }, m_requestorPtr{ pRequestor }
+ RemoteSceneCollection::RemoteSceneCollection(
+ std::shared_ptr< SceneCollectionResourceRequestor > requestor,
+ const std::string &id, const std::string &name)
+ : m_id{ id }, m_name{ name }, m_requestor{ requestor }
{
- // TODO: check pRequestor not null
+ assert(requestor);
}
void RemoteSceneCollection::addNewScene
(const std::string &name, AddNewSceneCallback clientCB)
{
- if (m_remoteScenes.find(name) == m_remoteScenes.end())
- {
- SceneCollectionResourceRequestor::InternalSceneRequestCallback internalCB
- = std::bind(&RemoteSceneCollection::onSceneAddedRemoved, this,
- std::placeholders::_1, std::placeholders::_2,
- std::placeholders::_3, std::move(clientCB), nullptr);
-
- m_requestorPtr->requestSceneCreation(name, internalCB);
- }
- else
+ if (name.empty())
{
- // TODO: throw duplication scene name exception
+ throw RCSInvalidParameterException("Scene name is an empty string");
}
+
+ SceneCollectionResourceRequestor::InternalSceneRequestCallback internalCB
+ = std::bind(&RemoteSceneCollection::onSceneAddedRemoved, this,
+ std::placeholders::_1, std::placeholders::_2,
+ std::placeholders::_3, std::move(clientCB), nullptr);
+
+ m_requestor->requestSceneCreation(name, internalCB);
}
- void RemoteSceneCollection::removeScene(const std::string &/* name */,
+ void RemoteSceneCollection::removeScene(RemoteScene::Ptr,
RemoveSceneCallback /* clientCB */)
{
}
- std::map< const std::string, RemoteScene::Ptr >
- RemoteSceneCollection::getRemoteScenes() const
+ std::unordered_map< std::string, RemoteScene::Ptr >
+ RemoteSceneCollection::getRemoteScenes() const
{
return m_remoteScenes;
}
RemoteScene::Ptr RemoteSceneCollection::getRemoteScene(const std::string &sceneName) const
{
+ std::lock_guard< std::mutex > scenelock(m_sceneLock);
auto itr = m_remoteScenes.find(sceneName);
- // TODO: throw unadded scene exception
- return itr != m_remoteScenes.end() ? itr->second : nullptr;
+ if (itr == m_remoteScenes.end())
+ {
+ throw RCSInvalidParameterException("Invalid scene name");
+ }
+
+ return itr->second;
}
void RemoteSceneCollection::setName(const std::string &name, SetNameCallback clientCB)
= std::bind(&RemoteSceneCollection::onNameSet, this,
std::placeholders::_1, name, std::move(clientCB));
- m_requestorPtr->requestSetName(name, internalCB);
+ m_requestor->requestSetName(name, internalCB);
}
std::string RemoteSceneCollection::getName() const
}
void RemoteSceneCollection::initializeRemoteSceneCollection(
- const std::vector< RCSRepresentation > &MemberReps, const std::string &host)
+ const std::vector< RCSResourceAttributes > &MemberReps, const std::string &host)
{
try
{
for (const auto &itr : MemberReps)
{
- RCSResourceAttributes attrs = itr.getAttributes();
+ RCSResourceAttributes attrs = itr;
for (const auto &mappingInfo :
- attrs.at(SCENE_KEY_SCENEMAPPINGS).get
- <std::vector< RCSResourceAttributes > >())
+ attrs.at(SCENE_KEY_SCENEMAPPINGS).get
+ <std::vector< RCSResourceAttributes > >())
{
std::string sceneName
= mappingInfo.at(SCENE_KEY_SCENE).get< std::string >();
pRemoteScene = m_remoteScenes.at(sceneName);
}
+ std::string targetHref
+ = attrs.at(SCENE_KEY_PAYLOAD_LINK).get< RCSResourceAttributes >().
+ at(SCENE_KEY_HREF).get< std::string >();
+ std::string mappingInfoKey
+ = mappingInfo.at(SCENE_KEY_MEMBERPROPERTY).get< std::string >();
+ RCSResourceAttributes::Value mappingInfoValue
+ = mappingInfo.at(SCENE_KEY_MEMBERVALUE);
+
pRemoteScene->addExistingRemoteSceneAction(
- host + itr.getUri(),
- attrs.at(SCENE_KEY_PAYLOAD_LINK).get< RCSResourceAttributes >().
- at(SCENE_KEY_HREF).get< std::string >(),
- attrs.at(SCENE_KEY_ID).get< std::string >(),
- mappingInfo.at(SCENE_KEY_MEMBERPROPERTY).get< std::string >(),
- RCSResourceAttributes::Value(mappingInfo.at(SCENE_KEY_MEMBERVALUE))
- );
+ host + attrs.at("uri").get< std::string >(),
+ targetHref, attrs.at(SCENE_KEY_ID).get< std::string >(),
+ mappingInfoKey, mappingInfoValue);
}
}
}
- catch (const std::exception &)
+ catch (const std::exception &e)
{
- // error
+ SCENE_CLIENT_PRINT_LOG(e.what());
}
}
- RemoteScene::Ptr RemoteSceneCollection::createRemoteSceneInstance
- (const std::string &name)
+ RemoteScene::Ptr RemoteSceneCollection::createRemoteSceneInstance(
+ const std::string &name)
{
- RemoteScene::Ptr pNewRemoteScene
- {
- new RemoteScene(name, m_requestorPtr)
- };
+ std::lock_guard< std::mutex > scenelock(m_sceneLock);
+ RemoteScene::Ptr pNewRemoteScene(new RemoteScene(name, m_requestor));
m_remoteScenes[name] = pNewRemoteScene;
-
+
return pNewRemoteScene;
}
- void RemoteSceneCollection::onSceneAddedRemoved(const int &reqType,
- const std::string &name, int eCode,
- const AddNewSceneCallback &addCB, const RemoveSceneCallback &)
+ void RemoteSceneCollection::onSceneAddedRemoved(int reqType,
+ const std::string &name, int eCode,
+ const AddNewSceneCallback &addCB, const RemoveSceneCallback &)
{
- if (eCode == SCENE_RESPONSE_SUCCESS)
+ switch (reqType)
{
- switch (reqType)
+ case SceneCollectionResourceRequestor::REQUEST_TYPE::ADD_SCENE:
{
- case SceneCollectionResourceRequestor::REQUEST_TYPE::ADD_SCENE:
+ if (eCode == SCENE_RESPONSE_SUCCESS)
+ {
addCB(createRemoteSceneInstance(name), SCENE_RESPONSE_SUCCESS);
- break;
-
- case SceneCollectionResourceRequestor::REQUEST_TYPE::REMOVE_SCENE:
- break;
+ }
+ else
+ {
+ addCB(nullptr, SCENE_CLIENT_BADREQUEST);
+ }
}
- }
- else
- {
- // error
+ break;
+
+ case SceneCollectionResourceRequestor::REQUEST_TYPE::REMOVE_SCENE:
+ break;
}
}
void RemoteSceneCollection::onNameSet(int eCode, const std::string &name,
const SetNameCallback &clientCB)
{
+ int result = SCENE_CLIENT_BADREQUEST;
if (eCode == SCENE_RESPONSE_SUCCESS)
+ {
m_name = name;
+ result = SCENE_RESPONSE_SUCCESS;
+ }
- clientCB(eCode);
+ clientCB(result);
}
}
#include "RemoteSceneList.h"
#include <map>
+#include <algorithm>
#include "SceneCommons.h"
#include "RemoteSceneUtils.h"
namespace Service
{
- RemoteSceneList::RemoteSceneList(SceneListResourceRequestor::Ptr pRequestor)
- : m_requestorPtr{ pRequestor }, m_getResponseHandler{}
+ RemoteSceneList::RemoteSceneList(SceneListResourceRequestor::Ptr requestor)
+ : m_requestorPtr{ requestor }, m_getResponseHandler{}
{
}
- void RemoteSceneList::createInstance(RCSRemoteResourceObject::Ptr pSceneListResource,
+ void RemoteSceneList::createInstance(RCSRemoteResourceObject::Ptr sceneListResource,
CreateInstanceCallback clientCB)
{
- // TODO: check pRequestor not null
+ if (sceneListResource == nullptr)
+ {
+ throw RCSInvalidParameterException("Scene List resource object is null");
+ }
- SceneListResourceRequestor::Ptr pRequestor =
- std::make_shared< SceneListResourceRequestor >(pSceneListResource);
+ std::vector< std::string > rts = sceneListResource->getTypes();
+ auto it = std::find(rts.begin(), rts.end(), SCENE_LIST_RT);
+ if (it == rts.end())
+ {
+ throw RCSInvalidParameterException(
+ "Remote resource object is not a Scene List Resource");
+ }
- RemoteSceneList::Ptr newSceneList(new RemoteSceneList(pRequestor));
+ SceneListResourceRequestor::Ptr pRequestor =
+ std::make_shared< SceneListResourceRequestor >(sceneListResource);
- clientCB(std::move(newSceneList), SCENE_RESPONSE_SUCCESS);
+ std::string requestIf = OC::DEFAULT_INTERFACE;
+ pRequestor->requestGet(requestIf, std::bind(
+ &RemoteSceneList::onInstanceCreated,
+ std::placeholders::_2, std::placeholders::_3, requestIf,
+ pRequestor, std::move(clientCB)));
}
void RemoteSceneList::addNewSceneCollection(AddNewSceneCollectionCallback clientCB)
{
SceneListResourceRequestor::InternalCreateSceneCollectionCallback internalCB
= std::bind(&RemoteSceneList::onSceneCollectionCreated, this,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
- std::placeholders::_4, std::move(clientCB));
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
+ std::placeholders::_4, std::move(clientCB));
m_requestorPtr->requestSceneCollectionCreation("", internalCB);
}
}
std::vector< RemoteSceneCollection::Ptr >
- RemoteSceneList::getRemoteSceneCollections() const
+ RemoteSceneList::getRemoteSceneCollections() const
{
return m_remoteSceneCollections;
}
{
SceneListResourceRequestor::InternalSetNameCallback internalCB
= std::bind(&RemoteSceneList::onNameSet, this,
- std::placeholders::_1, name, std::move(clientCB));
+ std::placeholders::_1, name, std::move(clientCB));
m_requestorPtr->requestSetName(name, internalCB);
}
return m_name;
}
- RemoteSceneCollection::Ptr RemoteSceneList::createRemoteSceneCollectionInstance
- (const std::string &link, const std::string &id, const std::string &name)
+ void RemoteSceneList::onInstanceCreated(
+ const RCSRepresentation &rep, int eCode, const std::string &If,
+ SceneListResourceRequestor::Ptr requestor, const CreateInstanceCallback &cb)
+ {
+ if (eCode == OC_STACK_OK)
+ {
+ if (If == OC::DEFAULT_INTERFACE)
+ {
+ auto retPtr = buildSceneList(requestor, rep.getAttributes());
+ cb(std::move(retPtr), SCENE_RESPONSE_SUCCESS);
+ }
+ else if (If == OC::BATCH_INTERFACE)
+ {
+ // TODO build remote scene list instance with batch interface.
+ }
+ else
+ {
+ // TODO error handle.
+ }
+ }
+ }
+
+ RemoteSceneList::Ptr RemoteSceneList::buildSceneList(
+ SceneListResourceRequestor::Ptr requestor, const RCSResourceAttributes &attrs)
{
- RemoteSceneCollection::Ptr pNewSceneCollection = nullptr;
+ RemoteSceneList::Ptr newList(new RemoteSceneList(requestor));
- std::vector< std::string > vecRT{ SCENE_COLLECTION_RT };
- std::vector< std::string > vecIF{ SCENE_CLIENT_REQ_IF };
+ auto collections = newList->parseSceneListFromAttributes(attrs);
- RCSRemoteResourceObject::Ptr pResource
- = createRCSResourceObject(link, SCENE_CONNECTIVITY, vecRT, vecIF);
+ try
+ {
+ for (const auto &itr : collections)
+ {
+ auto collection = itr.first;
+ auto host = newList->getListResourceRequestor()
+ ->getRemoteResourceObject()->getAddress();
+
+ RemoteSceneCollection::Ptr newCollection
+ = newList->createRemoteSceneCollectionInstance(
+ host + collection.at("uri").get< std::string >(),
+ collection.at(SCENE_KEY_ID).get< std::string >(),
+ collection.at(SCENE_KEY_NAME).get< std::string >());
- if (pResource)
+ newCollection->initializeRemoteSceneCollection(itr.second, host);
+ }
+ }
+ catch (const std::exception &e)
{
- SceneCollectionResourceRequestor::Ptr pRequestor
- { new SceneCollectionResourceRequestor(pResource) };
+ SCENE_CLIENT_PRINT_LOG(e.what());
+ }
+
+ return std::move(newList);
+ }
- pNewSceneCollection.reset(
+ RemoteSceneCollection::Ptr RemoteSceneList::createRemoteSceneCollectionInstance(
+ const std::string &link, const std::string &id, const std::string &name)
+ {
+ try
+ {
+ std::vector< std::string > vecRT{ SCENE_COLLECTION_RT };
+ std::vector< std::string > vecIF{ SCENE_CLIENT_REQ_IF };
+
+ RCSRemoteResourceObject::Ptr pResource
+ = SceneUtils::createRCSResourceObject(link, SCENE_CONNECTIVITY, vecRT, vecIF);
+
+ SceneCollectionResourceRequestor::Ptr pRequestor(
+ new SceneCollectionResourceRequestor(pResource));
+
+ RemoteSceneCollection::Ptr newCollection(
new RemoteSceneCollection(pRequestor, id, name));
+
+ {
+ std::lock_guard< std::mutex > collectionlock(m_collectionLock);
+ m_remoteSceneCollections.push_back(newCollection);
+ }
- m_remoteSceneCollections.push_back(pNewSceneCollection);
+ return newCollection;
+ }
+ catch (const std::exception &e)
+ {
+ SCENE_CLIENT_PRINT_LOG(e.what());
+ return nullptr;
}
+ }
- return pNewSceneCollection;
+ SceneListResourceRequestor::Ptr RemoteSceneList::getListResourceRequestor() const
+ {
+ return m_requestorPtr;
}
- void RemoteSceneList::setGetResponseHandler
- (const std::string &host, GetResponseHandler::GetCallback cb)
+ 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));
}
- void RemoteSceneList::onSceneCollectionCreated
- (const std::string &link, const std::string &id, const std::string &name, int eCode,
- AddNewSceneCollectionCallback clientCB)
+ std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
+ RemoteSceneList::parseSceneListFromAttributes(const RCSResourceAttributes & listAttrs)
+ {
+ std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
+ retParsed;
+
+ auto collectionsResourceAttrs = getChildrenAttributes(listAttrs);
+
+ for (unsigned int i = 0; i < collectionsResourceAttrs.size(); ++i)
+ {
+ retParsed.push_back(
+ std::make_pair(
+ collectionsResourceAttrs[i],
+ getChildrenAttributes(collectionsResourceAttrs[i])));
+ }
+
+ return retParsed;
+ }
+
+ std::vector<RCSResourceAttributes> RemoteSceneList::getChildrenAttributes(
+ const RCSResourceAttributes & attrs) const
+ {
+ const std::string SCENE_CHILD = "child";
+
+ std::vector<RCSResourceAttributes> retChildren = {};
+
+ if (attrs.contains(SCENE_CHILD))
+ {
+ retChildren
+ = attrs.at(SCENE_CHILD).get<std::vector<RCSResourceAttributes>>();
+ }
+
+ return retChildren;
+ }
+
+ void RemoteSceneList::onSceneCollectionCreated(
+ const std::string &link, const std::string &id, const std::string &name, int eCode,
+ const AddNewSceneCollectionCallback &clientCB)
{
int result = SCENE_CLIENT_BADREQUEST;
- RemoteSceneCollection::Ptr pNewRemoteSceneCollection = nullptr;
+ RemoteSceneCollection::Ptr newCollection = nullptr;
if (eCode == SCENE_RESPONSE_SUCCESS)
{
- pNewRemoteSceneCollection =
+ newCollection =
createRemoteSceneCollectionInstance(link, id, name);
- // TODO: result type check
- if (pNewRemoteSceneCollection)
+ if (newCollection)
result = SCENE_RESPONSE_SUCCESS;
}
- clientCB(pNewRemoteSceneCollection, result);
+
+ clientCB(newCollection, result);
}
void RemoteSceneList::onNameSet(int eCode, const std::string &name,
- const SetNameCallback &clientCB)
+ const SetNameCallback &clientCB)
{
+ int result = SCENE_CLIENT_BADREQUEST;
if (eCode == SCENE_RESPONSE_SUCCESS)
+ {
m_name = name;
-
- clientCB(eCode);
+ result = SCENE_RESPONSE_SUCCESS;
+ }
+
+ clientCB(result);
}
- RemoteSceneList::GetResponseHandler::GetResponseHandler
- (std::shared_ptr< RemoteSceneList > ptr)
- : m_errorCode{ SCENE_RESPONSE_SUCCESS }, m_owner{ ptr }
+ 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)
+ void RemoteSceneList::GetResponseHandler::startGetResponseHandler(
+ const std::string &host, GetCallback cb)
{
RCSRemoteResourceObject::GetCallback ListGetCB
= std::bind(&GetResponseHandler::onGetListAttrs, this,
- std::placeholders::_1, std::placeholders::_2,
- std::placeholders::_3,
- host);
+ std::placeholders::_2, std::placeholders::_3, host);
m_cb = cb;
- std::shared_ptr< RemoteSceneList > pList = m_owner.lock();
+ std::shared_ptr< RemoteSceneList > list = m_owner.lock();
- if (pList)
+ if (list)
{
- pList->m_requestorPtr->
- requestGet(SCENE_CLIENT_CREATE_REQ_IF, ListGetCB);
+ list->getListResourceRequestor()
+ ->requestGet(SCENE_CLIENT_CREATE_REQ_IF, ListGetCB);
}
}
- void RemoteSceneList::GetResponseHandler::onGetListAttrs
- (const HeaderOpts &, const RCSRepresentation &rep,
- int eCode, const std::string &host)
+ void RemoteSceneList::GetResponseHandler::onGetListAttrs(
+ const RCSRepresentation &rep, int eCode, const std::string &host)
{
- if (eCode == SCENE_RESPONSE_SUCCESS)
+ if (eCode == OC_STACK_OK)
{
- std::shared_ptr< RemoteSceneList > pList = m_owner.lock();
+ std::shared_ptr< RemoteSceneList > list = m_owner.lock();
- if (pList)
+ if (list == nullptr)
{
- pList->m_name
- = rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >();
+ SCENE_CLIENT_PRINT_LOG("remote scene list deleted.");
+ return;
+ }
- std::vector< RCSRepresentation > childReps
- = rep.getChildren();
+ list->m_name
+ = rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >();
- if (childReps.size() > 0)
+ std::vector< RCSRepresentation > childReps = rep.getChildren();
+
+ if (childReps.size() > 0)
+ {
+ for (const auto &itr : childReps)
{
- for (auto itr : childReps)
- {
- std::vector< std::string > childRTs = itr.getResourceTypes();
- if (std::find(childRTs.begin(), childRTs.end(), SCENE_COLLECTION_RT)
+ std::vector< std::string > childRTs = itr.getResourceTypes();
+ if (std::find(childRTs.begin(), childRTs.end(), SCENE_COLLECTION_RT)
!= childRTs.end())
- {
- RCSResourceAttributes attr = itr.getAttributes();
- RemoteSceneCollection::Ptr pNewSceneCollection
- = pList->createRemoteSceneCollectionInstance(
- host + rep.getUri(),
- attr.at(SCENE_KEY_ID).get< std::string >(),
- attr.at(SCENE_KEY_NAME).get< std::string >());
-
- if (pNewSceneCollection == nullptr)
- {
- // error
- continue;
- }
-
- RCSRemoteResourceObject::GetCallback handlerGetCB
- = std::bind(&GetResponseHandler::onGetCollectionAttrs,
- this, std::placeholders::_1,
- std::placeholders::_2, std::placeholders::_3,
- pNewSceneCollection, host);
-
- pNewSceneCollection->m_requestorPtr->requestGet(
- SCENE_CLIENT_REQ_IF, handlerGetCB);
- }
+ {
+ 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
{
- // error
+ // TODO error
}
}
- void RemoteSceneList::GetResponseHandler::onGetCollectionAttrs
- (const HeaderOpts &, const RCSRepresentation &reps, int eCode,
- RemoteSceneCollection::Ptr pRemoteSceneCollection, const std::string &host)
+ void RemoteSceneList::GetResponseHandler::onGetCollectionAttrs(
+ const RCSRepresentation &reps, int eCode,
+ RemoteSceneCollection::Ptr collection, const std::string &host)
{
m_respondedCollections++;
- if (eCode == SCENE_RESPONSE_SUCCESS)
+ if (eCode == OC_STACK_OK)
{
- pRemoteSceneCollection->
- initializeRemoteSceneCollection(reps.getChildren(), std::string(host));
+ 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->
+ initializeRemoteSceneCollection(childrenAttr, host);
}
else
{
- // error
- m_errorCode = eCode;
+ // TODO error
+ m_errorCode = SCENE_CLIENT_BADREQUEST;
}
if (m_respondedCollections == m_numOfCollections)
{
- m_cb(eCode);
+ m_cb(m_errorCode);
}
}
+++ /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 "RemoteSceneUtils.h"
-
-namespace OIC
-{
- namespace Service
- {
-
- RCSRemoteResourceObject::Ptr createRCSResourceObject(
- const std::string &address, const OCConnectivityType ct,
- const std::vector< std::string > &vecRT, const std::vector< std::string > &vecIF)
- {
- RCSRemoteResourceObject::Ptr pResource = nullptr;
-
- std::string hostaddress, uri;
- SceneUtils::getHostUriString(address, &hostaddress, &uri);
-
- OC::OCResource::Ptr pOCResource =
- OC::OCPlatform::constructResourceObject
- (hostaddress, uri, ct, false, vecRT, vecIF);
-
- if (pOCResource)
- {
- pResource = RCSRemoteResourceObject::fromOCResource(pOCResource);
- }
-
- return pResource;
- }
-
- }
-}
\ No newline at end of file
#include <cassert>
-#include "OCApi.h"
#include "logger.h"
-#include "RCSRemoteResourceObject.h"
-#include "OCPlatform.h"
-#include "SceneCommons.h"
#define SCENE_CLIENT_PRINT_LOG(strError) \
OIC_LOG_V(ERROR, "[SCENE_CLIENT]", "%s:%d %s", __PRETTY_FUNCTION__, __LINE__, strError);
} \
}
-namespace OIC
-{
- namespace Service
- {
-
- const OCConnectivityType SCENE_CONNECTIVITY = CT_ADAPTER_IP;
- const std::string SCENE_CLIENT_REQ_IF = OC::DEFAULT_INTERFACE;
- const std::string SCENE_CLIENT_CREATE_REQ_IF = OC::BATCH_INTERFACE;
-
- enum class SceneResource
- {
- List = 0,
- Collection,
- Member
- };
-
- // This function will be moved to SceneUtills.cpp
- RCSRemoteResourceObject::Ptr createRCSResourceObject(
- const std::string &address, const OCConnectivityType ct,
- const std::vector< std::string > &vecRT, const std::vector< std::string > &vecIF);
-
- }
-}
-
#endif // REMOTE_SCENE_UTILS_H
\ No newline at end of file
namespace Service
{
- SceneCollectionResourceRequestor::SceneCollectionResourceRequestor
- (RCSRemoteResourceObject::Ptr pSceneCollection)
- : m_SceneCollectionResourcePtr{ pSceneCollection }
+ SceneCollectionResourceRequestor::SceneCollectionResourceRequestor(
+ RCSRemoteResourceObject::Ptr collectionResource)
+ : m_sceneCollectionResource{ collectionResource }
{
- SCENE_CLIENT_ASSERT_NOT_NULL(pSceneCollection);
+ SCENE_CLIENT_ASSERT_NOT_NULL(collectionResource);
}
- SceneCollectionResourceRequestor::~SceneCollectionResourceRequestor()
- {
-
- }
-
- void SceneCollectionResourceRequestor::requestSceneCreation
- (const std::string &name, InternalSceneRequestCallback createSceneCB)
+ void SceneCollectionResourceRequestor::requestSceneCreation(
+ const std::string &name, InternalSceneRequestCallback createSceneCB)
{
RCSResourceAttributes attributesToSet;
- std::vector< std::string > vecScenes{ name };
-
- attributesToSet[SCENE_KEY_SCENEVALUES] = vecScenes;
+ std::vector< std::string > scenenames{ name };
+
+ attributesToSet[SCENE_KEY_SCENEVALUES] = scenenames;
RCSRemoteResourceObject::RemoteAttributesSetCallback setRequestCB
= std::bind(&SceneCollectionResourceRequestor::onSetResponseForScene,
name, std::move(createSceneCB), ADD_SCENE,
SceneCollectionResourceRequestor::wPtr(shared_from_this()));
- m_SceneCollectionResourcePtr->setRemoteAttributes(
+ m_sceneCollectionResource->setRemoteAttributes(
std::move(attributesToSet), std::move(setRequestCB));
}
void SceneCollectionResourceRequestor::requestSceneRemoval
- (const std::string &/* name */, InternalSceneRequestCallback /* removeSceneCB */)
+ (const std::string &/* name */, InternalSceneRequestCallback)
{
}
name, std::move(executeSceneCB), EXECUTE_SCENE,
SceneCollectionResourceRequestor::wPtr(shared_from_this()));
- m_SceneCollectionResourcePtr->setRemoteAttributes
- (std::move(attributesToSet), std::move(setRequestCB));
+ m_sceneCollectionResource->setRemoteAttributes(
+ std::move(attributesToSet), std::move(setRequestCB));
}
- void SceneCollectionResourceRequestor::requestAddSceneMember
- (RCSRemoteResourceObject::Ptr pMember, const std::string &sceneName,
- const RCSResourceAttributes &attr, InternalAddMemberCallback addMemberCB)
+ void SceneCollectionResourceRequestor::requestAddSceneMember(
+ RCSRemoteResourceObject::Ptr targetResource, const std::string &sceneName,
+ const RCSResourceAttributes &attr, InternalAddMemberCallback addMemberCB)
{
- SCENE_CLIENT_ASSERT_NOT_NULL(pMember);
+ SCENE_CLIENT_ASSERT_NOT_NULL(targetResource);
RCSResourceAttributes attributesToSet, linkAttrs;
- linkAttrs[SCENE_KEY_HREF] = pMember->getAddress() + pMember->getUri();
- linkAttrs[SCENE_KEY_IF] = pMember->getInterfaces();
- linkAttrs[SCENE_KEY_RT] = pMember->getTypes();
+ linkAttrs[SCENE_KEY_HREF] = targetResource->getAddress() + targetResource->getUri();
+ linkAttrs[SCENE_KEY_IF] = targetResource->getInterfaces();
+ linkAttrs[SCENE_KEY_RT] = targetResource->getTypes();
attributesToSet[SCENE_KEY_PAYLOAD_LINK] = linkAttrs;
RCSRemoteResourceObject::SetCallback setRequestCB
= std::bind(&SceneCollectionResourceRequestor::onSceneMemberAdded,
- std::placeholders::_1, std::placeholders::_2,
- std::placeholders::_3,
- pMember->getAddress() + pMember->getUri(),
+ std::placeholders::_2, std::placeholders::_3,
+ targetResource->getAddress() + targetResource->getUri(),
std::move(addMemberCB),
SceneCollectionResourceRequestor::wPtr(shared_from_this()));
RCSQueryParams queryParams;
queryParams.setResourceInterface(SCENE_CLIENT_CREATE_REQ_IF);
- m_SceneCollectionResourcePtr->set(queryParams, std::move(attributesToSet),
+ m_sceneCollectionResource->set(queryParams, std::move(attributesToSet),
std::move(setRequestCB));
}
void SceneCollectionResourceRequestor::requestSetName
- (const std::string &, InternalSetNameCallback)
+ (const std::string &name, InternalSetNameCallback internalCB)
{
+ RCSResourceAttributes attrs;
+ attrs[SCENE_KEY_NAME] = name;
+
+ RCSRemoteResourceObject::SetCallback setRequestCB
+ = std::bind(&SceneCollectionResourceRequestor::onNameSet,
+ std::placeholders::_2, std::placeholders::_3, name, std::move(internalCB),
+ SceneCollectionResourceRequestor::wPtr(shared_from_this()));
+
+ RCSQueryParams queryParams;
+ queryParams.setResourceInterface(SCENE_CLIENT_REQ_IF);
+ m_sceneCollectionResource->set(queryParams, std::move(attrs), std::move(setRequestCB));
}
void SceneCollectionResourceRequestor::requestGet(
RCSQueryParams params;
params.setResourceInterface(ifType);
- m_SceneCollectionResourcePtr->get(params, cb);
+ m_sceneCollectionResource->get(params, cb);
}
- RCSRemoteResourceObject::Ptr SceneCollectionResourceRequestor::getRemoteResourceObject()
+ RCSRemoteResourceObject::Ptr
+ SceneCollectionResourceRequestor::getRemoteResourceObject() const
{
- return m_SceneCollectionResourcePtr;
+ return m_sceneCollectionResource;
}
SceneMemberResourceRequestor::Ptr
SceneCollectionResourceRequestor::createSceneMemberResourceRequestor(
- const std::string &memLink, const std::string &id, const std::string &targetlink)
+ const std::string &memHref, const std::string &id, const std::string &targetHref)
{
- SceneMemberResourceRequestor::Ptr pMemRequestor = nullptr;
-
- std::vector< std::string > vecRT{ SCENE_MEMBER_RT };
- std::vector< std::string > vecIF{ SCENE_CLIENT_REQ_IF };
+ try
+ {
+ std::vector< std::string > vecRT{ SCENE_MEMBER_RT };
+ std::vector< std::string > vecIF{ SCENE_CLIENT_REQ_IF };
- RCSRemoteResourceObject::Ptr pResource
- = createRCSResourceObject(memLink, SCENE_CONNECTIVITY, vecRT, vecIF);
+ RCSRemoteResourceObject::Ptr pResource
+ = SceneUtils::createRCSResourceObject(
+ memHref, SCENE_CONNECTIVITY, vecRT, vecIF);
- if (pResource)
- {
- pMemRequestor =
+ SceneMemberResourceRequestor::Ptr pMemRequestor =
std::make_shared< SceneMemberResourceRequestor >(pResource, id);
- m_mapMemberRequestors[targetlink] = pMemRequestor;
- }
+ {
+ std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
+ m_memberRequestors[targetHref] = pMemRequestor;
+ }
- return pMemRequestor;
+ return pMemRequestor;
+ }
+ catch (const std::exception &e)
+ {
+ SCENE_CLIENT_PRINT_LOG(e.what());
+ return nullptr;
+ }
}
SceneMemberResourceRequestor::Ptr
- SceneCollectionResourceRequestor::getSceneMemberResourceRequestor
- (const std::string &memLink)
+ SceneCollectionResourceRequestor::getSceneMemberResourceRequestor(
+ const std::string &targetHref) const
{
- return m_mapMemberRequestors.find(memLink) != m_mapMemberRequestors.end() ?
- m_mapMemberRequestors.at(memLink) : nullptr;
+ std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
+
+ return m_memberRequestors.find(targetHref) != m_memberRequestors.end() ?
+ m_memberRequestors.at(targetHref) : nullptr;
}
- void SceneCollectionResourceRequestor::onSetResponseForScene
- (const RCSResourceAttributes &attrs, int eCode,
- const std::string &name, const InternalSceneRequestCallback &cb,
- REQUEST_TYPE reqType, SceneCollectionResourceRequestor::wPtr ptr)
+ void SceneCollectionResourceRequestor::onSetResponseForScene(
+ const RCSResourceAttributes &attrs, int eCode,
+ const std::string &name, const InternalSceneRequestCallback &cb,
+ REQUEST_TYPE reqType, SceneCollectionResourceRequestor::wPtr ptr)
{
SceneCollectionResourceRequestor::Ptr collectionPtr = ptr.lock();
if (collectionPtr)
+ {
collectionPtr->onSetResponseForScene_impl(
std::move(attrs), eCode, name, std::move(cb), reqType);
+ }
}
- void SceneCollectionResourceRequestor::onSetResponseForScene_impl
- (const RCSResourceAttributes &attrs, int eCode, const std::string &name,
- const InternalSceneRequestCallback &internalCB, REQUEST_TYPE reqType)
+ void SceneCollectionResourceRequestor::onSetResponseForScene_impl(
+ const RCSResourceAttributes &attrs, int eCode, const std::string &name,
+ const InternalSceneRequestCallback &internalCB, REQUEST_TYPE reqType)
{
- // TODO: error code
+ // TODO error code
int resultCode = SCENE_CLIENT_BADREQUEST;
if (eCode == OC_STACK_OK)
case ADD_SCENE:
{
auto scenes
- = attrs.at(SCENE_KEY_SCENEVALUES).get
- < std::vector< std::string > >();
+ = attrs.at(SCENE_KEY_SCENEVALUES).
+ get< std::vector< std::string > >();
if ((std::find(scenes.begin(), scenes.end(), name))
!= scenes.end())
+ {
resultCode = SCENE_RESPONSE_SUCCESS;
+ }
}
break;
= attrs.at(SCENE_KEY_LAST_SCENE).get< std::string >();
if (lastScene.compare(name) == 0)
+ {
resultCode = SCENE_RESPONSE_SUCCESS;
+ }
}
break;
}
internalCB(reqType, name, resultCode);
}
- void SceneCollectionResourceRequestor::onSceneMemberAdded
- (const HeaderOpts &headOpt, const RCSRepresentation &rep, int eCode,
- const std::string &targetLink, const InternalAddMemberCallback &internalCB,
- SceneCollectionResourceRequestor::wPtr ptr)
+ void SceneCollectionResourceRequestor::onSceneMemberAdded(
+ const RCSRepresentation &rep, int eCode,
+ const std::string &targetHref, const InternalAddMemberCallback &internalCB,
+ SceneCollectionResourceRequestor::wPtr ptr)
{
- SceneCollectionResourceRequestor::Ptr pSceneCollectionRequestor
- = ptr.lock();
+ SceneCollectionResourceRequestor::Ptr collection = ptr.lock();
- if (pSceneCollectionRequestor)
- pSceneCollectionRequestor->onSceneMemberAdded_impl(
- headOpt, rep, eCode, targetLink, std::move(internalCB));
+ if (collection)
+ {
+ collection->onSceneMemberAdded_impl(
+ std::move(rep), eCode, targetHref, std::move(internalCB));
+ }
}
- void SceneCollectionResourceRequestor::onSceneMemberAdded_impl
- (const HeaderOpts &, const RCSRepresentation &rep, int eCode,
- const std::string &targetLink, const InternalAddMemberCallback &internalCB)
+ void SceneCollectionResourceRequestor::onSceneMemberAdded_impl(
+ const RCSRepresentation &rep, int eCode,
+ const std::string &targetHref, const InternalAddMemberCallback &internalCB)
{
- // TODO: error code
+ // TODO error code
int result = SCENE_CLIENT_BADREQUEST;
- SceneMemberResourceRequestor::Ptr pMemRequestor = nullptr;
+ SceneMemberResourceRequestor::Ptr memRequestor = nullptr;
if (eCode == OC_STACK_OK)
{
{
RCSResourceAttributes receivedAttrs = rep.getAttributes();
- pMemRequestor
+ memRequestor
= createSceneMemberResourceRequestor(
receivedAttrs.at(SCENE_KEY_CREATEDLINK).get< std::string >(),
receivedAttrs.at(SCENE_KEY_ID).get< std::string >(),
- targetLink);
+ targetHref);
- if (pMemRequestor)
- result = SCENE_RESPONSE_SUCCESS;
+ if (memRequestor) result = SCENE_RESPONSE_SUCCESS;
}
catch (const std::exception &e)
{
}
}
- internalCB(pMemRequestor, result);
+ internalCB(result);
+ }
+
+ void SceneCollectionResourceRequestor::onNameSet(const RCSRepresentation &rep, int eCode,
+ const std::string &name, const InternalSetNameCallback &internalCB,
+ SceneCollectionResourceRequestor::wPtr ptr)
+ {
+ SceneCollectionResourceRequestor::Ptr collectionPtr = ptr.lock();
+
+ if (collectionPtr)
+ {
+ collectionPtr->onNameSet_impl(std::move(rep), eCode, name, std::move(internalCB));
+ }
+ }
+
+ void SceneCollectionResourceRequestor::onNameSet_impl(
+ const RCSRepresentation &rep, int eCode, const std::string &name,
+ const InternalSetNameCallback &internalCB)
+ {
+ int result = SCENE_CLIENT_BADREQUEST;
+ if (eCode == OC_STACK_OK)
+ {
+ if (rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >() == name)
+ {
+ result = SCENE_RESPONSE_SUCCESS;
+ }
+
+ }
+
+ internalCB(result);
}
}
#define SM_SCENECOLLECTION_RESOURCE_REQUESTOR_H_
#include <map>
+#include <mutex>
#include "SceneCommons.h"
#include "RCSRemoteResourceObject.h"
ADD_SCENE, REMOVE_SCENE, EXECUTE_SCENE
};
- typedef std::function
- < void(const REQUEST_TYPE, const std::string &name, int eCode) >
- InternalSceneRequestCallback;
+ typedef std::function<
+ void(REQUEST_TYPE, const std::string &name, int eCode) >
+ InternalSceneRequestCallback;
- typedef std::function
- < void(SceneMemberResourceRequestor::Ptr, int eCode) > InternalAddMemberCallback;
-
- typedef std::function
- < void(int eCode) > InternalSetNameCallback;
+ typedef std::function < void(int eCode) > InternalAddMemberCallback;
+ typedef std::function < void(int eCode) > InternalSetNameCallback;
public:
- SceneCollectionResourceRequestor(RCSRemoteResourceObject::Ptr pSceneCollection);
- ~SceneCollectionResourceRequestor();
+ SceneCollectionResourceRequestor(RCSRemoteResourceObject::Ptr collectionResource);
+ ~SceneCollectionResourceRequestor() = default;
void requestSceneCreation(const std::string &name, InternalSceneRequestCallback);
void requestSceneRemoval(const std::string &name, InternalSceneRequestCallback);
void requestSceneExecution(const std::string &name, InternalSceneRequestCallback);
- void requestAddSceneMember(RCSRemoteResourceObject::Ptr pMember,
+ void requestAddSceneMember(RCSRemoteResourceObject::Ptr targetResource,
const std::string &sceneName,
const RCSResourceAttributes &attr,
InternalAddMemberCallback);
void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
- RCSRemoteResourceObject::Ptr getRemoteResourceObject();
+ RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
SceneMemberResourceRequestor::Ptr createSceneMemberResourceRequestor(
- const std::string &memlink, const std::string &id,
- const std::string &targetlink);
+ const std::string &memHref, const std::string &id,
+ const std::string &targetHref);
SceneMemberResourceRequestor::Ptr getSceneMemberResourceRequestor(
- const std::string &link);
-
+ const std::string &targetHref) const;
private:
static void onSetResponseForScene(
REQUEST_TYPE);
static void onSceneMemberAdded(
- const HeaderOpts &, const RCSRepresentation &, int eCode,
+ const RCSRepresentation &, int eCode,
const std::string &, const InternalAddMemberCallback &,
SceneCollectionResourceRequestor::wPtr);
void onSceneMemberAdded_impl(
- const HeaderOpts &, const RCSRepresentation &, int eCode,
+ const RCSRepresentation &, int eCode,
const std::string &, const InternalAddMemberCallback &);
+ static void onNameSet(const RCSRepresentation &, int eCode, const std::string &,
+ const InternalSetNameCallback &, SceneCollectionResourceRequestor::wPtr);
+
+ void onNameSet_impl(const RCSRepresentation &, int eCode, const std::string &,
+ const InternalSetNameCallback &);
private:
- RCSRemoteResourceObject::Ptr m_SceneCollectionResourcePtr;
- std::map< std::string, SceneMemberResourceRequestor::Ptr > m_mapMemberRequestors;
+ RCSRemoteResourceObject::Ptr m_sceneCollectionResource;
+ mutable std::mutex m_memberRequestorLock;
+ std::map< std::string, SceneMemberResourceRequestor::Ptr > m_memberRequestors;
};
-
+
}
}
#define SCENE_COMMONS_H
#include <string>
+#include <vector>
+
+#include "OCApi.h"
+#include "RCSRemoteResourceObject.h"
namespace OIC
{
const std::string PREFIX_SCENE_COLLECTION_URI = "/a/sceneCollection";
const std::string PREFIX_SCENE_MEMBER_URI = "/a/sceneMember";
+ const OCConnectivityType SCENE_CONNECTIVITY = CT_ADAPTER_IP;
+ const std::string SCENE_CLIENT_REQ_IF = OC::DEFAULT_INTERFACE;
+ const std::string SCENE_CLIENT_CREATE_REQ_IF = OC::BATCH_INTERFACE;
+
const int SCENE_RESPONSE_SUCCESS = 200;
const int SCENE_CLIENT_BADREQUEST = 400;
const int SCENE_SERVER_INTERNALSERVERERROR = 500;
* @throw RCSException
*/
static std::string getNetAddress();
+
+ /**
+ * Returns RCSRemoteResourceObject pointer created with provided resource information.
+ *
+ * @param address uri of resource (e.g. coap://192.168.0.2:12345/a/light)
+ * @param ct OCConnectivityType type of connectivity indicating the interface
+ * @param vecRT a vector of resource types implemented by the resource
+ * @param vecIF a vector of interfaces that the resource supports/implements
+ *
+ * @throw RCSException
+ */
+ static RCSRemoteResourceObject::Ptr createRCSResourceObject(
+ const std::string &address, const OCConnectivityType ct,
+ const std::vector< std::string > &vecRT, const std::vector< std::string > &vecIF);
};
}
}
namespace Service
{
- SceneListResourceRequestor::SceneListResourceRequestor
- (RCSRemoteResourceObject::Ptr pSceneList)
- : m_SceneListResourcePtr{ pSceneList }
+ SceneListResourceRequestor::SceneListResourceRequestor(
+ RCSRemoteResourceObject::Ptr listResource)
+ : m_sceneListResource{ listResource }
{
- SCENE_CLIENT_ASSERT_NOT_NULL(pSceneList);
+ SCENE_CLIENT_ASSERT_NOT_NULL(listResource);
}
- SceneListResourceRequestor::~SceneListResourceRequestor()
- {
-
- }
-
- void SceneListResourceRequestor::requestSceneCollectionCreation
- (const std::string &name, InternalCreateSceneCollectionCallback internalCB)
+ void SceneListResourceRequestor::requestSceneCollectionCreation(
+ const std::string &name, InternalCreateSceneCollectionCallback internalCB)
{
RCSResourceAttributes attrs;
attrs[SCENE_KEY_NAME] = name;
RCSRemoteResourceObject::SetCallback setRequestCB
= std::bind(&SceneListResourceRequestor::onSceneCollectionCreated,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
+ std::placeholders::_2, std::placeholders::_3,
name, std::move(internalCB),
SceneListResourceRequestor::wPtr(shared_from_this()));
RCSQueryParams queryParams;
queryParams.setResourceInterface(SCENE_CLIENT_CREATE_REQ_IF);
- m_SceneListResourcePtr->set(queryParams, std::move(attrs), std::move(setRequestCB));
+ m_sceneListResource->set(queryParams, std::move(attrs), std::move(setRequestCB));
}
void SceneListResourceRequestor::requestSetName
- (const std::string &, InternalSetNameCallback)
+ (const std::string &name, InternalSetNameCallback internalCB)
{
+ RCSResourceAttributes attrs;
+ attrs[SCENE_KEY_NAME] = name;
+
+ RCSRemoteResourceObject::SetCallback setRequestCB
+ = std::bind(&SceneListResourceRequestor::onNameSet,
+ std::placeholders::_2, std::placeholders::_3, name, std::move(internalCB),
+ SceneListResourceRequestor::wPtr(shared_from_this()));
+ RCSQueryParams queryParams;
+ queryParams.setResourceInterface(SCENE_CLIENT_REQ_IF);
+
+ m_sceneListResource->set(queryParams, std::move(attrs), std::move(setRequestCB));
}
void SceneListResourceRequestor::requestGet(
RCSQueryParams params;
params.setResourceInterface(ifType);
- m_SceneListResourcePtr->get(params, cb);
+ m_sceneListResource->get(params, cb);
}
- RCSRemoteResourceObject::Ptr SceneListResourceRequestor::getRemoteResourceObject()
+ RCSRemoteResourceObject::Ptr SceneListResourceRequestor::getRemoteResourceObject() const
{
- return m_SceneListResourcePtr;
+ return m_sceneListResource;
}
- void SceneListResourceRequestor::onSceneCollectionCreated
- (const HeaderOpts &headOpts, const RCSRepresentation &rep, int eCode,
- const std::string &name, const InternalCreateSceneCollectionCallback &cb,
- SceneListResourceRequestor::wPtr ptr)
+ void SceneListResourceRequestor::onSceneCollectionCreated(
+ const RCSRepresentation &rep, int eCode,
+ const std::string &name, const InternalCreateSceneCollectionCallback &cb,
+ SceneListResourceRequestor::wPtr ptr)
{
SceneListResourceRequestor::Ptr listPtr = ptr.lock();
if (listPtr)
- listPtr->onSceneCollectionCreated_impl(headOpts, std::move(rep), eCode,
- name, std::move(cb));
+ {
+ listPtr->onSceneCollectionCreated_impl(std::move(rep), eCode, name, std::move(cb));
+ }
}
- void SceneListResourceRequestor::onSceneCollectionCreated_impl
- (const HeaderOpts &, const RCSRepresentation &rep, int eCode,
- const std::string &name, const InternalCreateSceneCollectionCallback &internalCB)
+ void SceneListResourceRequestor::onSceneCollectionCreated_impl(
+ const RCSRepresentation &rep, int eCode,
+ const std::string &name, const InternalCreateSceneCollectionCallback &internalCB)
{
- // TODO: error code
int result = SCENE_CLIENT_BADREQUEST;
std::string link, id;
internalCB(link, id, name, result);
}
- std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
- SceneListResourceRequestor::parseSceneListFromAttributes(
- const RCSResourceAttributes & listAttrs)
- {
- std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
- retParsed;
-
- auto collectionsResourceAttrs = getChildrenAttributes(listAttrs);
-
- for(unsigned int i = 0; i < collectionsResourceAttrs.size(); ++i)
- {
- retParsed.push_back(
- std::make_pair(
- collectionsResourceAttrs[i],
- getChildrenAttributes(collectionsResourceAttrs[i])));
- }
-
- return retParsed;
- }
-
- std::vector<RCSResourceAttributes> SceneListResourceRequestor::getChildrenAttributes(
- const RCSResourceAttributes & attrs) const
+ void SceneListResourceRequestor::onNameSet(const RCSRepresentation &rep, int eCode,
+ const std::string &name, const InternalSetNameCallback &internalCB,
+ SceneListResourceRequestor::wPtr ptr)
{
- const std::string SCENE_CHILD = "child";
-
- std::vector<RCSResourceAttributes> retChildren = { };
+ SceneListResourceRequestor::Ptr listPtr = ptr.lock();
- if (attrs.contains(SCENE_CHILD))
+ if (listPtr)
{
- retChildren
- = attrs.at(SCENE_CHILD).get<std::vector<RCSResourceAttributes>>();
+ listPtr->onNameSet_impl(std::move(rep), eCode, name, std::move(internalCB));
}
-
- return retChildren;
}
- RCSRemoteResourceObject::Ptr
- SceneListResourceRequestor::makeSceneRemoteResourceFromAttributes(
- const RCSResourceAttributes & attrs, const SceneResource & resource)
+ void SceneListResourceRequestor::onNameSet_impl(
+ const RCSRepresentation &rep, int eCode, const std::string &name,
+ const InternalSetNameCallback &internalCB)
{
- if (resource != SceneResource::List && !attrs.contains("uri"))
+ int result = SCENE_CLIENT_BADREQUEST;
+ if (eCode == OC_STACK_OK)
{
- // TODO error handle.
- return nullptr;
- }
-
- auto uri = attrs.at("uri").get<std::string>();
- std::vector<std::string> rts = {};
- std::vector<std::string> ifs = {OC::DEFAULT_INTERFACE};
+ if (rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >() == name)
+ {
+ result = SCENE_RESPONSE_SUCCESS;
+ }
- if (resource == SceneResource::Collection)
- {
- rts.push_back(SCENE_COLLECTION_RT);
- ifs.push_back(OC::BATCH_INTERFACE);
- }
- else if (resource == SceneResource::Member)
- {
- rts.push_back(SCENE_MEMBER_RT);
}
- auto ocResourceObj = OC::OCPlatform::constructResourceObject(
- m_SceneListResourcePtr->getAddress(),
- uri, SCENE_CONNECTIVITY, false, rts, ifs);
-
- return RCSRemoteResourceObject::fromOCResource(ocResourceObj);
+ internalCB(result);
}
}
typedef std::shared_ptr< SceneListResourceRequestor > Ptr;
typedef std::weak_ptr< SceneListResourceRequestor > wPtr;
- typedef std::function
- < void(const std::string &link, const std::string &id,
- const std::string &name, int eCode) >
- InternalCreateSceneCollectionCallback;
-
- typedef std::function
- < void(int eCode) > InternalSetNameCallback;
+ typedef std::function<
+ void(const std::string &link, const std::string &id,
+ const std::string &name, int eCode) >
+ InternalCreateSceneCollectionCallback;
+ typedef std::function < void(int eCode) > InternalSetNameCallback;
public:
- SceneListResourceRequestor(RCSRemoteResourceObject::Ptr pSceneList);
- ~SceneListResourceRequestor();
+ SceneListResourceRequestor(RCSRemoteResourceObject::Ptr listResource);
+ ~SceneListResourceRequestor() = default;
- void requestSceneCollectionCreation
- (const std::string &name, InternalCreateSceneCollectionCallback);
+ void requestSceneCollectionCreation(
+ const std::string &name, InternalCreateSceneCollectionCallback);
void requestSetName(const std::string &, InternalSetNameCallback);
void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
- RCSRemoteResourceObject::Ptr getRemoteResourceObject();
-
+ RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
private:
- static void onSceneCollectionCreated
- (const HeaderOpts &, const RCSRepresentation &, int eCode,
- const std::string &name, const InternalCreateSceneCollectionCallback &,
- SceneListResourceRequestor::wPtr);
-
- void onSceneCollectionCreated_impl
- (const HeaderOpts &, const RCSRepresentation &, int eCode,
- const std::string &name, const InternalCreateSceneCollectionCallback &);
-
- std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
- parseSceneListFromAttributes(const RCSResourceAttributes &);
+ static void onSceneCollectionCreated(
+ const RCSRepresentation &, int eCode,
+ const std::string &name, const InternalCreateSceneCollectionCallback &,
+ SceneListResourceRequestor::wPtr);
- std::vector<RCSResourceAttributes> getChildrenAttributes(
- const RCSResourceAttributes &) const;
+ void onSceneCollectionCreated_impl(
+ const RCSRepresentation &, int eCode,
+ const std::string &name, const InternalCreateSceneCollectionCallback &);
- RCSRemoteResourceObject::Ptr makeSceneRemoteResourceFromAttributes(
- const RCSResourceAttributes &, const SceneResource &);
+ static void onNameSet(const RCSRepresentation &, int eCode, const std::string &,
+ const InternalSetNameCallback &, SceneListResourceRequestor::wPtr);
+ void onNameSet_impl(const RCSRepresentation &, int eCode, const std::string &,
+ const InternalSetNameCallback &);
private:
- RCSRemoteResourceObject::Ptr m_SceneListResourcePtr;
+ RCSRemoteResourceObject::Ptr m_sceneListResource;
};
}
namespace Service
{
- SceneMemberResourceRequestor::SceneMemberResourceRequestor
- (RCSRemoteResourceObject::Ptr pSceneMember, const std::string &id)
- : m_id{ id }, m_SceneMemberResourcePtr{ pSceneMember }
+ SceneMemberResourceRequestor::SceneMemberResourceRequestor(
+ RCSRemoteResourceObject::Ptr memberResource, const std::string &id)
+ : m_id{ id }, m_sceneMemberResource{ memberResource }
{
- SCENE_CLIENT_ASSERT_NOT_NULL(pSceneMember);
+ SCENE_CLIENT_ASSERT_NOT_NULL(memberResource);
}
- SceneMemberResourceRequestor::~SceneMemberResourceRequestor()
- {
-
- }
-
- void SceneMemberResourceRequestor::requestSceneActionCreation
- (const std::string &sceneName, const RCSResourceAttributes &attr,
- InternalAddSceneActionCallback internalCB)
+ void SceneMemberResourceRequestor::requestSceneActionCreation(
+ const std::string &sceneName, const RCSResourceAttributes &attr,
+ InternalAddSceneActionCallback internalCB)
{
RCSResourceAttributes attributesToSet;
std::vector< RCSResourceAttributes > vecSceneMappings;
sceneName, attr, std::move(internalCB),
SceneMemberResourceRequestor::wPtr(shared_from_this()));
- m_SceneMemberResourcePtr->setRemoteAttributes
- (std::move(attributesToSet), std::move(setRequestCB));
+ m_sceneMemberResource->setRemoteAttributes(
+ std::move(attributesToSet), std::move(setRequestCB));
}
void SceneMemberResourceRequestor::requestGet(
RCSQueryParams params;
params.setResourceInterface(ifType);
- m_SceneMemberResourcePtr->get(params, cb);
+ m_sceneMemberResource->get(params, cb);
}
- RCSRemoteResourceObject::Ptr SceneMemberResourceRequestor::getRemoteResourceObject()
+ RCSRemoteResourceObject::Ptr SceneMemberResourceRequestor::getRemoteResourceObject() const
{
- return m_SceneMemberResourcePtr;
+ return m_sceneMemberResource;
}
- void SceneMemberResourceRequestor::onSceneActionCreated
- (const RCSResourceAttributes &attrs, int eCode, const std::string &sceneName,
- const RCSResourceAttributes &requestedAttrs, const InternalAddSceneActionCallback &cb,
- SceneMemberResourceRequestor::wPtr ptr)
+ void SceneMemberResourceRequestor::onSceneActionCreated(
+ const RCSResourceAttributes &attrs, int eCode, const std::string &sceneName,
+ const RCSResourceAttributes &requestedAttrs, const InternalAddSceneActionCallback &cb,
+ SceneMemberResourceRequestor::wPtr ptr)
{
- SceneMemberResourceRequestor::Ptr memberPtr = ptr.lock();
+ SceneMemberResourceRequestor::Ptr member = ptr.lock();
- if (memberPtr)
- memberPtr->onSceneActionCreated_impl(
+ if (member)
+ {
+ member->onSceneActionCreated_impl(
std::move(attrs), eCode, sceneName, std::move(requestedAttrs), std::move(cb));
+ }
}
- void SceneMemberResourceRequestor::onSceneActionCreated_impl
- (const RCSResourceAttributes &attrs, int eCode, const std::string &sceneName,
- const RCSResourceAttributes &requestedAttrs,
- const InternalAddSceneActionCallback &internalCB)
+ void SceneMemberResourceRequestor::onSceneActionCreated_impl(
+ const RCSResourceAttributes &attrs, int eCode, const std::string &sceneName,
+ const RCSResourceAttributes &requestedAttrs,
+ const InternalAddSceneActionCallback &internalCB)
{
- // TODO: error code
+ // TODO error code
int result = SCENE_CLIENT_BADREQUEST;
if (eCode == OC_STACK_OK)
typedef std::function < void(int eCode) > InternalAddSceneActionCallback;
-
public:
- SceneMemberResourceRequestor(RCSRemoteResourceObject::Ptr pSceneMember,
+ SceneMemberResourceRequestor(RCSRemoteResourceObject::Ptr memberResource,
const std::string &id);
- ~SceneMemberResourceRequestor();
+ ~SceneMemberResourceRequestor() = default;
void requestSceneActionCreation(const std::string &sceneName,
const RCSResourceAttributes &attr,
void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
- RCSRemoteResourceObject::Ptr getRemoteResourceObject();
-
+ RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
private:
static void onSceneActionCreated(
const std::string &sceneName, const RCSResourceAttributes &requestedAttrs,
const InternalAddSceneActionCallback &);
-
private:
std::string m_id;
- RCSRemoteResourceObject::Ptr m_SceneMemberResourcePtr;
+ RCSRemoteResourceObject::Ptr m_sceneMemberResource;
};
}
#include "oic_malloc.h"
#include "RCSException.h"
#include "cainterface.h"
+#include "OCPlatform.h"
namespace OIC
{
delete[] netInfo;
throw RCSException("Not supported Network");
}
+
+ RCSRemoteResourceObject::Ptr SceneUtils::createRCSResourceObject(
+ const std::string &address, const OCConnectivityType ct,
+ const std::vector< std::string > &vecRT, const std::vector< std::string > &vecIF)
+ {
+ try
+ {
+ std::string hostaddress, uri;
+ SceneUtils::getHostUriString(address, &hostaddress, &uri);
+
+ OC::OCResource::Ptr pOCResource =
+ OC::OCPlatform::constructResourceObject(
+ hostaddress, uri, ct, false, vecRT, vecIF);
+
+ return RCSRemoteResourceObject::fromOCResource(pOCResource);
+ }
+ catch (const std::exception &e)
+ {
+ throw RCSException("Fail to create RCSResourceObject");
+ }
+ }
}
}
projects / platform / upstream / iotivity.git / commitdiff