#include "RCSRemoteResourceObject.h"
+#include "OCPlatform.h"
+
#include "ResourceBroker.h"
#include "ResourceCacheManager.h"
}
OCStackResult cachingCallback(std::shared_ptr< PrimitiveResource >,
- const RCSResourceAttributes& data,
- RCSRemoteResourceObject::CacheUpdatedCallback onCacheUpdated)
+ const RCSResourceAttributes& data, int eCode,
+ RCSRemoteResourceObject::CacheUpdatedCallback onCacheUpdated,
+ std::weak_ptr<RCSRemoteResourceObject> resourcePtr)
{
SCOPE_LOG_F(DEBUG, TAG);
- onCacheUpdated(data);
+ //If error code is failure then RE Cache module should
+ //do clean up for caching flags, maps etc.
+ if(eCode > 4)
+ {
+ OIC_LOG_V(ERROR, TAG, "Error code: %d",eCode);
+ try
+ {
+ std::shared_ptr<RCSRemoteResourceObject> resource = resourcePtr.lock();
+ if(resource)
+ {
+ resource->stopCaching();
+ }
+ else
+ {
+ OIC_LOG(ERROR, TAG, "Resource object is null");
+ }
+ }
+ catch(...)
+ {
+ //Exception will be thrown: stack will return OC_STACK_ERROR
+ // if it already stopped observe. This call is reqired for clearing
+ //Cache manager.
+ OIC_LOG(DEBUG, TAG, "Cleared Cache");
+ }
+ }
+
+ //Calling application callback
+ onCacheUpdated(data, eCode);
return OC_STACK_OK;
}
namespace Service
{
- RCSQueryParams& RCSQueryParams::setResourceInterface(const std::string& resourceInterface)
- {
- m_resourceInterface = resourceInterface;
- return *this;
- }
-
- RCSQueryParams& RCSQueryParams::setResourceInterface(std::string&& resourceInterface)
+ RCSQueryParams& RCSQueryParams::setResourceInterface(std::string resourceInterface)
{
m_resourceInterface = std::move(resourceInterface);
return *this;
}
- RCSQueryParams& RCSQueryParams::setResuorceType(const std::string& resourceType)
- {
- m_resourceType = resourceType;
- return *this;
- }
-
- RCSQueryParams& RCSQueryParams::setResuorceType(std::string&& resourceType)
+ RCSQueryParams& RCSQueryParams::setResourceType(std::string resourceType)
{
m_resourceType = std::move(resourceType);
return *this;
}
- RCSQueryParams& RCSQueryParams::put(const std::string& key, const std::string& value)
- {
- m_map[key] = value;
- return *this;
- }
-
- RCSQueryParams& RCSQueryParams::put(std::string&& key, std::string&& value)
+ RCSQueryParams& RCSQueryParams::put(std::string key, std::string value)
{
m_map[std::move(key)] = std::move(value);
return *this;
}
- RCSQueryParams& RCSQueryParams::put(const std::string& key, std::string&& value)
- {
- m_map[key] = std::move(value);
- return *this;
- }
-
- RCSQueryParams& RCSQueryParams::put(std::string&& key, const std::string& value)
- {
- m_map[std::move(key)] = value;
- return *this;
- }
-
std::string RCSQueryParams::getResourceInterface() const
{
return m_resourceInterface;
std::string RCSQueryParams::get(const std::string& key) const
{
- return m_map.at(key);
+ try
+ {
+ return m_map.at(key);
+ }
+ catch (const std::out_of_range&)
+ {
+ throw RCSInvalidKeyException(key + " is an invalid key");
+ }
}
const RCSQueryParams::Map& RCSQueryParams::getAll() const
return m_map;
}
-
RCSRemoteResourceObject::RCSRemoteResourceObject(
- std::shared_ptr< PrimitiveResource > pResource) :
- m_primitiveResource{ pResource },
+ std::shared_ptr< PrimitiveResource > primtiveResource) :
+ m_primitiveResource{ primtiveResource },
m_cacheId{ },
m_brokerId{ }
{
catch(std::exception &e){
OIC_LOG_V(ERROR, TAG, "%s", e.what());
}
-
}
RCSRemoteResourceObject::Ptr RCSRemoteResourceObject::fromOCResource(
PrimitiveResource::create(ocResource));
}
+ std::shared_ptr< OC::OCResource > RCSRemoteResourceObject::toOCResource(
+ RCSRemoteResourceObject::Ptr rcsResource)
+ {
+ if (!rcsResource)
+ {
+ throw RCSInvalidParameterException("the rcs resource must not be nullptr.");
+ }
+
+ OC::OCResource::Ptr ocResource = OC::OCPlatform::constructResourceObject(rcsResource->getAddress(),
+ rcsResource->getUri(),
+ rcsResource->m_primitiveResource->getConnectivityType(),
+ rcsResource->isObservable(),
+ rcsResource->getTypes(),
+ rcsResource->getInterfaces());
+
+ return ocResource;
+ }
+
bool RCSRemoteResourceObject::isMonitoring() const
{
return m_brokerId != 0;
startCaching({ });
}
- void RCSRemoteResourceObject::startCaching(CacheUpdatedCallback cb)
+ void RCSRemoteResourceObject::startCaching(CacheUpdatedCallback cb, CacheMode mode)
{
SCOPE_LOG_F(DEBUG, TAG);
throw RCSBadRequestException{ "Caching already started." };
}
- if (cb)
+ if (mode == CacheMode::OBSERVE_ONLY)
{
m_cacheId = ResourceCacheManager::getInstance()->requestResourceCache(
m_primitiveResource,
- std::bind(cachingCallback, std::placeholders::_1, std::placeholders::_2,
- std::move(cb)), REPORT_FREQUENCY::UPTODATE, 0);
+ std::bind(cachingCallback, std::placeholders::_1,
+ std::placeholders::_2, std::placeholders::_3,
+ std::move(cb), shared_from_this()), CACHE_METHOD::OBSERVE_ONLY,
+ REPORT_FREQUENCY::UPTODATE, 0);
+ }
+
+ else if (cb)
+ {
+ m_cacheId = ResourceCacheManager::getInstance()->requestResourceCache(
+ m_primitiveResource,
+ std::bind(cachingCallback, std::placeholders::_1,
+ std::placeholders::_2, std::placeholders::_3,
+ std::move(cb), shared_from_this()), CACHE_METHOD::ITERATED_GET,
+ REPORT_FREQUENCY::UPTODATE, 0);
}
else
{
m_cacheId = ResourceCacheManager::getInstance()->requestResourceCache(
- m_primitiveResource, { }, REPORT_FREQUENCY::NONE, 0);
+ m_primitiveResource, { }, CACHE_METHOD::ITERATED_GET,
+ REPORT_FREQUENCY::NONE, 0);
}
OIC_LOG_V(DEBUG, TAG, "startCaching CACHE ID %d", m_cacheId);
return;
}
- ResourceCacheManager::getInstance()->cancelResourceCache(m_cacheId);
+ try
+ {
+ ResourceCacheManager::getInstance()->cancelResourceCache(m_cacheId);
+ }
+ catch (const RCSInvalidParameterException &)
+ {
+ throw;
+ }
+ catch (...)
+ {
+ m_cacheId = 0;
+ throw;
+ }
m_cacheId = 0;
}
}
return convertCacheState(
- ResourceCacheManager::getInstance()->getResourceCacheState(m_primitiveResource));
+ ResourceCacheManager::getInstance()->getResourceCacheState(m_cacheId));
}
bool RCSRemoteResourceObject::isCachedAvailable() const
throw RCSBadRequestException{ "Cache data is not available." };
}
- return ResourceCacheManager::getInstance()->getCachedData(m_primitiveResource);
+ return ResourceCacheManager::getInstance()->getCachedData(m_cacheId);
}
RCSResourceAttributes::Value RCSRemoteResourceObject::getCachedAttribute(
const auto& paramMap = queryParams.getAll();
- std::cout << queryParams.getResourceInterface() << "??\n";
-
m_primitiveResource->requestGetWith(
queryParams.getResourceType(), queryParams.getResourceInterface(),
OC::QueryParamsMap{ paramMap.begin(), paramMap.end() },
std::move(cb));
}
+ void RCSRemoteResourceObject::set(const RCSQueryParams& queryParams,
+ const RCSRepresentation& rep, SetCallback cb)
+ {
+ SCOPE_LOG_F(DEBUG, TAG);
+
+ if (!cb)
+ {
+ throw RCSInvalidParameterException{ "set : Callback is empty" };
+ }
+
+ const auto& paramMap = queryParams.getAll();
+
+ m_primitiveResource->requestSetWith(
+ queryParams.getResourceType(), queryParams.getResourceInterface(),
+ OC::QueryParamsMap{ paramMap.begin(), paramMap.end() }, rep,
+ std::move(cb));
+ }
+
}
}