service/resource-container/src/RemoteResourceUnit.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 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 "RemoteResourceUnit.h"
  22
  23 using namespace OIC::Service;
  24
  25 RemoteResourceUnit::RemoteResourceUnit()
  26 {
  27     pStateChangedCB = std::bind(&RemoteResourceUnit::stateChangedCB, this,
  28                         std::placeholders::_1);
  29     pCacheUpdateCB = std::bind(&RemoteResourceUnit::cacheUpdateCB, this,
  30                     std::placeholders::_1);
  31 }
  32
  33 RemoteResourceUnit::~RemoteResourceUnit()
  34 {
  35     if (remoteObject)
  36     {
  37         if(remoteObject->isCaching())
  38         {
  39             remoteObject->stopCaching();
  40         }
  41         if(remoteObject->isMonitoring())
  42         {
  43             remoteObject->stopMonitoring();
  44         }
  45     }
  46 }
  47
  48 RemoteResourceUnit::Ptr RemoteResourceUnit::createRemoteResourceInfo(
  49         RCSRemoteResourceObject::Ptr ptr, UpdatedCBFromServer updatedCB)
  50 {
  51     RemoteResourceUnit::Ptr retRemoteResourceUnit = std::make_shared<RemoteResourceUnit>();
  52     retRemoteResourceUnit->remoteObject = ptr;
  53     retRemoteResourceUnit->pUpdatedCB = updatedCB;
  54
  55     return retRemoteResourceUnit;
  56 }
  57
  58 RemoteResourceUnit::Ptr RemoteResourceUnit::createRemoteResourceInfoWithStateCB(
  59     RCSRemoteResourceObject::Ptr ptr, UpdatedCBFromServer updatedCB,
  60     RCSRemoteResourceObject::StateChangedCallback stateCB)
  61 {
  62     RemoteResourceUnit::Ptr retRemoteResourceUnit = std::make_shared<RemoteResourceUnit>();
  63     retRemoteResourceUnit->remoteObject = ptr;
  64     retRemoteResourceUnit->pUpdatedCB = updatedCB;
  65
  66     retRemoteResourceUnit->pStateChangedCB = stateCB;
  67
  68     return retRemoteResourceUnit;
  69 }
  70
  71 RemoteResourceUnit::Ptr RemoteResourceUnit::createRemoteResourceInfoWithCacheCB(
  72     RCSRemoteResourceObject::Ptr ptr, UpdatedCBFromServer updatedCB,
  73     RCSRemoteResourceObject::CacheUpdatedCallback cacheCB)
  74 {
  75     RemoteResourceUnit::Ptr retRemoteResourceUnit = std::make_shared<RemoteResourceUnit>();
  76     retRemoteResourceUnit->remoteObject = ptr;
  77     retRemoteResourceUnit->pUpdatedCB = updatedCB;
  78
  79     retRemoteResourceUnit->pCacheUpdateCB = cacheCB;
  80
  81     return retRemoteResourceUnit;
  82 }
  83
  84 RCSRemoteResourceObject::Ptr RemoteResourceUnit::getRemoteResourceObject() const
  85 {
  86     return remoteObject;
  87 }
  88
  89 std::string RemoteResourceUnit::getRemoteResourceUri() const
  90 {
  91     return remoteObject->getUri();
  92 }
  93
  94 void RemoteResourceUnit::startCaching() const
  95 {
  96     remoteObject->startCaching(pCacheUpdateCB);
  97 }
  98
  99 void RemoteResourceUnit::startMonitoring() const
 100 {
 101     remoteObject->startMonitoring(pStateChangedCB);
 102 }
 103
 104 void RemoteResourceUnit::stateChangedCB(ResourceState changedState) const
 105 {
 106     std::lock_guard<std::mutex> lock(m_mutex);
 107     if(changedState == ResourceState::LOST_SIGNAL ||
 108        changedState == ResourceState::DESTROYED)
 109     {
 110         pUpdatedCB(UPDATE_MSG::RESOURCE_DELETED, remoteObject);
 111     }
 112 }
 113
 114 void RemoteResourceUnit::cacheUpdateCB(const RCSResourceAttributes & updatedAtt) const
 115 {
 116     std::lock_guard<std::mutex> lock(m_mutex);
 117     (void)updatedAtt;
 118     pUpdatedCB(UPDATE_MSG::DATA_UPDATED, remoteObject);
 119 }