void ResourceHosting::discoveryHandler(RemoteObjectPtr remoteResource)
{
std::cout << "ResourceHosting: Discovered device with uri: " << remoteResource->getUri() << std::endl;
auto discoverdUri = remoteResource->getUri();
if (discoverdUri.compare(
discoverdUri.size()-HOSTING_TAG_SIZE, HOSTING_TAG_SIZE, HOSTING_TAG) != 0)
{
return;
}
auto foundHostingObject = findRemoteResource(remoteResource);
if (foundHostingObject != nullptr) return;
try
{
HostingObjectKey key = generateHostingObjectKey(remoteResource);
foundHostingObject = HostingObject::createHostingObject(remoteResource,
std::bind(&ResourceHosting::destroyedHostingObject, this, key));
RHLock lock(m_mutexForList);
m_hostingObjects.insert(std::make_pair(key, foundHostingObject));
} catch (const RCSException & e)
{
OIC_HOSTING_LOG(DEBUG,
"[ResourceHosting::discoverHandler]InvalidParameterException:%s", e.what());
}
}
bool ResourceHosting::isSameRemoteResource(
RemoteObjectPtr remoteResource_1, RemoteObjectPtr remoteResource_2)
{
bool ret = false;
if(remoteResource_1->getAddress() == remoteResource_2->getAddress() &&
remoteResource_1->getUri() == remoteResource_2->getUri())
{
ret = true;
}
return ret;
}
HostingObject::ResourceObjectPtr HostingObject::createMirroredServer(RemoteObjectPtr rObject)
{
ResourceObjectPtr retResource = nullptr;
if(rObject != nullptr)
{
std::string fulluri = rObject->getUri();
std::string uri = fulluri.substr(0, fulluri.size()-8);
std::vector<std::string> types = rObject->getTypes();
std::vector<std::string> interfaces = rObject->getInterfaces();
try
{
std::string type = types.begin()->c_str();
std::string interface = interfaces.begin()->c_str();
retResource = RCSResourceObject::Builder(uri, type, interface).
setDiscoverable(true).setObservable(true).build();
// TODO need to bind types and interfaces
retResource->setAutoNotifyPolicy(RCSResourceObject::AutoNotifyPolicy::UPDATED);
retResource->setSetRequestHandler(pSetRequestHandler);
}catch(...)
{
OIC_HOSTING_LOG(DEBUG, "[HostingObject::createMirroredServer] %s", "PlatformException");
throw;
}
}
else
{
throw PlatformException(OC_STACK_ERROR);
}
return retResource;
}
void ResourceHosting::discoverHandler(RemoteObjectPtr remoteResource)
{
std::string discoverdUri = remoteResource->getUri();
if(discoverdUri.compare(
discoverdUri.size()-HOSTING_TAG_SIZE, HOSTING_TAG_SIZE, HOSTING_TAG) != 0)
{
return;
}
HostingObjectPtr foundHostingObject = findRemoteResource(remoteResource);
if(foundHostingObject == nullptr)
{
try
{
foundHostingObject = std::make_shared<HostingObject>();
foundHostingObject->initializeHostingObject(remoteResource,
std::bind(&ResourceHosting::destroyedHostingObject, this,
HostingObjectWeakPtr(foundHostingObject)));
hostingObjectList.push_back(foundHostingObject);
}catch(const RCSInvalidParameterException &e)
{
OIC_HOSTING_LOG(DEBUG,
"[ResourceHosting::discoverHandler]InvalidParameterException:%s", e.what());
}
}
}
ResourceHosting::HostingObjectKey ResourceHosting::generateHostingObjectKey(
RemoteObjectPtr rResource)
{
return generateHostingObjectKey(rResource->getAddress(), rResource->getUri());
}
