// Pointer to function that handles the entity bound to the resource.
// This handler has to be explicitly defined by the programmer
OCEntityHandler entityHandler;
+ // callback parameter
+ void * entityHandlerCallbackParam;
// Properties on the resource – defines meta information on the resource
OCResourceProperty resourceProperties ; /* ACTIVE, DISCOVERABLE etc */
- // Pointer to an opaque object where app/user specific data can be placed with the resource;
- // this could be information for the entity handler between invocations
- void *context;
// NOTE: Methods supported by this resource should be based on the interface targeted
// i.e. look into the interface structure based on the query request Can be removed here;
// place holder for the note above
* no entity handler.
*/
OCEntityHandlerResult defaultResourceEHandler(OCEntityHandlerFlag flag,
- OCEntityHandlerRequest * request);
+ OCEntityHandlerRequest * request, void* callbackParam);
/**
* Get string value associated with a virtual resource type.
// Global variables
//-----------------------------------------------------------------------------
extern OCDeviceEntityHandler defaultDeviceHandler;
+extern void* defaultDeviceHandlerCallbackParameter;
//-----------------------------------------------------------------------------
// Defines
* @param entityHandler Entity handler function that is called by ocstack to handle requests for
* any undefined resources or default actions.
* If NULL is passed it removes the device default entity handler.
+ * @param callbackParameter paramter passed back when entityHandler is called.
*
* @return ::OC_STACK_OK on success, some other value upon failure.
*/
-OCStackResult OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandler entityHandler);
+OCStackResult OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandler entityHandler, void* callbackParameter);
/**
* Set device information.
* @param uri URI of the resource. Example: "/a/led".
* @param entityHandler Entity handler function that is called by ocstack to handle requests, etc.
* NULL for default entity handler.
+ * @param callbackParameter paramter passed back when entityHandler is called.
* @param resourceProperties Properties supported by resource.
* Example: ::OC_DISCOVERABLE|::OC_OBSERVABLE.
*
const char *resourceInterfaceName,
const char *uri,
OCEntityHandler entityHandler,
+ void* callbackParam,
uint8_t resourceProperties);
*
* @param handle Handle to the resource that the contained resource is to be bound.
* @param entityHandler Entity handler function that is called by ocstack to handle requests, etc.
+ * @param callbackParameter context paremeter that will be passed to entityHandler
* @return ::OC_STACK_OK on success, some other value upon failure.
*/
-OCStackResult OCBindResourceHandler(OCResourceHandle handle, OCEntityHandler entityHandler);
+OCStackResult OCBindResourceHandler(OCResourceHandle handle, OCEntityHandler entityHandler,
+ void *callbackParameter);
/**
* Get the number of resources that have been created in the stack.
* Entity handler callback needs to fill the resPayload of the entityHandlerRequest.
*/
typedef OCEntityHandlerResult (*OCEntityHandler)
-(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest);
+(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest, void* callbackParam);
/**
* Device Entity handler need to use this call back instead of OCEntityHandler.
*/
typedef OCEntityHandlerResult (*OCDeviceEntityHandler)
-(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest, char* uri);
+(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest, char* uri, void* callbackParam);
#ifdef __cplusplus
}
// This is the entity handler for the registered resource.
// This is invoked by OCStack whenever it recevies a request for this resource.
-OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest )
+OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
+ void *callbackParam)
{
OCEntityHandlerResult ehRet = OC_EH_OK;
OCEntityHandlerResponse response = {0};
OC_RSRVD_INTERFACE_DEFAULT,
"/a/light",
OCEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
OC_LOG_V(INFO, TAG, "Created Light resource with result: %s", getResult(res));
}
OCEntityHandlerResult
OCDeviceEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest, char* uri)
+ OCEntityHandlerRequest *entityHandlerRequest, char* uri, void* callbackParam)
{
OC_LOG_V (INFO, TAG, "Inside device default entity handler - flags: 0x%x, uri: %s", flag, uri);
OCEntityHandlerResult
OCNOPEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest)
+ OCEntityHandlerRequest *entityHandlerRequest, void* callbackParam)
{
// This is callback is associated with the 2 presence notification
// resources. They are non-operational.
OCEntityHandlerResult
OCEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest)
+ OCEntityHandlerRequest *entityHandlerRequest, void* callback)
{
OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
OC_RSRVD_INTERFACE_DEFAULT,
presenceNotificationUris.at(i).c_str(),
OCNOPEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
}
if(res != OC_STACK_OK)
"oc.mi.def",
uri,
OCEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
OC_LOG_V(INFO, TAG, "Created Light resource with result: %s", getResult(res));
}
#endif
- OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb);
+ OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb, NULL);
OCStackResult registrationResult =
SetPlatformInfo(platformID, manufacturerName, manufacturerUrl, modelNumber,
OCEntityHandlerResult
OCEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest)
+ OCEntityHandlerRequest *entityHandlerRequest,void* callbackParam)
{
OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
OC_RSRVD_INTERFACE_DEFAULT,
uri,
OCEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
OC_LOG_V(INFO, TAG, "Created LED resource with result: %s", getResult(res));
}
OCEntityHandlerResult OCEntityHandlerRoomCb(OCEntityHandlerFlag flag,
- OCEntityHandlerRequest * ehRequest)
+ OCEntityHandlerRequest * ehRequest,
+ void* callback)
{
OCEntityHandlerResult ret = OC_EH_OK;
OCEntityHandlerResponse response;
}
OCEntityHandlerResult OCEntityHandlerLightCb(OCEntityHandlerFlag flag,
- OCEntityHandlerRequest * ehRequest)
+ OCEntityHandlerRequest * ehRequest,void* callbackParam)
{
OCEntityHandlerResult ret = OC_EH_OK;
OCEntityHandlerResponse response;
}
OCEntityHandlerResult OCEntityHandlerFanCb(OCEntityHandlerFlag flag,
- OCEntityHandlerRequest * ehRequest)
+ OCEntityHandlerRequest * ehRequest, void* callback)
{
OCEntityHandlerResult ret = OC_EH_OK;
OCEntityHandlerResponse response;
OC_RSRVD_INTERFACE_DEFAULT,
"/a/fan",
OCEntityHandlerFanCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
OC_LOG_V(INFO, TAG, "Created fan resource with result: %s", getResult(res));
OC_RSRVD_INTERFACE_DEFAULT,
"/a/light",
OCEntityHandlerLightCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
OC_LOG_V(INFO, TAG, "Created light resource with result: %s", getResult(res));
OC_RSRVD_INTERFACE_BATCH,
"/a/room",
OCEntityHandlerRoomCb,
+ NULL,
OC_DISCOVERABLE);
}
else
OC_RSRVD_INTERFACE_BATCH,
"/a/room",
NULL,
+ NULL,
OC_DISCOVERABLE);
}
OCEntityHandlerResult
OCEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest)
+ OCEntityHandlerRequest *entityHandlerRequest, void* callbackParam)
{
OCEntityHandlerResult result = OC_EH_ERROR;
OCEntityHandlerRequest *request = NULL;
OC_RSRVD_INTERFACE_DEFAULT,
uri,
OCEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
OC_LOG_V(INFO, TAG, "Created LED resource with result: %s", getResult(res));
OCEntityHandlerResult
OCEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest)
+ OCEntityHandlerRequest *entityHandlerRequest,
+ void* callbackParam)
{
OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
OC_RSRVD_INTERFACE_DEFAULT,
uri,
OCEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE | OC_SECURE);
OC_LOG_V(INFO, TAG, "Created LED resource with result: %s", getResult(res));
// is ehRequest->resource
ehRequest->resource = (OCResourceHandle) temp;
- ehResult = temp->entityHandler(OC_REQUEST_FLAG, ehRequest);
+ ehResult = temp->entityHandler(OC_REQUEST_FLAG, ehRequest,
+ temp->entityHandlerCallbackParam);
// The default collection handler is returning as OK
if(stackRet != OC_STACK_SLOW_RESOURCE)
OC_OBSERVE_NO_OPTION, 0);
if(result == OC_STACK_OK)
{
- ehResult = resPtr->entityHandler(OC_REQUEST_FLAG, &ehRequest);
+ ehResult = resPtr->entityHandler(OC_REQUEST_FLAG, &ehRequest,
+ resPtr->entityHandlerCallbackParam);
if(ehResult == OC_EH_ERROR)
{
FindAndDeleteServerRequest(request);
// Default resource entity handler function
//-----------------------------------------------------------------------------
OCEntityHandlerResult defaultResourceEHandler(OCEntityHandlerFlag flag,
- OCEntityHandlerRequest * request)
+ OCEntityHandlerRequest * request, void* callbackParam)
{
//TODO ("Implement me!!!!");
// TODO: remove silence unused param warnings
(void) flag;
(void) request;
+ (void) callbackParam;
return OC_EH_OK; // Making sure that the Default EH and the Vendor EH have matching signatures
}
// At this point we know for sure that defaultDeviceHandler exists
ehResult = defaultDeviceHandler(OC_REQUEST_FLAG, &ehRequest,
- (char*) request->resourceUrl);
+ (char*) request->resourceUrl, defaultDeviceHandlerCallbackParameter);
if(ehResult == OC_EH_SLOW)
{
OC_LOG(INFO, TAG, PCF("This is a slow resource"));
goto exit;
}
- ehResult = resource->entityHandler(ehFlag, &ehRequest);
+ ehResult = resource->entityHandler(ehFlag, &ehRequest, resource->entityHandlerCallbackParam);
if(ehResult == OC_EH_SLOW)
{
OC_LOG(INFO, TAG, PCF("This is a slow resource"));
static OCMode myStackMode;
OCDeviceEntityHandler defaultDeviceHandler;
-
+void* defaultDeviceHandlerCallbackParameter = NULL;
//-----------------------------------------------------------------------------
// Macros
{
return result;
}
- observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest);
+ observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest,
+ observer->resource->entityHandlerCallbackParam);
}
//observer is not observing anymore
result = DeleteObserverUsingToken (token, tokenLength);
{
return OC_STACK_ERROR;
}
- observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest);
+ observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest,
+ observer->resource->entityHandlerCallbackParam);
//observer is unreachable
result = DeleteObserverUsingToken (token, tokenLength);
if(result == OC_STACK_OK)
myStackMode = mode;
defaultDeviceHandler = NULL;
+ defaultDeviceHandlerCallbackParameter = NULL;
OCSeedRandom();
result = CAResultToOCResult(CAInitialize());
}
#endif
-OCStackResult OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandler entityHandler)
+OCStackResult OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandler entityHandler,
+ void* callbackParameter)
{
defaultDeviceHandler = entityHandler;
+ defaultDeviceHandlerCallbackParameter = callbackParameter;
return OC_STACK_OK;
}
const char *resourceTypeName,
const char *resourceInterfaceName,
const char *uri, OCEntityHandler entityHandler,
+ void* callbackParam,
uint8_t resourceProperties)
{
if (entityHandler)
{
pointer->entityHandler = entityHandler;
+ pointer->entityHandlerCallbackParam = callbackParam;
}
else
{
pointer->entityHandler = defaultResourceEHandler;
+ pointer->entityHandlerCallbackParam = NULL;
}
*handle = pointer;
}
OCStackResult OCBindResourceHandler(OCResourceHandle handle,
- OCEntityHandler entityHandler)
+ OCEntityHandler entityHandler,
+ void* callbackParam)
{
OCResource *resource = NULL;
// Bind the handler
resource->entityHandler = entityHandler;
+ resource->entityHandlerCallbackParam = callbackParam;
#ifdef WITH_PRESENCE
if(presenceResource.handle)
"core.r",
OC_PRESENCE_URI,
NULL,
+ NULL,
OC_OBSERVABLE);
//make resource inactive
result = OCChangeResourceProperty(
//-----------------------------------------------------------------------------
// Entity handler
//-----------------------------------------------------------------------------
-OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest)
+OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
+ void* callbackParam)
{
OC_LOG(INFO, TAG, "Entering entityHandler");
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
// Property bitmask out of range
"core.rw",
"/a/led",
0,
+ NULL,
128));// invalid bitmask for OCResourceProperty
EXPECT_EQ(OC_STACK_OK, OCStop());
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
const char *url = OCGetResourceUri(handle);
EXPECT_STREQ("/a/led", url);
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
const char *url = OCGetResourceUri(handle);
EXPECT_STREQ("/a/led", url);
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCStop());
"core.rw",
"/a/led1",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
OCResourceHandle handle2;
"core.rw",
"/a/led2",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
OCResourceHandle handle3;
EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
"core.rw",
"/a/led3",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
const char *url = OCGetResourceUri(handle1);
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCStop());
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCStop());
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceTypes;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceTypes;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceInterfaces;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
OC_RSRVD_INTERFACE_DEFAULT));
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceInterfaces;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
"core.rw",
"/a1/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
const char *url = OCGetResourceUri(handle);
EXPECT_STREQ("/a1/led", url);
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
const char *url = OCGetResourceUri(handle);
EXPECT_STREQ("/a/led", url);
"core.rw",
"/a/led1",
0,
+ NULL,
OC_DISCOVERABLE));
const char *url = OCGetResourceUri(handle1);
EXPECT_STREQ("/a/led1", url);
"core.rw",
"/a/led2",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
url = OCGetResourceUri(handle2);
EXPECT_STREQ("/a/led2", url);
"core.rw",
"/a/led3",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
url = OCGetResourceUri(handle3);
EXPECT_STREQ("/a/led3", url);
"core.rw",
"/a/led4",
0,
+ NULL,
OC_DISCOVERABLE));
url = OCGetResourceUri(handle4);
EXPECT_STREQ("/a/led4", url);
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceTypes;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceTypes;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceTypes;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceInterfaces;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceInterfaces;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceInterfaces;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
uint8_t numResourceInterfaces;
"core.rw",
"/a/kitchen",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
OCResourceHandle handle0;
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
"core.rw",
"/a/kitchen",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led0",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led1",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led2",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led3",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led4",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led5",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
- EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
EXPECT_EQ(OC_STACK_OK, OCStop());
}
"core.rw",
"/a/led",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
OCEntityHandler myHandler = entityHandler;
- EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
+ EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
"core.rw",
"/a/kitchen",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led0",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led1",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led2",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led3",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led4",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led5",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led0",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led0",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led1",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led0",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led1",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led2",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led0",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led1",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
"core.rw",
"/a/led2",
0,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE));
EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
EXPECT_EQ(++numExpectedResources, numResources);
OCEntityHandlerResult DefaultEntityHandlerWrapper(OCEntityHandlerFlag flag,
OCEntityHandlerRequest * entityHandlerRequest,
- char* uri)
+ char* uri,
+ void * callbackParam)
{
OCEntityHandlerResult result = OC_EH_ERROR;
OCEntityHandlerResult EntityHandlerWrapper(OCEntityHandlerFlag flag,
- OCEntityHandlerRequest * entityHandlerRequest)
+ OCEntityHandlerRequest * entityHandlerRequest,
+ void* callbackParam)
{
OCEntityHandlerResult result = OC_EH_ERROR;
resourceInterface.c_str(), //const char * resourceInterfaceName //TODO fix this
resourceURI.c_str(), // const char * uri
EntityHandlerWrapper, // OCEntityHandler entityHandler
+ NULL,
resourceProperties // uint8_t resourceProperties
);
}
resourceInterface.c_str(), //const char * resourceInterfaceName //TODO fix this
resourceURI.c_str(), // const char * uri
NULL, // OCEntityHandler entityHandler
+ NULL,
resourceProperties // uint8_t resourceProperties
);
}
if(entityHandler)
{
- result = OCSetDefaultDeviceEntityHandler(DefaultEntityHandlerWrapper);
+ result = OCSetDefaultDeviceEntityHandler(DefaultEntityHandlerWrapper, NULL);
}
else
{
// If Null passed we unset
- result = OCSetDefaultDeviceEntityHandler(NULL);
+ result = OCSetDefaultDeviceEntityHandler(NULL, NULL);
}
return result;
uint8_t resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE;
EXPECT_EQ(OC_STACK_OK, OCCreateResource(&resHandle, resourceURI.c_str(),
- resourceTypeName.c_str(), resourceInterface.c_str(), nullptr,
+ resourceTypeName.c_str(), resourceInterface.c_str(), nullptr, nullptr,
resourceProperty));
EXPECT_EQ(NULL, response.getResourceHandle());
EXPECT_NO_THROW(response.setResourceHandle(resHandle));
* OC_EH_ERROR
*/
OCEntityHandlerResult resourceEntityHandlerCB (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest);
+ OCEntityHandlerRequest *entityHandlerRequest,
+ void *callbackParam);
/**
*
OC_LOG_V(DEBUG, HOSTING_TAG, "requiredUri+coordinatingFlag = %s", coordinatingURI);
ret = OCCreateResource(handle, resourceTypeName, resourceInterfaceName,
- coordinatingURI, entityHandler, resourceProperties);
+ coordinatingURI, entityHandler, NULL, resourceProperties);
free(coordinatingURI);
return ret;
}
mirrorResource->prop.resourceInterfaceName[0],
mirrorResource->uri,
resourceEntityHandlerCB,
+ NULL,
OC_DISCOVERABLE | OC_OBSERVABLE);
OC_LOG_V(DEBUG, HOSTING_TAG, "created mirror resource Handle : %u",mirrorResource->resourceHandle[OIC_MIRROR_HANDLE]);
OCEntityHandlerResult
resourceEntityHandlerCB (OCEntityHandlerFlag entifyHandlerFlag,
- OCEntityHandlerRequest *entityHandlerRequest)
+ OCEntityHandlerRequest *entityHandlerRequest,
+ void* callbackParam)
{
OC_LOG_V(DEBUG, HOSTING_TAG, "Inside device default entity handler - flags: 0x%x",
entifyHandlerFlag);