service/scene-manager/src/SceneCollectionResourceRequestor.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   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
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  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.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "SceneCollectionResourceRequestor.h"
  22 #include "RemoteSceneUtils.h"
  23 #include "OCPlatform.h"
  24
  25 namespace OIC
  26 {
  27     namespace Service
  28     {
  29
  30         SceneCollectionResourceRequestor::SceneCollectionResourceRequestor(
  31             RCSRemoteResourceObject::Ptr collectionResource)
  32                 : m_sceneCollectionResource{ collectionResource }
  33         {
  34             SCENE_CLIENT_ASSERT_NOT_NULL(collectionResource);
  35         }
  36
  37         void SceneCollectionResourceRequestor::requestSceneCreation(
  38             const std::string &name, InternalSceneRequestCallback createSceneCB)
  39         {
  40             RCSResourceAttributes attributesToSet;
  41             std::vector< std::string > scenenames{ name };
  42
  43             attributesToSet[SCENE_KEY_SCENEVALUES] = scenenames;
  44
  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()));
  50
  51             m_sceneCollectionResource->setRemoteAttributes(
  52                 std::move(attributesToSet), std::move(setRequestCB));
  53         }
  54
  55         void SceneCollectionResourceRequestor::requestSceneRemoval
  56         (const std::string &/* name */, InternalSceneRequestCallback)
  57         {
  58
  59         }
  60
  61         void SceneCollectionResourceRequestor::requestSceneExecution
  62         (const std::string &name, InternalSceneRequestCallback executeSceneCB)
  63         {
  64             RCSResourceAttributes attributesToSet;
  65             attributesToSet[SCENE_KEY_LAST_SCENE] = name;
  66
  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()));
  72
  73             m_sceneCollectionResource->setRemoteAttributes(
  74                 std::move(attributesToSet), std::move(setRequestCB));
  75         }
  76
  77         void SceneCollectionResourceRequestor::requestAddSceneMember(
  78             RCSRemoteResourceObject::Ptr targetResource, const std::string &sceneName,
  79             const RCSResourceAttributes &attr, InternalAddMemberCallback addMemberCB)
  80         {
  81             SCENE_CLIENT_ASSERT_NOT_NULL(targetResource);
  82
  83             RCSResourceAttributes attributesToSet, linkAttrs;
  84
  85             linkAttrs[SCENE_KEY_HREF] = targetResource->getAddress() + targetResource->getUri();
  86             linkAttrs[SCENE_KEY_IF] = targetResource->getInterfaces();
  87             linkAttrs[SCENE_KEY_RT] = targetResource->getTypes();
  88
  89             attributesToSet[SCENE_KEY_PAYLOAD_LINK] = linkAttrs;
  90
  91             if (!attr.empty())
  92             {
  93                 std::vector< RCSResourceAttributes > vecSceneMappings;
  94                 for (const auto &itr : attr)
  95                 {
  96                     RCSResourceAttributes sceneMappingAttrs;
  97                     sceneMappingAttrs[SCENE_KEY_SCENE] = sceneName;
  98                     sceneMappingAttrs[SCENE_KEY_MEMBERPROPERTY] = itr.key();
  99                     sceneMappingAttrs[SCENE_KEY_MEMBERVALUE] = itr.value();
 100
 101                     vecSceneMappings.push_back(sceneMappingAttrs);
 102                 }
 103
 104                 attributesToSet[SCENE_KEY_SCENEMAPPINGS] = vecSceneMappings;
 105             }
 106
 107             RCSRemoteResourceObject::SetCallback setRequestCB
 108                 = std::bind(&SceneCollectionResourceRequestor::onSceneMemberAdded,
 109                             std::placeholders::_2, std::placeholders::_3,
 110                             targetResource,
 111                             std::move(addMemberCB),
 112                             SceneCollectionResourceRequestor::wPtr(shared_from_this()));
 113
 114             RCSQueryParams queryParams;
 115             queryParams.setResourceInterface(LINK_BATCH);
 116
 117             m_sceneCollectionResource->set(queryParams, std::move(attributesToSet),
 118                                               std::move(setRequestCB));
 119         }
 120
 121         void SceneCollectionResourceRequestor::requestSetName
 122         (const std::string &name, InternalSetNameCallback internalCB)
 123         {
 124             RCSResourceAttributes attrs;
 125             attrs[SCENE_KEY_NAME] = name;
 126
 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()));
 131
 132             RCSQueryParams queryParams;
 133             queryParams.setResourceInterface(SCENE_CLIENT_REQ_IF);
 134
 135             m_sceneCollectionResource->set(queryParams, std::move(attrs), std::move(setRequestCB));
 136         }
 137
 138         void SceneCollectionResourceRequestor::requestGet(
 139             const std::string &ifType, RCSRemoteResourceObject::GetCallback cb)
 140         {
 141             RCSQueryParams params;
 142             params.setResourceInterface(ifType);
 143
 144             m_sceneCollectionResource->get(params, cb);
 145         }
 146
 147         RCSRemoteResourceObject::Ptr
 148             SceneCollectionResourceRequestor::getRemoteResourceObject() const
 149         {
 150             return m_sceneCollectionResource;
 151         }
 152
 153         SceneMemberResourceRequestor::Ptr
 154         SceneCollectionResourceRequestor::createSceneMemberResourceRequestor(
 155             const std::string &memHref, const std::string &id, RCSRemoteResourceObject::Ptr target)
 156         {
 157             try
 158             {
 159                 std::vector< std::string > vecRT{ SCENE_MEMBER_RT };
 160                 std::vector< std::string > vecIF{ SCENE_CLIENT_REQ_IF };
 161
 162                 RCSRemoteResourceObject::Ptr pResource
 163                     = SceneUtils::createRCSResourceObject(
 164                         memHref, SCENE_CONNECTIVITY, vecRT, vecIF);
 165
 166                 SceneMemberResourceRequestor::Ptr pMemRequestor =
 167                     std::make_shared< SceneMemberResourceRequestor >(pResource, id);
 168
 169                 pMemRequestor->setRemoteResourceObject(target);
 170
 171                 {
 172                     std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
 173                     m_memberRequestors[target->getAddress() + target->getUri()] = pMemRequestor;
 174                 }
 175
 176                 return pMemRequestor;
 177             }
 178             catch (const std::exception &e)
 179             {
 180                 SCENE_CLIENT_PRINT_LOG(e.what());
 181                 return nullptr;
 182             }
 183         }
 184
 185         SceneMemberResourceRequestor::Ptr
 186         SceneCollectionResourceRequestor::getSceneMemberResourceRequestor(
 187             const std::string &targetHref) const
 188         {
 189             std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
 190
 191             return m_memberRequestors.find(targetHref) != m_memberRequestors.end() ?
 192                 m_memberRequestors.at(targetHref) : nullptr;
 193         }
 194
 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)
 199         {
 200             SceneCollectionResourceRequestor::Ptr collectionPtr = ptr.lock();
 201
 202             if (collectionPtr)
 203             {
 204                 collectionPtr->onSetResponseForScene_impl(
 205                     std::move(attrs), eCode, name, std::move(cb), reqType);
 206             }
 207         }
 208
 209         void SceneCollectionResourceRequestor::onSetResponseForScene_impl(
 210             const RCSResourceAttributes &attrs, int eCode, const std::string &name,
 211             const InternalSceneRequestCallback &internalCB, REQUEST_TYPE reqType)
 212         {
 213             // TODO error code
 214             int resultCode = SCENE_CLIENT_BADREQUEST;
 215
 216             if (eCode == OC_STACK_OK)
 217             {
 218                 try
 219                 {
 220                     switch (reqType)
 221                     {
 222                         case ADD_SCENE:
 223                             {
 224                                 auto scenes
 225                                     = attrs.at(SCENE_KEY_SCENEVALUES).
 226                                         get< std::vector< std::string > >();
 227
 228                                 if ((std::find(scenes.begin(), scenes.end(), name))
 229                                     != scenes.end())
 230                                 {
 231                                     resultCode = SCENE_RESPONSE_SUCCESS;
 232                                 }
 233                             }
 234                             break;
 235
 236                         case REMOVE_SCENE:
 237                             break;
 238
 239                         case EXECUTE_SCENE:
 240                             {
 241                                 auto lastScene
 242                                     = attrs.at(SCENE_KEY_LAST_SCENE).get< std::string >();
 243
 244                                 if (lastScene.compare(name) == 0)
 245                                 {
 246                                     resultCode = SCENE_RESPONSE_SUCCESS;
 247                                 }
 248                             }
 249                             break;
 250                     }
 251                 }
 252                 catch (const std::exception &e)
 253                 {
 254                     SCENE_CLIENT_PRINT_LOG(e.what());
 255                     resultCode = SCENE_SERVER_INTERNALSERVERERROR;
 256                 }
 257             }
 258
 259             internalCB(reqType, name, resultCode);
 260         }
 261
 262         void SceneCollectionResourceRequestor::onSceneMemberAdded(
 263             const RCSRepresentation &rep, int eCode,
 264             RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB,
 265             SceneCollectionResourceRequestor::wPtr ptr)
 266         {
 267             SceneCollectionResourceRequestor::Ptr collection = ptr.lock();
 268
 269             if (collection)
 270             {
 271                 collection->onSceneMemberAdded_impl(
 272                     std::move(rep), eCode, target, std::move(internalCB));
 273             }
 274         }
 275
 276         void SceneCollectionResourceRequestor::onSceneMemberAdded_impl(
 277             const RCSRepresentation &rep, int eCode,
 278             RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB)
 279         {
 280             // TODO error code
 281             int result = SCENE_CLIENT_BADREQUEST;
 282             SceneMemberResourceRequestor::Ptr memRequestor = nullptr;
 283
 284             if (eCode == OC_STACK_OK)
 285             {
 286                 try
 287                 {
 288                     RCSResourceAttributes receivedAttrs = rep.getAttributes();
 289
 290                     memRequestor
 291                         = createSceneMemberResourceRequestor(
 292                               receivedAttrs.at(SCENE_KEY_CREATEDLINK).get< std::string >(),
 293                               receivedAttrs.at(SCENE_KEY_ID).get< std::string >(), target);
 294
 295                     if (memRequestor)
 296                     {
 297                         memRequestor->setRemoteResourceObject(target);
 298                         result = SCENE_RESPONSE_SUCCESS;
 299                     }
 300                 }
 301                 catch (const std::exception &e)
 302                 {
 303                     SCENE_CLIENT_PRINT_LOG(e.what());
 304                     result = SCENE_SERVER_INTERNALSERVERERROR;
 305                 }
 306             }
 307
 308             internalCB(result);
 309         }
 310
 311         void SceneCollectionResourceRequestor::onNameSet(const RCSRepresentation &rep, int eCode,
 312             const std::string &name, const InternalSetNameCallback &internalCB,
 313             SceneCollectionResourceRequestor::wPtr ptr)
 314         {
 315             SceneCollectionResourceRequestor::Ptr collectionPtr = ptr.lock();
 316
 317             if (collectionPtr)
 318             {
 319                 collectionPtr->onNameSet_impl(std::move(rep), eCode, name, std::move(internalCB));
 320             }
 321         }
 322
 323         void SceneCollectionResourceRequestor::onNameSet_impl(
 324             const RCSRepresentation &rep, int eCode, const std::string &name,
 325             const InternalSetNameCallback &internalCB)
 326         {
 327             int result = SCENE_CLIENT_BADREQUEST;
 328             if (eCode == OC_STACK_OK)
 329             {
 330                 if (rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >() == name)
 331                 {
 332                     result = SCENE_RESPONSE_SUCCESS;
 333                 }
 334
 335             }
 336
 337             internalCB(result);
 338         }
 339
 340     }
 341 }