--- /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 "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);
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);
+
}
}
void SceneCollectionResourceRequestor::requestAddSceneMember
(RCSRemoteResourceObject::Ptr pMember, const std::string &sceneName,
- RCSResourceAttributes &attr, InternalAddMemberCallback addMemberCB)
+ const RCSResourceAttributes &attr, InternalAddMemberCallback addMemberCB)
{
SCENE_CLIENT_ASSERT_NOT_NULL(pMember);
attributesToSet[SCENE_KEY_PAYLOAD_LINK] = linkAttrs;
- std::vector< RCSResourceAttributes > vecSceneMappings;
- for (const auto &itr : attr)
+ if (!attr.empty())
{
- RCSResourceAttributes sceneMappingAttrs;
- sceneMappingAttrs[SCENE_KEY_SCENE] = sceneName;
- sceneMappingAttrs[SCENE_KEY_MEMBERPROPERTY] = itr.key();
- sceneMappingAttrs[SCENE_KEY_MEMBERVALUE] = itr.value();
+ std::vector< RCSResourceAttributes > vecSceneMappings;
+ for (const auto &itr : attr)
+ {
+ RCSResourceAttributes sceneMappingAttrs;
+ sceneMappingAttrs[SCENE_KEY_SCENE] = sceneName;
+ sceneMappingAttrs[SCENE_KEY_MEMBERPROPERTY] = itr.key();
+ sceneMappingAttrs[SCENE_KEY_MEMBERVALUE] = itr.value();
- vecSceneMappings.push_back(sceneMappingAttrs);
- }
+ vecSceneMappings.push_back(sceneMappingAttrs);
+ }
- attributesToSet[SCENE_KEY_SCENEMAPPINGS] = vecSceneMappings;
+ attributesToSet[SCENE_KEY_SCENEMAPPINGS] = vecSceneMappings;
+ }
RCSRemoteResourceObject::SetCallback setRequestCB
= std::bind(&SceneCollectionResourceRequestor::onSceneMemberAdded,
std::placeholders::_1, std::placeholders::_2,
- std::placeholders::_3, std::move(addMemberCB),
+ std::placeholders::_3,
+ pMember->getAddress() + pMember->getUri(),
+ std::move(addMemberCB),
SceneCollectionResourceRequestor::wPtr(shared_from_this()));
RCSQueryParams queryParams;
}
+ void SceneCollectionResourceRequestor::requestGet(
+ const std::string &ifType, RCSRemoteResourceObject::GetCallback cb)
+ {
+ RCSQueryParams params;
+ params.setResourceInterface(ifType);
+
+ m_SceneCollectionResourcePtr->get(params, cb);
+ }
+
+ RCSRemoteResourceObject::Ptr SceneCollectionResourceRequestor::getRemoteResourceObject()
+ {
+ return m_SceneCollectionResourcePtr;
+ }
+
+ SceneMemberResourceRequestor::Ptr
+ SceneCollectionResourceRequestor::createSceneMemberResourceRequestor(
+ const std::string &memLink, const std::string &id, const std::string &targetlink)
+ {
+ SceneMemberResourceRequestor::Ptr pMemRequestor = nullptr;
+
+ 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);
+
+ if (pResource)
+ {
+ pMemRequestor =
+ std::make_shared< SceneMemberResourceRequestor >(pResource, id);
+
+ m_mapMemberRequestors[targetlink] = pMemRequestor;
+ }
+
+ return pMemRequestor;
+ }
+
SceneMemberResourceRequestor::Ptr
SceneCollectionResourceRequestor::getSceneMemberResourceRequestor
(const std::string &memLink)
// TODO: error code
int resultCode = SCENE_CLIENT_BADREQUEST;
- if (eCode == SCENE_RESPONSE_SUCCESS)
+ if (eCode == OC_STACK_OK)
{
try
{
void SceneCollectionResourceRequestor::onSceneMemberAdded
(const HeaderOpts &headOpt, const RCSRepresentation &rep, int eCode,
- const InternalAddMemberCallback &internalCB,
+ const std::string &targetLink, const InternalAddMemberCallback &internalCB,
SceneCollectionResourceRequestor::wPtr ptr)
{
SceneCollectionResourceRequestor::Ptr pSceneCollectionRequestor
if (pSceneCollectionRequestor)
pSceneCollectionRequestor->onSceneMemberAdded_impl(
- headOpt, rep, eCode, std::move(internalCB));
+ headOpt, rep, eCode, targetLink, std::move(internalCB));
}
void SceneCollectionResourceRequestor::onSceneMemberAdded_impl
(const HeaderOpts &, const RCSRepresentation &rep, int eCode,
- const InternalAddMemberCallback &internalCB)
+ const std::string &targetLink, const InternalAddMemberCallback &internalCB)
{
// TODO: error code
int result = SCENE_CLIENT_BADREQUEST;
SceneMemberResourceRequestor::Ptr pMemRequestor = nullptr;
- if (eCode == SCENE_RESPONSE_SUCCESS)
+ if (eCode == OC_STACK_OK)
{
try
{
RCSResourceAttributes receivedAttrs = rep.getAttributes();
- std::string hostaddress, uri;
-
- SceneUtils::getHostUriString
- (receivedAttrs.at(SCENE_KEY_CREATEDLINK).get< std::string >(),
- &hostaddress, &uri);
-
- std::vector< std::string > vecRT{ SCENE_MEMBER_RT };
- std::vector< std::string > vecIF{ SCENE_CLIENT_REQ_IF };
-
- OC::OCResource::Ptr pOCResource =
- OC::OCPlatform::constructResourceObject
- (hostaddress, uri, SCENE_CONNECTIVITY, false, vecRT, vecIF);
-
- SCENE_CLIENT_ASSERT_NOT_NULL(pOCResource);
-
- RCSRemoteResourceObject::Ptr pResource
- = RCSRemoteResourceObject::fromOCResource(pOCResource);
-
- SCENE_CLIENT_ASSERT_NOT_NULL(pResource);
-
- pMemRequestor =
- std::make_shared< SceneMemberResourceRequestor >
- (pResource, receivedAttrs.at(SCENE_KEY_ID).get< std::string >());
-
- m_mapMemberRequestors[receivedAttrs.at(SCENE_KEY_PAYLOAD_LINK).
- get< RCSResourceAttributes >().
- at(SCENE_KEY_HREF).get< std::string >()] = pMemRequestor;
+ pMemRequestor
+ = createSceneMemberResourceRequestor(
+ receivedAttrs.at(SCENE_KEY_CREATEDLINK).get< std::string >(),
+ receivedAttrs.at(SCENE_KEY_ID).get< std::string >(),
+ targetLink);
- result = SCENE_RESPONSE_SUCCESS;
+ if (pMemRequestor)
+ result = SCENE_RESPONSE_SUCCESS;
}
catch (const std::exception &e)
{
void requestAddSceneMember(RCSRemoteResourceObject::Ptr pMember,
const std::string &sceneName,
- RCSResourceAttributes &attr,
+ const RCSResourceAttributes &attr,
InternalAddMemberCallback);
void requestSetName(const std::string &, InternalSetNameCallback);
+ void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
+
+ RCSRemoteResourceObject::Ptr getRemoteResourceObject();
+
+ SceneMemberResourceRequestor::Ptr createSceneMemberResourceRequestor(
+ const std::string &memlink, const std::string &id,
+ const std::string &targetlink);
+
SceneMemberResourceRequestor::Ptr getSceneMemberResourceRequestor(
- const std::string &);
+ const std::string &link);
private:
static void onSceneMemberAdded(
const HeaderOpts &, const RCSRepresentation &, int eCode,
- const InternalAddMemberCallback &, SceneCollectionResourceRequestor::wPtr);
+ const std::string &, const InternalAddMemberCallback &,
+ SceneCollectionResourceRequestor::wPtr);
void onSceneMemberAdded_impl(
const HeaderOpts &, const RCSRepresentation &, int eCode,
- const InternalAddMemberCallback &);
+ const std::string &, const InternalAddMemberCallback &);
private:
#include "SceneListResourceRequestor.h"
#include "RemoteSceneUtils.h"
+#include "OCPlatform.h"
namespace OIC
{
}
+ void SceneListResourceRequestor::requestGet(
+ const std::string &ifType, RCSRemoteResourceObject::GetCallback cb)
+ {
+ RCSQueryParams params;
+ params.setResourceInterface(ifType);
+
+ m_SceneListResourcePtr->get(params, cb);
+ }
+
+ RCSRemoteResourceObject::Ptr SceneListResourceRequestor::getRemoteResourceObject()
+ {
+ return m_SceneListResourcePtr;
+ }
+
void SceneListResourceRequestor::onSceneCollectionCreated
(const HeaderOpts &headOpts, const RCSRepresentation &rep, int eCode,
const std::string &name, const InternalCreateSceneCollectionCallback &cb,
int result = SCENE_CLIENT_BADREQUEST;
std::string link, id;
- if (eCode == SCENE_RESPONSE_SUCCESS)
+ if (eCode == OC_STACK_OK)
{
try
{
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
+ {
+ 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;
+ }
+
+ RCSRemoteResourceObject::Ptr
+ SceneListResourceRequestor::makeSceneRemoteResourceFromAttributes(
+ const RCSResourceAttributes & attrs, const SceneResource & resource)
+ {
+ if (resource != SceneResource::List && !attrs.contains("uri"))
+ {
+ // 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 (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);
+ }
+
}
}
\ No newline at end of file
#include "SceneCommons.h"
#include "RCSRemoteResourceObject.h"
#include "RCSRepresentation.h"
+#include "RemoteSceneUtils.h"
namespace OIC
{
void requestSetName(const std::string &, InternalSetNameCallback);
+ void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
+
+ RCSRemoteResourceObject::Ptr getRemoteResourceObject();
+
private:
static void onSceneCollectionCreated
(const HeaderOpts &, const RCSRepresentation &, int eCode,
const std::string &name, const InternalCreateSceneCollectionCallback &);
+ std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
+ parseSceneListFromAttributes(const RCSResourceAttributes &);
+
+ std::vector<RCSResourceAttributes> getChildrenAttributes(
+ const RCSResourceAttributes &) const;
+
+ RCSRemoteResourceObject::Ptr makeSceneRemoteResourceFromAttributes(
+ const RCSResourceAttributes &, const SceneResource &);
+
private:
RCSRemoteResourceObject::Ptr m_SceneListResourcePtr;
}
void SceneMemberResourceRequestor::requestSceneActionCreation
- (const std::string &sceneName, RCSResourceAttributes &attr,
+ (const std::string &sceneName, const RCSResourceAttributes &attr,
InternalAddSceneActionCallback internalCB)
{
RCSResourceAttributes attributesToSet;
RCSRemoteResourceObject::RemoteAttributesSetCallback setRequestCB
= std::bind(&SceneMemberResourceRequestor::onSceneActionCreated,
std::placeholders::_1, std::placeholders::_2,
- sceneName, std::move(attr), std::move(internalCB),
+ sceneName, attr, std::move(internalCB),
SceneMemberResourceRequestor::wPtr(shared_from_this()));
m_SceneMemberResourcePtr->setRemoteAttributes
(std::move(attributesToSet), std::move(setRequestCB));
}
+ void SceneMemberResourceRequestor::requestGet(
+ const std::string &ifType, RCSRemoteResourceObject::GetCallback cb)
+ {
+ RCSQueryParams params;
+ params.setResourceInterface(ifType);
+
+ m_SceneMemberResourcePtr->get(params, cb);
+ }
+
RCSRemoteResourceObject::Ptr SceneMemberResourceRequestor::getRemoteResourceObject()
{
return m_SceneMemberResourcePtr;
// TODO: error code
int result = SCENE_CLIENT_BADREQUEST;
- if (eCode == SCENE_RESPONSE_SUCCESS)
+ if (eCode == OC_STACK_OK)
{
try
{
~SceneMemberResourceRequestor();
void requestSceneActionCreation(const std::string &sceneName,
- RCSResourceAttributes &attr,
+ const RCSResourceAttributes &attr,
InternalAddSceneActionCallback);
+ void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
+
RCSRemoteResourceObject::Ptr getRemoteResourceObject();
projects / contrib / iotivity.git / commitdiff