1 //******************************************************************
3 // Copyright 2016 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "SceneCollectionResourceRequestor.h"
22 #include "RemoteSceneUtils.h"
23 #include "OCPlatform.h"
30 SceneCollectionResourceRequestor::SceneCollectionResourceRequestor(
31 RCSRemoteResourceObject::Ptr collectionResource)
32 : m_sceneCollectionResource{ collectionResource }
34 SCENE_CLIENT_ASSERT_NOT_NULL(collectionResource);
37 void SceneCollectionResourceRequestor::requestSceneCreation(
38 const std::string &name, InternalSceneRequestCallback createSceneCB)
40 RCSResourceAttributes attributesToSet;
41 std::vector< std::string > scenenames{ name };
43 attributesToSet[SCENE_KEY_SCENEVALUES] = scenenames;
45 RCSRemoteResourceObject::RemoteAttributesSetCallback setRequestCB
46 = std::bind(&SceneCollectionResourceRequestor::onSetResponseForScene,
47 std::placeholders::_1, std::placeholders::_2,
48 name, std::move(createSceneCB), ADD_SCENE,
49 SceneCollectionResourceRequestor::wPtr(shared_from_this()));
51 m_sceneCollectionResource->setRemoteAttributes(
52 std::move(attributesToSet), std::move(setRequestCB));
55 void SceneCollectionResourceRequestor::requestSceneRemoval
56 (const std::string &/* name */, InternalSceneRequestCallback)
61 void SceneCollectionResourceRequestor::requestSceneExecution
62 (const std::string &name, InternalSceneRequestCallback executeSceneCB)
64 RCSResourceAttributes attributesToSet;
65 attributesToSet[SCENE_KEY_LAST_SCENE] = name;
67 RCSRemoteResourceObject::RemoteAttributesSetCallback setRequestCB
68 = std::bind(&SceneCollectionResourceRequestor::onSetResponseForScene,
69 std::placeholders::_1, std::placeholders::_2,
70 name, std::move(executeSceneCB), EXECUTE_SCENE,
71 SceneCollectionResourceRequestor::wPtr(shared_from_this()));
73 m_sceneCollectionResource->setRemoteAttributes(
74 std::move(attributesToSet), std::move(setRequestCB));
77 void SceneCollectionResourceRequestor::requestAddSceneMember(
78 RCSRemoteResourceObject::Ptr targetResource, const std::string &sceneName,
79 const RCSResourceAttributes &attr, InternalAddMemberCallback addMemberCB)
81 SCENE_CLIENT_ASSERT_NOT_NULL(targetResource);
83 RCSResourceAttributes attributesToSet, linkAttrs;
85 linkAttrs[SCENE_KEY_HREF] = targetResource->getAddress() + targetResource->getUri();
86 linkAttrs[SCENE_KEY_IF] = targetResource->getInterfaces();
87 linkAttrs[SCENE_KEY_RT] = targetResource->getTypes();
89 attributesToSet[SCENE_KEY_PAYLOAD_LINK] = linkAttrs;
93 std::vector< RCSResourceAttributes > vecSceneMappings;
94 for (const auto &itr : attr)
96 RCSResourceAttributes sceneMappingAttrs;
97 sceneMappingAttrs[SCENE_KEY_SCENE] = sceneName;
98 sceneMappingAttrs[SCENE_KEY_MEMBERPROPERTY] = itr.key();
99 sceneMappingAttrs[SCENE_KEY_MEMBERVALUE] = itr.value();
101 vecSceneMappings.push_back(sceneMappingAttrs);
104 attributesToSet[SCENE_KEY_SCENEMAPPINGS] = vecSceneMappings;
107 RCSRemoteResourceObject::SetCallback setRequestCB
108 = std::bind(&SceneCollectionResourceRequestor::onSceneMemberAdded,
109 std::placeholders::_2, std::placeholders::_3,
111 std::move(addMemberCB),
112 SceneCollectionResourceRequestor::wPtr(shared_from_this()));
114 RCSQueryParams queryParams;
115 queryParams.setResourceInterface(LINK_BATCH);
117 m_sceneCollectionResource->set(queryParams, std::move(attributesToSet),
118 std::move(setRequestCB));
121 void SceneCollectionResourceRequestor::requestSetName
122 (const std::string &name, InternalSetNameCallback internalCB)
124 RCSResourceAttributes attrs;
125 attrs[SCENE_KEY_NAME] = name;
127 RCSRemoteResourceObject::SetCallback setRequestCB
128 = std::bind(&SceneCollectionResourceRequestor::onNameSet,
129 std::placeholders::_2, std::placeholders::_3, name, std::move(internalCB),
130 SceneCollectionResourceRequestor::wPtr(shared_from_this()));
132 RCSQueryParams queryParams;
133 queryParams.setResourceInterface(SCENE_CLIENT_REQ_IF);
135 m_sceneCollectionResource->set(queryParams, std::move(attrs), std::move(setRequestCB));
138 void SceneCollectionResourceRequestor::requestGet(
139 const std::string &ifType, RCSRemoteResourceObject::GetCallback cb)
141 RCSQueryParams params;
142 params.setResourceInterface(ifType);
144 m_sceneCollectionResource->get(params, cb);
147 RCSRemoteResourceObject::Ptr
148 SceneCollectionResourceRequestor::getRemoteResourceObject() const
150 return m_sceneCollectionResource;
153 SceneMemberResourceRequestor::Ptr
154 SceneCollectionResourceRequestor::createSceneMemberResourceRequestor(
155 const std::string &memHref, const std::string &id, RCSRemoteResourceObject::Ptr target)
159 std::vector< std::string > vecRT{ SCENE_MEMBER_RT };
160 std::vector< std::string > vecIF{ SCENE_CLIENT_REQ_IF };
162 RCSRemoteResourceObject::Ptr pResource
163 = SceneUtils::createRCSResourceObject(
164 memHref, SCENE_CONNECTIVITY, vecRT, vecIF);
166 SceneMemberResourceRequestor::Ptr pMemRequestor =
167 std::make_shared< SceneMemberResourceRequestor >(pResource, id);
169 pMemRequestor->setRemoteResourceObject(target);
172 std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
173 m_memberRequestors[target->getAddress() + target->getUri()] = pMemRequestor;
176 return pMemRequestor;
178 catch (const std::exception &e)
180 SCENE_CLIENT_PRINT_LOG(e.what());
185 SceneMemberResourceRequestor::Ptr
186 SceneCollectionResourceRequestor::getSceneMemberResourceRequestor(
187 const std::string &targetHref) const
189 std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
191 return m_memberRequestors.find(targetHref) != m_memberRequestors.end() ?
192 m_memberRequestors.at(targetHref) : nullptr;
195 void SceneCollectionResourceRequestor::onSetResponseForScene(
196 const RCSResourceAttributes &attrs, int eCode,
197 const std::string &name, const InternalSceneRequestCallback &cb,
198 REQUEST_TYPE reqType, SceneCollectionResourceRequestor::wPtr ptr)
200 SceneCollectionResourceRequestor::Ptr collectionPtr = ptr.lock();
204 collectionPtr->onSetResponseForScene_impl(
205 std::move(attrs), eCode, name, std::move(cb), reqType);
209 void SceneCollectionResourceRequestor::onSetResponseForScene_impl(
210 const RCSResourceAttributes &attrs, int eCode, const std::string &name,
211 const InternalSceneRequestCallback &internalCB, REQUEST_TYPE reqType)
214 int resultCode = SCENE_CLIENT_BADREQUEST;
216 if (eCode == OC_STACK_OK)
225 = attrs.at(SCENE_KEY_SCENEVALUES).
226 get< std::vector< std::string > >();
228 if ((std::find(scenes.begin(), scenes.end(), name))
231 resultCode = SCENE_RESPONSE_SUCCESS;
242 = attrs.at(SCENE_KEY_LAST_SCENE).get< std::string >();
244 if (lastScene.compare(name) == 0)
246 resultCode = SCENE_RESPONSE_SUCCESS;
252 catch (const std::exception &e)
254 SCENE_CLIENT_PRINT_LOG(e.what());
255 resultCode = SCENE_SERVER_INTERNALSERVERERROR;
259 internalCB(reqType, name, resultCode);
262 void SceneCollectionResourceRequestor::onSceneMemberAdded(
263 const RCSRepresentation &rep, int eCode,
264 RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB,
265 SceneCollectionResourceRequestor::wPtr ptr)
267 SceneCollectionResourceRequestor::Ptr collection = ptr.lock();
271 collection->onSceneMemberAdded_impl(
272 std::move(rep), eCode, target, std::move(internalCB));
276 void SceneCollectionResourceRequestor::onSceneMemberAdded_impl(
277 const RCSRepresentation &rep, int eCode,
278 RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB)
281 int result = SCENE_CLIENT_BADREQUEST;
282 SceneMemberResourceRequestor::Ptr memRequestor = nullptr;
284 if (eCode == OC_STACK_OK)
288 RCSResourceAttributes receivedAttrs = rep.getAttributes();
291 = createSceneMemberResourceRequestor(
292 receivedAttrs.at(SCENE_KEY_CREATEDLINK).get< std::string >(),
293 receivedAttrs.at(SCENE_KEY_ID).get< std::string >(), target);
297 memRequestor->setRemoteResourceObject(target);
298 result = SCENE_RESPONSE_SUCCESS;
301 catch (const std::exception &e)
303 SCENE_CLIENT_PRINT_LOG(e.what());
304 result = SCENE_SERVER_INTERNALSERVERERROR;
311 void SceneCollectionResourceRequestor::onNameSet(const RCSRepresentation &rep, int eCode,
312 const std::string &name, const InternalSetNameCallback &internalCB,
313 SceneCollectionResourceRequestor::wPtr ptr)
315 SceneCollectionResourceRequestor::Ptr collectionPtr = ptr.lock();
319 collectionPtr->onNameSet_impl(std::move(rep), eCode, name, std::move(internalCB));
323 void SceneCollectionResourceRequestor::onNameSet_impl(
324 const RCSRepresentation &rep, int eCode, const std::string &name,
325 const InternalSetNameCallback &internalCB)
327 int result = SCENE_CLIENT_BADREQUEST;
328 if (eCode == OC_STACK_OK)
330 if (rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >() == name)
332 result = SCENE_RESPONSE_SUCCESS;