NSResult NSUnRegisterResource()
{
NS_LOG(DEBUG, "NSUnRegisterResource - IN");
if (OCDeleteResource(NotificationResource.handle) != OC_STACK_OK)
{
NS_LOG(ERROR, "Fail to Delete Notification Resource");
return NS_ERROR;
}
if (OCDeleteResource(NotificationMessageResource.handle) != OC_STACK_OK)
{
NS_LOG(ERROR, "Fail to Delete Notification Message Resource");
return NS_ERROR;
}
if (OCDeleteResource(NotificationSyncResource.handle) != OC_STACK_OK)
{
NS_LOG(ERROR, "Fail to Delete Notification Sync Resource");
return NS_ERROR;
}
NotificationResource.handle = NULL;
NotificationMessageResource.handle = NULL;
NotificationSyncResource.handle = NULL;
NS_LOG(DEBUG, "NSUnRegisterResource - OUT");
return NS_OK;
}
OCStackResult InProcServerWrapper::unregisterResource(const OCResourceHandle& resourceHandle)
{
auto cLock = m_csdkLock.lock();
OCStackResult result = OC_STACK_ERROR;
if(cLock)
{
std::lock_guard<std::recursive_mutex> lock(*cLock);
result = OCDeleteResource(resourceHandle);
if(result == OC_STACK_OK)
{
std::lock_guard<std::mutex> lock(OC::details::serverWrapperLock);
OC::details::resourceUriMap.erase(resourceHandle);
}
else
{
throw OCException(OC::Exception::RESOURCE_UNREG_FAILED, result);
}
}
else
{
result = OC_STACK_ERROR;
}
return result;
}
/**
* Perform cleanup for pstat resources.
*
* @retval OC_STACK_OK for Success, otherwise some error value
*/
OCStackResult DeInitPstatResource()
{
if(gPstat != &gDefaultPstat)
{
DeletePstatBinData(gPstat);
gPstat = NULL;
}
return OCDeleteResource(gPstatHandle);
}
OCStackResult DeleteProvisioningResource()
{
OCStackResult res = OCDeleteResource(gProvResource.handle);
if (res != OC_STACK_OK)
{
OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
}
return res;
}
void delete_resource(struct things_server_builder_s *builder)
{
iotivity_api_lock();
for (size_t iter = 0; iter < builder->res_num; iter++) {
OCStackResult ret = OCDeleteResource((OCResourceHandle)(builder->gres_arr[iter]->resource_handle));
if (ret != OC_STACK_OK) {
THINGS_LOG_E(TAG, "Failed to delete the resource");
}
}
iotivity_api_unlock();
}
void *presenceNotificationGenerator(void *param)
{
sleep(5);
(void)param;
OCDoHandle presenceNotificationHandles[numPresenceResources];
OCStackResult res = OC_STACK_OK;
std::array<std::string, numPresenceResources> presenceNotificationResources { {
std::string("core.fan"),
std::string("core.led") } };
std::array<std::string, numPresenceResources> presenceNotificationUris { {
std::string("/a/fan"),
std::string("/a/led") } };
for(int i=0; i<numPresenceResources; i++)
{
if(res == OC_STACK_OK)
{
sleep(1);
res = OCCreateResource(&presenceNotificationHandles[i],
presenceNotificationResources.at(i).c_str(),
"oc.mi.def",
presenceNotificationUris.at(i).c_str(),
OCNOPEntityHandlerCb,
OC_DISCOVERABLE|OC_OBSERVABLE);
}
if(res != OC_STACK_OK)
{
OC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to create resource "
"%s with result %s.", presenceNotificationResources.at(i).c_str(),
getResult(res));
break;
}
}
sleep(5);
for(int i=0; i<numPresenceResources; i++)
{
if(res == OC_STACK_OK)
{
res = OCDeleteResource(presenceNotificationHandles[i]);
}
if(res != OC_STACK_OK)
{
OC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to delete "\
"resource %s.", presenceNotificationResources.at(i).c_str());
break;
}
}
return NULL;
}
OCStackResult DeleteKeepAliveResource()
{
OIC_LOG(DEBUG, TAG, "DeleteKeepAliveResource IN");
// Create a KeepAlive resource
OCStackResult result = OCDeleteResource(g_keepAliveHandle);
if (OC_STACK_OK != result)
{
OIC_LOG_V(ERROR, TAG, "Delete resource for KeepAlive failed[%d]", result);
}
OIC_LOG(DEBUG, TAG, "DeleteKeepAliveResource OUT");
return result;
}
/**
* Perform cleanup for DOXM resources.
*
* @return
* OC_STACK_OK - no error
* OC_STACK_ERROR - stack process error
*
*/
OCStackResult DeInitDoxmResource()
{
OCStackResult ret = OCDeleteResource(gDoxmHandle);
if(gDoxm != &gDefaultDoxm)
{
DeleteDoxmBinData(gDoxm);
}
gDoxm = NULL;
if(OC_STACK_OK == ret)
{
return OC_STACK_OK;
}
else
{
return OC_STACK_ERROR;
}
}
OCEntityHandlerResult ProcessDeleteRequest (OCEntityHandlerRequest *ehRequest, char *payload, uint16_t maxPayloadSize)
{
if(ehRequest == NULL)
{
OC_LOG(INFO, TAG, "The ehRequest is NULL");
return OC_EH_ERROR;
}
OCEntityHandlerResult ehResult = OC_EH_OK;
OC_LOG_V(INFO, TAG, "\n\nExecuting %s for resource %d ", __func__, ehRequest->resource);
/*
* In the sample below, the application will:
* 1a. pass the delete request to the c stack
* 1b. internally, the c stack figures out what needs to be done and does it accordingly
* (e.g. send observers notification, remove observers...)
* 1c. the c stack returns with the result whether the request is fullfilled.
* 2. optionally, app removes observers out of its array 'interestedObservers'
*/
const char* deleteResponse = NULL;
if ((ehRequest != NULL) && (ehRequest->resource == Light.handle))
{
//Step 1: Ask stack to do the work.
OCStackResult result = OCDeleteResource(ehRequest->resource);
if (result == OC_STACK_OK)
{
OC_LOG (INFO, TAG, "\n\nDelete Resource operation succeeded.");
ehResult = OC_EH_OK;
deleteResponse = responsePayloadDeleteOk;
//Step 2: clear observers who wanted to observe this resource at the app level.
for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
{
if (interestedObservers[i].resourceHandle == ehRequest->resource)
{
interestedObservers[i].valid = false;
interestedObservers[i].observationId = 0;
interestedObservers[i].resourceHandle = NULL;
}
}
}
else if (result == OC_STACK_NO_RESOURCE)
{
OC_LOG(INFO, TAG, "\n\nThe resource doesn't exist or it might have been deleted.");
deleteResponse = responsePayloadResourceDoesNotExist;
ehResult = OC_EH_RESOURCE_DELETED;
}
else
{
OC_LOG(INFO, TAG, "\n\nEncountered error from OCDeleteResource().");
deleteResponse = responsePayloadDeleteNotOK;
ehResult = OC_EH_ERROR;
}
}
else if (ehRequest->resource != Light.handle)
{
//Let's this app not supporting DELETE on some resources so
//consider the DELETE request is received for a non-support resource.
OC_LOG_V(INFO, TAG, "\n\nThe request is received for a non-support resource.");
deleteResponse = responsePayloadDeleteResourceNotSupported;
ehResult = OC_EH_FORBIDDEN;
}
if (maxPayloadSize > strlen ((char *)deleteResponse))
{
strncpy(payload, deleteResponse, strlen((char *)deleteResponse));
}
else
{
OC_LOG_V (INFO, TAG, "Response buffer: %d bytes is too small",
maxPayloadSize);
ehResult = OC_EH_ERROR;
}
return ehResult;
}
void *presenceNotificationGenerator(void *param)
{
uint8_t secondsBeforePresence = 10;
OIC_LOG_V(INFO, TAG, "Will send out presence in %u seconds", secondsBeforePresence);
sleep(secondsBeforePresence);
(void)param;
OCDoHandle presenceNotificationHandles[numPresenceResources];
OCStackResult res = OC_STACK_OK;
std::array<std::string, numPresenceResources> presenceNotificationResources { {
std::string("core.fan"),
std::string("core.led") } };
std::array<std::string, numPresenceResources> presenceNotificationUris { {
std::string("/a/fan"),
std::string("/a/led") } };
for(int i=0; i<numPresenceResources; i++)
{
if(res == OC_STACK_OK)
{
sleep(1);
res = OCCreateResource(&presenceNotificationHandles[i],
presenceNotificationResources.at(i).c_str(),
OC_RSRVD_INTERFACE_DEFAULT,
presenceNotificationUris.at(i).c_str(),
OCNOPEntityHandlerCb,
NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
}
if(res != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to create resource "
"%s with result %s.", presenceNotificationResources.at(i).c_str(),
getResult(res));
break;
}
OIC_LOG_V(INFO, TAG, PCF("Created %s for presence notification"),
presenceNotificationUris[i].c_str());
}
sleep(5);
for(int i=0; i<numPresenceResources; i++)
{
if(res == OC_STACK_OK)
{
res = OCDeleteResource(presenceNotificationHandles[i]);
}
if(res != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to delete "\
"resource %s.", presenceNotificationResources.at(i).c_str());
break;
}
OIC_LOG_V(INFO, TAG, PCF("Deleted %s for presence notification"),
presenceNotificationUris[i].c_str());
}
OIC_LOG(INFO, TAG, "================ stopping presence");
OCStopPresence();
return NULL;
}