service/resource-manipulation/src/ResourceClient.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 "ResourceClient.h"
  22 #include "ResourceBroker.h"
  23 #include "ResourceCacheManager.h"
  24
  25 #define CLIENT_W_TAG  PCF("ResourceClient")
  26
  27 using namespace OIC::Service;
  28
  29 namespace
  30 {
  31     ResourceState getResourceStateFromBrokerState(BROKER_STATE state)
  32     {
  33
  34         OC_LOG(DEBUG, CLIENT_W_TAG, "getResourceStateFromBrokerState entry");
  35
  36         if (state == BROKER_STATE::ALIVE)
  37         {
  38             return ResourceState::ALIVE;
  39         }
  40         else if (state == BROKER_STATE::REQUESTED)
  41         {
  42             return ResourceState::REQUESTED;
  43         }
  44         else if (state == BROKER_STATE::LOST_SIGNAL)
  45         {
  46             return ResourceState::LOST_SIGNAL;
  47         }
  48         else if (state == BROKER_STATE::DESTROYED)
  49         {
  50             return ResourceState::DESTROYED;
  51         }
  52
  53         OC_LOG(ERROR, CLIENT_W_TAG, "getResourceStateFromBrokerState ERROR");
  54
  55         //Default return value
  56         return ResourceState::DESTROYED;
  57     }
  58
  59     CacheState getCacheState(CACHE_STATE state)
  60     {
  61
  62         OC_LOG(DEBUG, CLIENT_W_TAG, "getCacheState (from CACHE_STATE) entry");
  63
  64         if (state == CACHE_STATE::READY)
  65         {
  66             return CacheState::READY;
  67         }
  68         else if (state == CACHE_STATE::READY_YET)
  69         {
  70             return CacheState::READY_YET;
  71         }
  72         else if (state == CACHE_STATE::LOST_SIGNAL)
  73         {
  74             return CacheState::LOST_SIGNAL;
  75         }
  76         else if (state == CACHE_STATE::DESTROYED)
  77         {
  78             return CacheState::DESTROYED;
  79         }
  80         else if (state == CACHE_STATE::UPDATING)
  81         {
  82             return CacheState::UPDATING;
  83         }
  84         else if (state == CACHE_STATE::NONE)
  85         {
  86             return CacheState::NONE;
  87         }
  88         OC_LOG(ERROR, CLIENT_W_TAG, "getCacheState (from CACHE_STATE) ERROR");
  89
  90         //Default return value
  91         return CacheState::NONE;
  92     }
  93
  94     OCStackResult hostingCallback(BROKER_STATE state,
  95                                   RemoteResourceObject::ResourceStateChangedCallback onResourceStateChanged)
  96     {
  97         OC_LOG(DEBUG, CLIENT_W_TAG, "hostingCallback entry");
  98
  99         ResourceState resourceState = getResourceStateFromBrokerState(state);
 100         onResourceStateChanged(resourceState); //passing ResourceState to application
 101
 102         OC_LOG(DEBUG, CLIENT_W_TAG, "hostingCallback exit");
 103         return OC_STACK_OK;
 104     }
 105
 106     OCStackResult cachingCallback(std::shared_ptr<PrimitiveResource> resource,
 107                                   const ResourceAttributes &data,
 108                                   RemoteResourceObject::CacheUpdatedCallback onCacheUpdated)
 109     {
 110         OC_LOG(DEBUG, CLIENT_W_TAG, "cachingCallback entry");
 111
 112         onCacheUpdated(data); //passing ResourceAttributes to application
 113
 114         OC_LOG(DEBUG, CLIENT_W_TAG, "cachingCallback exit");
 115         return OC_STACK_OK;
 116     }
 117
 118     void setCallback(const HeaderOptions &header, const ResponseStatement &response, int n,
 119                      RemoteResourceObject::RemoteAttributesSetCallback onRemoteAttributesSet)
 120     {
 121         OC_LOG(DEBUG, CLIENT_W_TAG, "setCallback entry");
 122
 123         const ResourceAttributes &attributes = response.getAttributes();
 124         onRemoteAttributesSet(attributes); //passing ResourceAttributes to application
 125
 126         OC_LOG(DEBUG, CLIENT_W_TAG, "setCallback exit");
 127     }
 128
 129     void getCallback(const HeaderOptions &headerOption, const ResponseStatement &response, int n,
 130                      RemoteResourceObject::RemoteAttributesReceivedCallback onRemoteAttributesReceived)
 131     {
 132         OC_LOG(DEBUG, CLIENT_W_TAG, "getCallback entry");
 133
 134         const ResourceAttributes &attributes = response.getAttributes();
 135         onRemoteAttributesReceived(attributes); //passing ResourceAttributes to application
 136
 137         OC_LOG(DEBUG, CLIENT_W_TAG, "getCallback exit");
 138     }
 139
 140     void findCallback(std::shared_ptr<PrimitiveResource> primitiveResource,
 141                       DiscoveryManager::OnResourceDiscoveredCallback OnResourceDiscovered )
 142     {
 143         OC_LOG(DEBUG, CLIENT_W_TAG, "findCallback entry");
 144
 145         if (nullptr == primitiveResource)
 146         {
 147             OC_LOG(ERROR, CLIENT_W_TAG, "findCallback::primitiveResource NULL Parameter");
 148             return ;
 149         }
 150
 151         std::shared_ptr< RemoteResourceObject>  primitiveClientResource =
 152             std::shared_ptr< RemoteResourceObject>(new RemoteResourceObject(primitiveResource));
 153
 154         OnResourceDiscovered(primitiveClientResource); //passing PrimitiveClientResource to application
 155
 156         OC_LOG(DEBUG, CLIENT_W_TAG, "findcb exit");
 157     }
 158
 159 }
 160
 161 //*******************************Primitive Client Resource*************************************
 162
 163 namespace OIC
 164 {
 165     namespace Service
 166     {
 167
 168         RemoteResourceObject:: RemoteResourceObject(std::shared_ptr<PrimitiveResource>  pResource) :
 169             m_watchingFlag(false), m_cachingFlag(false),  m_observableFlag(pResource->isObservable()),
 170             m_primitiveResource(pResource), m_cacheId(0), m_brokerId(0) {}
 171
 172         bool RemoteResourceObject::isWatching() const
 173         {
 174             return m_watchingFlag;
 175         }
 176
 177         bool RemoteResourceObject::isCaching() const
 178         {
 179             return m_cachingFlag;
 180         }
 181
 182         void RemoteResourceObject::startWatching(ResourceStateChangedCallback cb)
 183         {
 184             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startWatching entry");
 185             if (true == m_watchingFlag)
 186             {
 187                 OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startWatching : Already started");
 188             }
 189             else
 190             {
 191                 try
 192                 {
 193                     BrokerID brokerId =  ResourceBroker::getInstance()->hostResource(m_primitiveResource,
 194                                          std::bind(hostingCallback, std::placeholders::_1,
 195                                                    cb));
 196                     m_watchingFlag = true;
 197                     m_brokerId = brokerId;
 198                 }
 199                 catch (InvalidParameterException exception )
 200                 {
 201                     throw InvalidParameterException {exception.what()};
 202                 }
 203             }
 204             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startWatching exit");
 205         }
 206
 207         void RemoteResourceObject::stopWatching()
 208         {
 209             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::stopWatching entry");
 210             if (true == m_watchingFlag)
 211             {
 212                 try
 213                 {
 214                     ResourceBroker::getInstance()->cancelHostResource(m_brokerId);
 215                     m_watchingFlag = false;
 216                 }
 217                 catch (InvalidParameterException exception )
 218                 {
 219                     OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::stopWatching InvalidParameterException");
 220                 }
 221             }
 222             else
 223             {
 224                 OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject:: stopWatching : already terminated");
 225             }
 226
 227             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::stopWatching exit");
 228         }
 229
 230         ResourceState RemoteResourceObject::getState() const
 231         {
 232             OC_LOG(DEBUG, CLIENT_W_TAG, " RemoteResourceObject::getState entry");
 233             try
 234             {
 235                 BROKER_STATE brokerState = ResourceBroker::getInstance()->getResourceState(m_primitiveResource);
 236                 OC_LOG(DEBUG, CLIENT_W_TAG, " RemoteResourceObject::getState exit");
 237                 return getResourceStateFromBrokerState(brokerState);
 238             }
 239             catch (InvalidParameterException exception)
 240             {
 241                 OC_LOG(DEBUG, CLIENT_W_TAG, " RemoteResourceObject::getState InvalidParameterException");
 242             }
 243         }
 244
 245         void RemoteResourceObject::startCaching()
 246         {
 247             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching entry");
 248             if (true == m_cachingFlag)
 249             {
 250                 OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching : already Started");
 251             }
 252             else
 253             {
 254                 try
 255                 {
 256                   CacheID cacheId = ResourceCacheManager::getInstance()->requestResourceCache(m_primitiveResource,
 257                                       NULL, REPORT_FREQUENCY::NONE,  0);
 258
 259                     m_cacheId = cacheId;
 260                     m_cachingFlag = true;
 261                     OC_LOG_V(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching CACHE ID %d", cacheId);
 262                 }
 263                 catch (InvalidParameterException e)
 264                 {
 265                     OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching InvalidParameterException");
 266                 }
 267             }
 268             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching exit");
 269         }
 270
 271         void RemoteResourceObject::startCaching(CacheUpdatedCallback cb)
 272         {
 273             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching entry");
 274             if (true == m_cachingFlag)
 275             {
 276                 OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching : already Started");
 277             }
 278             else
 279             {
 280                 try
 281                 {
 282                    CacheID cacheId = ResourceCacheManager::getInstance()->requestResourceCache(m_primitiveResource,
 283                                       std::bind(cachingCallback, std::placeholders::_1, std::placeholders::_2, cb),
 284                                       REPORT_FREQUENCY::UPTODATE,  0);
 285
 286                     m_cacheId = cacheId;
 287                     m_cachingFlag = true;
 288                     OC_LOG_V(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::startCaching CACHE ID %d", cacheId);
 289                 }
 290                 catch (InvalidParameterException e)
 291                 {
 292                     throw InvalidParameterException { e.what() };
 293                 }
 294             }
 295         }
 296
 297         void RemoteResourceObject::stopCaching()
 298         {
 299             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::stopCaching entry");
 300
 301             if (true == m_cachingFlag)
 302             {
 303                 try
 304                 {
 305                     ResourceCacheManager::getInstance()->cancelResourceCache(m_cacheId);
 306                     m_cachingFlag = false;
 307                 }
 308                 catch (InvalidParameterException exception)
 309                 {
 310                     OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::stopCaching InvalidParameterException");
 311                 }
 312             }
 313             else
 314             {
 315                 OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject:: Caching already terminated");
 316             }
 317
 318             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::stopCaching exit");
 319         }
 320
 321         CacheState  RemoteResourceObject::getResourceCacheState()
 322         {
 323             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::getResourceCacheState entry");
 324             try
 325             {
 326                 CACHE_STATE cacheState = ResourceCacheManager::getInstance()->getResourceCacheState(
 327                                              m_primitiveResource);
 328                 OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::getResourceCacheState exit");
 329                 return getCacheState(cacheState);
 330             }
 331             catch (InvalidParameterException exception)
 332             {
 333                 OC_LOG(DEBUG, CLIENT_W_TAG,
 334                        "RemoteResourceObject::getResourceCacheState InvalidParameterException");
 335             }
 336         }
 337
 338         void RemoteResourceObject::refreshCache()
 339         {
 340             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::refreshCache entry");
 341             try
 342             {
 343
 344                 ResourceCacheManager::getInstance()->updateResourceCache(
 345                     m_primitiveResource);
 346             }
 347             catch (InvalidParameterException exception)
 348             {
 349                 OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::refreshCache InvalidParameterException");
 350             }
 351             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::refreshCache exit");
 352         }
 353
 354         ResourceAttributes RemoteResourceObject:: getCachedAttributes() const
 355         {
 356             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject :: getCachedAttributes ");
 357             try
 358             {
 359                 return  ResourceCacheManager::getInstance()->getCachedData(m_primitiveResource);
 360             }
 361             catch (InvalidParameterException e)
 362             {
 363               OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::getCachedAttributes InvalidParameterException");
 364             }
 365         }
 366
 367         ResourceAttributes::Value  RemoteResourceObject:: getCachedAttribute( const std::string &key)
 368         {
 369             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject :: getCachedAttribute entry");
 370             try
 371             {
 372                 ResourceAttributes  Cachedattributes = ResourceCacheManager::getInstance()->getCachedData(
 373                         m_primitiveResource);
 374                 return Cachedattributes[key];
 375             }
 376             catch  (InvalidParameterException e)
 377             {
 378                OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::getCachedAttribute InvalidParameterException");
 379             }
 380             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject :: getCachedAttribute exit");
 381         }
 382
 383         std::string RemoteResourceObject::getUri() const
 384         {
 385             return m_primitiveResource->getUri();
 386         }
 387
 388         std::string RemoteResourceObject::getAddress() const
 389         {
 390             return m_primitiveResource->getHost();
 391         }
 392
 393         std::vector < std::string > RemoteResourceObject::getTypes() const
 394         {
 395             return m_primitiveResource->getTypes();
 396         }
 397
 398         std::vector < std::string > RemoteResourceObject::getInterfaces() const
 399         {
 400             return m_primitiveResource->getInterfaces();
 401         }
 402
 403         void RemoteResourceObject::getRemoteAttributes(RemoteAttributesReceivedCallback cb)
 404         {
 405             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::getRemoteAttributes entry");
 406
 407             m_primitiveResource->requestGet(std::bind(getCallback, std::placeholders::_1,
 408                                             std::placeholders::_2, std::placeholders::_3, cb));
 409
 410             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::getRemoteAttributes exit");
 411         }
 412
 413         void RemoteResourceObject::setRemoteAttributes(ResourceAttributes &attribute,
 414                 RemoteAttributesSetCallback cb)
 415         {
 416             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::setRemoteAttributes entry");
 417
 418             m_primitiveResource->requestSet(attribute, std::bind(setCallback, std::placeholders::_1,
 419                                             std::placeholders::_2, std::placeholders::_3, cb));
 420
 421             OC_LOG(DEBUG, CLIENT_W_TAG, "RemoteResourceObject::setRemoteAttributes exit");
 422         }
 423
 424         bool RemoteResourceObject::isObservable() const
 425         {
 426             return m_observableFlag;
 427         }
 428
 429 //*******************************Discovery Manager****************************************
 430
 431         DiscoveryManager *DiscoveryManager:: getInstance()
 432         {
 433             OC_LOG(DEBUG, CLIENT_W_TAG, "DiscoveryManager:: getInstance entry");
 434             static DiscoveryManager *s_instance;
 435             static std::mutex s_mutex;
 436             if (!s_instance)
 437             {
 438                 std::lock_guard<std::mutex> lock(s_mutex);
 439                 if (!s_instance)
 440                 {
 441                     s_instance = new DiscoveryManager();
 442                 }
 443             }
 444             OC_LOG(DEBUG, CLIENT_W_TAG, "DiscoveryManager:: getInstance exit");
 445             return s_instance;
 446         }
 447
 448         void DiscoveryManager::discoverResource(std::string host, std::string resourceURI,
 449                                                 OCConnectivityType connectivityType,
 450                                                 OnResourceDiscoveredCallback cb)
 451         {
 452
 453             OC_LOG(DEBUG, CLIENT_W_TAG, "DiscoveryManager::discoverResource entry");
 454
 455             if ( resourceURI.empty() )
 456             {
 457                 OC_LOG(ERROR, CLIENT_W_TAG, "discoverResource NULL resourceURI");
 458                 throw InvalidParameterException { "discoverResource NULL resourceURI'" };
 459             }
 460             else if ( !cb )
 461             {
 462                 OC_LOG(ERROR, CLIENT_W_TAG, "discoverResource NULL Callback");
 463                 throw InvalidParameterException { "discoverResource NULL Callback'" };
 464             }
 465             OIC::Service::discoverResource(host, resourceURI, connectivityType, std::bind(findCallback,
 466                                            std::placeholders::_1,
 467                                            cb));
 468
 469             OC_LOG(DEBUG, CLIENT_W_TAG, "DiscoveryManager::discoverResource exit");
 470         }
 471     }
 472 }