bool ThingsMaintenance::isSimpleResource(std::shared_ptr< OCResource > resource)
{
for (unsigned int i = 0; i < resource->getResourceTypes().size(); ++i)
{
if (resource->getResourceTypes().at(0).find(".resourceset", 0) != std::string::npos)
return false;
}
return true;
}
OCStackResult ThingsMaintenance::factoryReset(std::shared_ptr< OCResource > resource,
MaintenanceCallback callback)
{
if (!resource)
{
std::cout << "resource is NULL\n";
return OC_STACK_ERROR;
}
std::string mnt = "fr";
// Check the request queue if a previous request is still left. If so, remove it.
std::map< std::string, MaintenanceRequestEntry >::iterator iter =
maintenanceRequestTable.find(mnt);
if (iter != maintenanceRequestTable.end())
maintenanceRequestTable.erase(iter);
// Create new request entry stored in the queue
MaintenanceRequestEntry newCallback(mnt, callback, resource, "true");
maintenanceRequestTable.insert(std::make_pair(mnt, newCallback));
QueryParamsMap query;
OCRepresentation rep;
if (isSimpleResource(resource))
{
// This resource is a simple resource. Just send a PUT message
OCRepresentation rep;
rep.setValue < std::string > ("value", "true");
return resource->put(resource->getResourceTypes().at(0), DEFAULT_INTERFACE, rep, query,
std::function<
void(const HeaderOptions& headerOptions, const OCRepresentation& rep,
const int eCode) >(
std::bind(&ThingsMaintenance::onPut, this, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3, mnt)));
}
else
{
// This resource is a collection resource. It just acquires child resource's URI and
// send GET massages to the child resources in turn.
// First, request the child resources's URI.
// TODO: Add a deletion of actionset
return resource->get(resource->getResourceTypes().at(0), DEFAULT_INTERFACE, query,
std::function<
void(const HeaderOptions& headerOptions, const OCRepresentation& rep,
const int eCode) >(
std::bind(&ThingsMaintenance::onGetChildInfoForUpdate, this,
std::placeholders::_1, std::placeholders::_2,
std::placeholders::_3, mnt)));
}
}
void printResourceInformation(std::shared_ptr< OC::OCResource > resource)
{
std::lock_guard<std::mutex> lock(g_iotivity_utility_print_mutex);
try
{
std::cout << "------------------------------------------------------" << std::endl;
std::cout << "DISCOVERED Resource:" << std::endl;
std::cout << "\tResource address: " << resource->host() << std::endl;
std::cout << "\tResource uri: " << resource->uri() << std::endl;
std::cout << "\tList of resource interfaces: " << std::endl;
for (auto &resourceInterface : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterface << std::endl;
}
std::cout << "\tList of resource types: " << std::endl;
for (auto &resourceType : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceType << std::endl;
}
}
catch (std::exception &e)
{
std::cerr << "Caught exception in printResourceInformation: " << e.what() << std::endl;
}
}
void printResourceCompact(std::shared_ptr< OC::OCResource > resource)
{
std::unique_lock<std::mutex> lock(g_iotivity_utility_print_mutex);
try
{
resource->get(OC::QueryParamsMap(), &on_iotivity_utility_get);
g_iotivity_utility_condition_variable.wait(lock);
std::cout << "\t" << resource->host() << resource->uri() << std::endl // uri is links.href
<< "\tresourceTypes ";
for (auto rt : resource->getResourceTypes())
{
std::cout << rt << " ";
}
std::cout << std::endl;
std::cout << "\tresourceInterfaces ";
for (auto ri : resource->getResourceInterfaces())
{
std::cout << ri << " ";
}
std::cout << std::endl;
std:: cout << "\tsid " << resource->sid() << std::endl;
}
catch (std::exception &e)
{
std::cerr << "Caught exception in printResourceInformation: " << e.what() << std::endl;
}
}
void MenuBrightness::onFindResource(std::shared_ptr< OC::OCResource > resource)
{
std::lock_guard<std::mutex> lock(m_mutex);
std::cout << "Found resource" << std::endl;
try
{
if (resource)
{
for (auto &resourceType : resource->getResourceTypes())
{
if (resourceType == UPNP_OIC_TYPE_BRIGHTNESS)
{
if (m_brightnessSet.find(resource) == m_brightnessSet.end())
{
m_brightnessSet.insert(resource);
m_brightnessVector.push_back(resource);
if (m_brightnessSet.size() != m_brightnessVector.size())
{
std::cerr << "Mismatch in discovered Services. Reinitilizing.";
init(m_brightnessSet);
}
}
}
}
}
}
catch (std::exception &e)
{
std::cerr << "Caught exception in foundResource: " << e.what() << std::endl;
}
}
// Callback to found resources
void foundResource(std::shared_ptr<OCResource> resource)
{
std::lock_guard<std::mutex> lock(curResourceLock);
if(curResource)
{
std::cout << "Found another resource, ignoring"<<std::endl;
return;
}
std::string resourceURI;
std::string hostAddress;
try
{
// Do some operations with resource object.
if(resource)
{
std::cout<<"DISCOVERED Resource:"<<std::endl;
// Get the resource URI
resourceURI = resource->uri();
std::cout << "\tURI of the resource: " << resourceURI << std::endl;
// Get the resource host address
hostAddress = resource->host();
std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
// Get the resource types
std::cout << "\tList of resource types: " << std::endl;
for(auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
}
// Get the resource interfaces
std::cout << "\tList of resource interfaces: " << std::endl;
for(auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
if(resourceURI == "/a/garage")
{
curResource = resource;
// Call a local function which will internally invoke
// get API on the resource pointer
getLightRepresentation(resource);
}
}
else
{
// Resource is invalid
std::cout << "Resource is invalid" << std::endl;
}
}
catch(std::exception& e)
{
std::cerr << "Exception in foundResource: "<< e.what()<<std::endl;
}
}
void foundResource(std::shared_ptr<OCResource> resource)
{
std::cout << "In foundResource\n";
std::string resourceURI;
std::string hostAddress;
try
{
if(discoveredResources.find(resource->uniqueIdentifier()) == discoveredResources.end())
{
std::cout << "Found resource " << resource->uniqueIdentifier() <<
" for the first time on server with ID: "<< resource->sid()<<std::endl;
discoveredResources[resource->uniqueIdentifier()] = resource;
}
else
{
std::cout<<"Found resource "<< resource->uniqueIdentifier() << " again!"<<std::endl;
}
if(curResource)
{
std::cout << "Found another resource, ignoring"<<std::endl;
return;
}
if(resource)
{
std::cout<<"DISCOVERED Resource:"<<std::endl;
resourceURI = resource->uri();
std::cout << "\tURI of the resource: " << resourceURI << std::endl;
hostAddress = resource->host();
std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
std::cout << "\tList of resource types: " << std::endl;
for(auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
}
std::cout << "\tList of resource interfaces: " << std::endl;
for(auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
if(resourceURI == "/a/rvi")
{
curResource = resource;
dlog_print(DLOG_INFO, LOG_TAG, "RVI resource detected");
ocfinitialized = 1;
}
}
else
{
std::cout << "Resource is invalid" << std::endl;
}
}
catch(std::exception& e)
{
std::cerr << "Exception in foundResource: "<< e.what() << std::endl;
}
std::cout << "-----------------------Exit foundResource\n";
}
OCStackResult GroupManager::cancelActionSet(std::shared_ptr< OCResource > resource,
std::string actionsetName, PostCallback cb)
{
if (resource != NULL)
{
OCRepresentation rep;
rep.setValue("CancelAction", actionsetName);
return resource->post(resource->getResourceTypes().front(), GROUP_INTERFACE, rep,
QueryParamsMap(), cb);
}
else
{
return OC_STACK_ERROR;
}
}
void printResourceInfo(std::shared_ptr<OCResource> resource)
{
std::cout << "Found Resource: "<<std::endl;
std::cout << "\tHost: "<< resource->host()<<std::endl;
std::cout << "\tURI: "<< resource->uri()<<std::endl;
// Get the resource types
std::cout << "\tList of resource types: " << std::endl;
for(auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
}
// Get the resource interfaces
std::cout << "\tList of resource interfaces: " << std::endl;
for(auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
}
void foundResource(std::shared_ptr<OCResource> resource)
{
std::cout << "In foundResource" << std::endl;
if(resource && resource->uri() == "/q/foo")
{
{
std::lock_guard<std::mutex> lock(m_resourceLock);
if(m_resource)
{
return;
}
m_resource = resource;
}
std::cout << "Found Resource: "<<std::endl;
std::cout << "\tHost: "<< resource->host()<<std::endl;
std::cout << "\tURI: "<< resource->uri()<<std::endl;
// Get the resource types
std::cout << "\tList of resource types: " << std::endl;
for(auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
}
// Get the resource interfaces
std::cout << "\tList of resource interfaces: " << std::endl;
for(auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
std::cout<<"Doing a get on q/foo."<<std::endl;
resource->get(QueryParamsMap(),
GetCallback(std::bind(&ClientWorker::getResourceInfo, this,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
}
}
OCStackResult GroupManager::executeActionSet(std::shared_ptr< OCResource > resource,
std::string actionsetName, long int delay, PostCallback cb)
{
if(delay <= 0 )
{
return OC_STACK_INVALID_PARAM;
}
if (resource != NULL)
{
std::string value = actionsetName;
value.append("*");
value.append(std::to_string(delay));
OCRepresentation rep;
rep.setValue("DoScheduledAction", value);
return resource->post(resource->getResourceTypes().front(), GROUP_INTERFACE, rep,
QueryParamsMap(), cb);
}
else
{
return OC_STACK_ERROR;
}
}
OCStackResult GroupManager::addActionSet(std::shared_ptr< OCResource > resource,
const ActionSet* newActionSet, PutCallback cb)
{
// BUILD message of ActionSet which it is included delimiter.
if ((resource != NULL) && (newActionSet != NULL))
{
if(newActionSet->mDelay < 0)
{
return OC_STACK_INVALID_PARAM;
}
std::string message = getStringFromActionSet(newActionSet);
OCRepresentation rep;
rep.setValue("ActionSet", message);
return resource->put(resource->getResourceTypes().front(), GROUP_INTERFACE, rep,
QueryParamsMap(), cb);
}
else
{
return OC_STACK_ERROR;
}
}
// Callback to found resources
void foundResource(std::shared_ptr<OCResource> resource)
{
std::lock_guard<std::mutex> lock(resourceLock);
if(curResource)
{
std::cout << "Found another resource, ignoring"<<std::endl;
return;
}
std::string resourceURI;
std::string hostAddress;
try
{
// Do some operations with resource object.
if(resource)
{
std::cout<<"DISCOVERED Resource:"<<std::endl;
// Get the resource URI
resourceURI = resource->uri();
std::cout << "\tURI of the resource: " << resourceURI << std::endl;
// Get the resource host address
hostAddress = resource->host();
std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
// Get the resource types
std::cout << "\tList of resource types: " << std::endl;
for(auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
}
// Get the resource interfaces
std::cout << "\tList of resource interfaces: " << std::endl;
for(auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
if(resourceURI == "/a/light")
{
OCStackResult result = OC_STACK_OK;
curResource = resource;
OCPlatform::OCPresenceHandle presenceHandle = nullptr;
if(TEST_CASE == TEST_UNICAST_PRESENCE_NORMAL)
{
result = OCPlatform::subscribePresence(presenceHandle, hostAddress,
connectivityType, &presenceHandler);
if(result == OC_STACK_OK)
{
std::cout<< "Subscribed to unicast address: " << hostAddress << std::endl;
}
else
{
std::cout<< "Failed to subscribe to unicast address:" << hostAddress
<< std::endl;
}
}
if(TEST_CASE == TEST_UNICAST_PRESENCE_WITH_FILTER ||
TEST_CASE == TEST_UNICAST_PRESENCE_WITH_FILTERS)
{
result = OCPlatform::subscribePresence(presenceHandle, hostAddress,
"core.light", connectivityType, &presenceHandler);
if(result == OC_STACK_OK)
{
std::cout<< "Subscribed to unicast address: " << hostAddress;
}
else
{
std::cout<< "Failed to subscribe to unicast address: " << hostAddress;
}
std::cout << " with resource type \"core.light\"." << std::endl;
}
if(TEST_CASE == TEST_UNICAST_PRESENCE_WITH_FILTERS)
{
result = OCPlatform::subscribePresence(presenceHandle, hostAddress, "core.fan",
connectivityType, &presenceHandler);
if(result == OC_STACK_OK)
{
std::cout<< "Subscribed to unicast address: " << hostAddress;
}
else
{
std::cout<< "Failed to subscribe to unicast address: " << hostAddress;
}
std::cout << " with resource type \"core.fan\"." << std::endl;
}
}
}
else
{
// Resource is invalid
std::cout << "Resource is invalid" << std::endl;
}
}
catch(std::exception& e)
{
//log(e.what());
}
}
// Callback to found resources
void foundResource(std::shared_ptr<OCResource> resource)
{
std::cout << "In foundResource\n";
std::string resourceURI = resource->uri();
std::string hostAddress;
try
{
{
std::lock_guard<std::mutex> lock(curResourceLock);
if (discoveredResources.find(resource->uniqueIdentifier()) == discoveredResources.end())
{
std::cout << "Found resource " << resource->uniqueIdentifier() <<
" for the first time on server with ID: " << resource->sid() << std::endl;
discoveredResources[resource->uniqueIdentifier()] = resource;
if (resourceURI.find("/discomfortIndex") != std::string::npos)
{
std::cout << "discomfortIndex found !!! " << std::endl;
DISensorResource = resource;
OCRepresentation rep;
rep.setValue("humidity", std::string("30"));
rep.setValue("temperature", std::string("27"));
resource->put(rep, QueryParamsMap(), &onPutForDISensor);
}
}
else
{
std::cout << "Found resource " << resource->uniqueIdentifier() << " again!" << std::endl;
}
if (curResource)
{
std::cout << "Found another resource, ignoring" << std::endl;
return;
}
}
// Do some operations with resource object.
if (resource)
{
std::cout << "DISCOVERED Resource:" << std::endl;
// Get the resource URI
resourceURI = resource->uri();
std::cout << "\tURI of the resource: " << resourceURI << std::endl;
// Get the resource host address
hostAddress = resource->host();
std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
// Get the resource types
std::cout << "\tList of resource types: " << std::endl;
for (auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
if (resourceTypes == "oic.r.light")
{
curResource = resource;
// Call a local function which will internally invoke get API on the resource pointer
getLightRepresentation(resource);
}
}
// Get the resource interfaces
std::cout << "\tList of resource interfaces: " << std::endl;
for (auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
}
else
{
// Resource is invalid
std::cout << "Resource is invalid" << std::endl;
}
}
catch (std::exception &e)
{
std::cerr << "Exception in foundResource: " << e.what() << std::endl;
}
}
void onFoundResource(std::shared_ptr<SimulatorRemoteResource> resource)
{
JNIEnv *env = getEnv();
if (nullptr == env)
return;
jobject foundResourceListener = env->NewLocalRef(m_listener);
if (!foundResourceListener)
{
releaseEnv();
return;
}
jclass foundResourceCls = env->GetObjectClass(foundResourceListener);
if (!foundResourceCls)
{
releaseEnv();
return;
}
jmethodID foundResourceMId = env->GetMethodID(foundResourceCls, "onResourceCallback",
"(Lorg/oic/simulator/clientcontroller/SimulatorRemoteResource;)V");
if (!foundResourceMId)
{
releaseEnv();
return;
}
JniSimulatorRemoteResource *jniSimulatorResource = new JniSimulatorRemoteResource(resource);
if (!jniSimulatorResource)
{
releaseEnv();
return;
}
jobject simulatorResource = SimulatorRemoteResourceToJava(env,
reinterpret_cast<jlong>(jniSimulatorResource));
jfieldID fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mUri",
"Ljava/lang/String;");
jstring jUri = env->NewStringUTF(resource->getURI().c_str());
env->SetObjectField(simulatorResource, fieldID, jUri);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mConnType", "I");
jint jConnType = resource->getConnectivityType();
env->SetIntField(simulatorResource, fieldID, jConnType);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mHost",
"Ljava/lang/String;");
jstring jHost = env->NewStringUTF(resource->getHost().c_str());
env->SetObjectField(simulatorResource, fieldID, jHost);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mId",
"Ljava/lang/String;");
jstring jUid = env->NewStringUTF(resource->getID().c_str());
env->SetObjectField(simulatorResource, fieldID, jUid);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResTypes",
"Ljava/util/LinkedList;");
std::vector<std::string> resourceTypes = resource->getResourceTypes();
jobject jResTypes = convertStringVectorToJavaList(env, resourceTypes);
env->SetObjectField(simulatorResource, fieldID, jResTypes);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResInterfaces",
"Ljava/util/LinkedList;");
std::vector<std::string> interfaceTypes = resource->getResourceInterfaces();
jobject jResInterfaces = convertStringVectorToJavaList(env, interfaceTypes);
env->SetObjectField(simulatorResource, fieldID, jResInterfaces);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mIsObservable", "Z");
env->SetBooleanField(simulatorResource, fieldID, resource->isObservable());
env->CallVoidMethod(foundResourceListener, foundResourceMId, simulatorResource);
if ((env)->ExceptionCheck())
{
delete jniSimulatorResource;
releaseEnv();
return;
}
releaseEnv();
}
void resourceFindCallback::foundResource(std::shared_ptr<OCResource> resource) {
resourceCallbackMutex.lock();
Dart_CObject* result = new Dart_CObject;
// Indicate invocation
m_callbackInvoked = true;
try {
// Check for a null resource
if (resource == NULL) {
// Return a boolean here to indicate no resources found
Dart_CObject* servicePortObject = m_message->value.as_array.values[EXT_SERVICE_PORT];
Dart_Port reply_port_id = servicePortObject->value.as_send_port.id;
result->type = Dart_CObject_kBool;
result->value.as_bool = false;
Dart_PostCObject(reply_port_id, result);
resourceCallbackMutex.unlock();
#ifdef DEBUG
std::cout << "<<< foundResource - returned invalid result" << std::endl;
#endif
} else {
#ifdef DEBUG
//std::cout << "<<< foundResource - resource id is " << resource->uniqueIdentifier() << std::endl;
#endif
// Build and return the result for a found resource
// Host
Dart_CObject* retHost = new Dart_CObject;
std::string host = resource->host();
retHost->type = Dart_CObject_kString;
retHost->value.as_string = const_cast<char*> (host.c_str());
// Uri
Dart_CObject* retUri = new Dart_CObject;
std::string uri = resource->uri();
retUri->type = Dart_CObject_kString;
retUri->value.as_string = const_cast<char*> (uri.c_str());
// Unique id
Dart_CObject* retUid = new Dart_CObject;
retUid->type = Dart_CObject_kString;
retUid->value.as_string = const_cast<char*> (uri.c_str());
// We don't know how many resource and interface types a resource has so
// use dynamic memory allocation, not Dart as we have no zone in this callback.
// Resource types
Dart_CObject* retResourceTypes = new Dart_CObject;
Dart_CObject* resTemp;
std::vector<std::string> resourceTypes = resource->getResourceTypes();
long unsigned int resourceTypesLen = resourceTypes.size();
Dart_CObject** resourceTemp = new Dart_CObject*[resourceTypesLen];
int i = 0;
for (std::vector<std::string>::iterator it = resourceTypes.begin(); it != resourceTypes.end(); ++it) {
resTemp = new Dart_CObject;
resTemp->type = Dart_CObject_kString;
resTemp->value.as_string = const_cast<char*> ((*it).c_str());
resourceTemp[i] = resTemp;
i++;
}
retResourceTypes->type = Dart_CObject_kArray;
retResourceTypes->value.as_array.values = resourceTemp;
retResourceTypes->value.as_array.length = resourceTypesLen;
// Interface types
Dart_CObject* retInterfaceTypes = new Dart_CObject;
Dart_CObject* intTemp;
std::vector<std::string> intTypes = resource->getResourceInterfaces();
long unsigned intTypesLen = intTypes.size();
Dart_CObject** interfaceTemp = new Dart_CObject*[intTypesLen];
i = 0;
for (std::vector<std::string>::iterator it = intTypes.begin(); it != intTypes.end(); ++it) {
intTemp = new Dart_CObject;
intTemp->type = Dart_CObject_kString;
intTemp->value.as_string = const_cast<char*> ((*it).c_str());
interfaceTemp[i] = intTemp;
i++;
}
retInterfaceTypes->type = Dart_CObject_kArray;
retInterfaceTypes->value.as_array.values = interfaceTemp;
retInterfaceTypes->value.as_array.length = intTypesLen;
// Observable
Dart_CObject* retObservable = new Dart_CObject;
bool observable = resource->isObservable();
retObservable->type = Dart_CObject_kBool;
retObservable->value.as_bool = observable;
// Create a proxy object from the resource so we can see this outside
// of this handler.
OCResource::Ptr resourcePtr = OCPlatform::constructResourceObject(resource->host(),
resource->uri(),
resource->connectivityType(), resource->isObservable(),
resource->getResourceTypes(),
resource->getResourceInterfaces());
// The proxy object is only supports put/get/observe functionality so get as
// much resource data as we can here and return it to create a resource class.
// The pointer
Dart_CObject* retPtr = new Dart_CObject;
retPtr->type = Dart_CObject_kInt64;
retPtr->value.as_int64 = reinterpret_cast<int64_t> (resourcePtr.get());
// Return it all
Dart_CObject** temp = new Dart_CObject*[PLATFORM_FIND_RESOURCES_RET_PARAMS];
temp[0] = retPtr;
temp[1] = retUid;
temp[2] = retUri;
temp[3] = retHost;
temp[4] = retResourceTypes;
temp[5] = retInterfaceTypes;
temp[6] = retObservable;
result->type = Dart_CObject_kArray;
result->value.as_array.values = temp;
result->value.as_array.length = PLATFORM_FIND_RESOURCES_RET_PARAMS;
if (m_resListCount <= (MAX_DISCOVERABLE_RESOURCES - 1)) {
m_resList[m_resListCount] = result;
++m_resListCount;
}
#ifdef DEBUG
std::cout << "<<< foundResource - returned valid result id is " << resource->uniqueIdentifier() << std::endl;
std::cout << "<<< foundResource - returned valid result uri is " << resource->uri() << std::endl;
#endif
}
resourceCallbackMutex.unlock();
} catch (std::exception& e) {
std::cout << "Exception in foundResource: " << e.what() << std::endl;
}
}
void GroupManager::onFoundResource(std::shared_ptr< OCResource > resource, int waitsec)
{
std::string resourceURI;
std::string hostAddress;
try
{
// Do some operations with resource object.
if (resource)
{
std::cout << "DISCOVERED Resource:" << std::endl;
// Get the resource URI
resourceURI = resource->uri();
std::cout << "\tURI of the resource: " << resourceURI << std::endl;
// Get the resource host address
hostAddress = resource->host();
std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
// Get the resource types
std::cout << "\tList of resource types: " << std::endl;
hostAddress.append(resourceURI);
for (auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
if (std::find(allFoundResourceTypes.begin(), allFoundResourceTypes.end(),
resourceTypes) == allFoundResourceTypes.end())
{
allFoundResourceTypes.push_back(resourceTypes);
}
rtForResourceList[resourceTypes][hostAddress] = resource;
}
// Get the resource interfaces
std::cout << "\tList of resource interfaces: " << std::endl;
for (auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
if (waitsec == -1)
{
findPreparedRequest(candidateRequest);
}
}
else
{
// Resource is invalid
std::cout << "Resource is invalid" << std::endl;
}
}
catch (std::exception& e)
{
//log(e.what());
}
}
// Callback to found resources
void foundResource(std::shared_ptr<OCResource> resource)
{
std::string resourceURI;
std::string hostAddress;
try
{
// Do some operations with resource object.
if(resource)
{
std::lock_guard<std::mutex> lk(resourceLock);
if(discoveredResources.find(resource) == discoveredResources.end())
{
std::cout << "Found resource " << resource->uniqueIdentifier() <<
" for the first time on server with ID: "<< resource->sid()<<std::endl;
discoveredResources.insert(resource);
}
else
{
std::cout<<"Found resource "<< resource->uniqueIdentifier() << " again!"<<std::endl;
}
if(curResource)
{
std::cout << "Found another resource, ignoring"<<std::endl;
return;
}
std::cout<<"DISCOVERED Resource:"<<std::endl;
// Get the resource URI
resourceURI = resource->uri();
std::cout << "\tURI of the resource: " << resourceURI << std::endl;
// Get the resource host address
hostAddress = resource->host();
std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
// Get the resource types
std::cout << "\tList of resource types: " << std::endl;
for(auto &resourceTypes : resource->getResourceTypes())
{
std::cout << "\t\t" << resourceTypes << std::endl;
}
// Get the resource interfaces
std::cout << "\tList of resource interfaces: " << std::endl;
for(auto &resourceInterfaces : resource->getResourceInterfaces())
{
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
if(resourceURI == "/a/light")
{
curResource = resource;
sleep(1);
// Call a local function which will internally invoke get
// API on the resource pointer
getLightRepresentation(resource);
}
}
else
{
// Resource is invalid
std::cout << "Resource is invalid" << std::endl;
}
}
catch(std::exception& e)
{
std::cerr << "Exception in foundResource: "<< e.what() <<std::endl;
}
}
// Callback to found resources
void SensorResource::foundResource(std::shared_ptr<OCResource> resource)
{
std::string resourceURI;
std::string hostAddress;
std::lock_guard<std::mutex> lock(m_resourceLock);
try {
if(resource) {
std::cout<<"DISCOVERED Resource:"<<std::endl;
resourceURI = resource->uri();
std::cout << "\tURI of the resource: " << resourceURI << std::endl;
hostAddress = resource->host();
std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
std::cout << "\tList of resource types: " << std::endl;
for(auto &resourceTypes : resource->getResourceTypes()) {
std::cout << "\t\t" << resourceTypes << std::endl;
}
std::cout << "\tList of resource interfaces: " << std::endl;
for(auto &resourceInterfaces : resource->getResourceInterfaces()) {
std::cout << "\t\t" << resourceInterfaces << std::endl;
}
GetCallback g (std::bind(&SensorResource::onGet, this, PH::_1, PH::_2, PH::_3));
ObserveCallback o (std::bind(&SensorResource::onObserve, this, PH::_1, PH::_2, PH::_3, PH::_4));
if (resourceURI == "/sensor/gas") {
std::cout << "\tFound Gas Sensor." << std::endl;
resource->observe(ObserveType::Observe, QueryParamsMap(), o);
m_gas.s_resource = resource;
m_gas.s_active = true;
}
else if (resourceURI == "/a/fan") {
std::cout << "\tFound Fan Device." << std::endl;
resource->observe(ObserveType::Observe, QueryParamsMap(), o);
QueryParamsMap params;
resource->get(params, g);
m_fan.s_resource = resource;
m_fan.s_active = true;
}
else if (resourceURI == "/intel/chainable_led_edison") {
std::cout << "\tFound Edison Led Device." << std::endl;
resource->observe(ObserveType::Observe, QueryParamsMap(), o);
QueryParamsMap params;
resource->get(params, g);
m_led.s_resource = resource;
m_led.s_active = true;
}
else if (resourceURI == "/sensor/pri") {
std::cout << "\tFound Pri Device." << std::endl;
resource->observe(ObserveType::Observe, QueryParamsMap(), o);
m_pri.s_resource = resource;
m_pri.s_active = true;
}
else {
std::cout << "Resource unknown." << std::endl;
}
}
else {
std::cout << "Resource is invalid" << std::endl;
}
}
catch(std::exception& e) {
//log(e.what());
}
}
