1 //******************************************************************
3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
25 #include "ocstackconfig.h"
31 //-----------------------------------------------------------------------------
33 //-----------------------------------------------------------------------------
35 //TODO: May want to refactor this in upcoming sprints.
36 //Don't want to expose to application layer that lower level stack is using CoAP.
38 #define OC_WELL_KNOWN_QUERY "224.0.1.187:5683/oc/core"
39 #define OC_EXPLICIT_DEVICE_DISCOVERY_URI "224.0.1.187:5683/oc/core/d?rt=core.led"
40 #define OC_MULTICAST_PREFIX "224.0.1.187:5683"
41 #define OC_MULTICAST_IP "224.0.1.187"
43 #define USE_RANDOM_PORT (0)
45 #define OC_DEFAULT_PRESENCE_TTL (60)
46 #define OC_PRESENCE_URI "/oc/presence"
47 extern uint8_t PresenceTimeOutSize; // length of PresenceTimeOut - 1
48 extern uint32_t PresenceTimeOut[];
50 //-----------------------------------------------------------------------------
52 //-----------------------------------------------------------------------------
55 * OC Virtual resources supported by every OC device
58 OC_WELL_KNOWN_URI= 0, // "/oc/core"
59 OC_DEVICE_URI, // "/oc/core/d"
60 OC_RESOURCE_TYPES_URI, // "/oc/core/d/type"
62 OC_PRESENCE, // "/oc/presence"
64 OC_MAX_VIRTUAL_RESOURCES // Max items in the list
68 * Standard RESTful HTTP Methods
72 OC_REST_GET = (1 << 0), // Read
73 OC_REST_PUT = (1 << 1), // Write
74 OC_REST_POST = (1 << 2), // Update
75 OC_REST_DELETE = (1 << 3), // Delete
76 // Register observe request for most up date notifications ONLY.
77 OC_REST_OBSERVE = (1 << 4),
78 // Register observe request for all notifications, including stale notifications.
79 OC_REST_OBSERVE_ALL = (1 << 5),
80 // Deregister observation, intended for internal use
81 OC_REST_CANCEL_OBSERVE = (1 << 6),
83 // Subscribe for all presence notifications of a particular resource.
84 OC_REST_PRESENCE = (1 << 7)
89 * Host Mode of Operation
97 extern OCMode myStackMode;
105 OC_NA_QOS // No Quality is defined, let the stack decide
106 } OCQualityOfService;
109 * Resource Properties
111 * OC_ACTIVE - When this bit is set, the resource is initialized, otherwise the resource
112 * is 'inactive'. 'inactive' signifies that the resource has been marked for
113 * deletion or is already deleted.
114 * OC_DISCOVERABLE - When this bit is set, the resource is allowed to be discovered by clients.
115 * OC_OBSERVABLE - When this bit is set, the resource is allowed to be observed by clients.
116 * OC_SLOW - When this bit is set, the resource has been marked as 'slow'. 'slow' signifies
117 * that responses from this resource can expect delays in processing its
118 * requests from clients.
119 * OC_SECURE - When this bit is set, the resource is a secure resource.
122 OC_ACTIVE = (1 << 0),
123 OC_DISCOVERABLE = (1 << 1),
124 OC_OBSERVABLE = (1 << 2),
127 } OCResourceProperty;
130 * Transport Protocol IDs
133 OC_INVALID_ID = (1 << 0),
134 OC_COAP_ID = (1 << 1)
135 } OCTransportProtocolID;
145 OC_ALL //Multicast message: send over all the interfaces.
146 } OCConnectivityType;
149 * Declares Stack Results & Errors
152 /* Success status code - START HERE */
154 OC_STACK_RESOURCE_CREATED,
155 OC_STACK_RESOURCE_DELETED,
157 /* Success status code - END HERE */
158 /* Error status code - START HERE */
159 OC_STACK_INVALID_URI = 20,
160 OC_STACK_INVALID_QUERY,
162 OC_STACK_INVALID_PORT,
163 OC_STACK_INVALID_CALLBACK,
164 OC_STACK_INVALID_METHOD,
165 OC_STACK_INVALID_PARAM,
166 OC_STACK_INVALID_OBSERVE_PARAM,
170 OC_STACK_NO_RESOURCE, /* resource not found */
171 OC_STACK_RESOURCE_ERROR, /* ex: not supported method or interface */
172 OC_STACK_SLOW_RESOURCE,
173 OC_STACK_NO_OBSERVERS, /* resource has no registered observers */
174 OC_STACK_OBSERVER_NOT_FOUND,
175 OC_STACK_VIRTUAL_DO_NOT_HANDLE,
176 OC_STACK_INVALID_OPTION,
177 OC_STACK_MALFORMED_RESPONSE, /* the remote reply contained malformed data */
178 OC_STACK_PERSISTENT_BUFFER_REQUIRED,
179 OC_STACK_INVALID_REQUEST_HANDLE,
180 OC_STACK_INVALID_DEVICE_INFO,
181 OC_STACK_INVALID_JSON,
182 /* NOTE: Insert all new error codes here!*/
184 OC_STACK_PRESENCE_STOPPED = 128,
185 OC_STACK_PRESENCE_TIMEOUT,
186 OC_STACK_PRESENCE_DO_NOT_HANDLE,
189 /* Error status code - END HERE */
193 * Handle to an @ref OCDoResource invocation.
195 typedef void * OCDoHandle;
198 * Handle to an OCResource object owned by the OCStack.
200 typedef void * OCResourceHandle;
202 typedef void * OCRequestHandle;
203 typedef void * OCResponseHandle;
206 * Unique identifier for each observation request. Used when observations are
207 * registered or deregistering. Used by entity handler to signal specific
208 * observers to be notified of resource changes.
209 * There can be maximum of 256 observations per server.
211 typedef uint8_t OCObservationId;
214 * Action associated with observation
217 OC_OBSERVE_REGISTER = 0,
218 OC_OBSERVE_DEREGISTER = 1,
219 OC_OBSERVE_NO_OPTION = 2
223 // Action associated with observation request
224 OCObserveAction action;
225 // Identifier for observation being registered/deregistered
226 OCObservationId obsId;
230 * Possible returned values from entity handler
235 OC_EH_RESOURCE_CREATED,
236 OC_EH_RESOURCE_DELETED,
239 } OCEntityHandlerResult;
241 // following structure will be used to define the vendor specific header options to be included
242 // in communication packets
244 typedef struct OCHeaderOption {
245 // The protocol ID this option applies to
246 OCTransportProtocolID protocolID;
247 // The header option ID which will be added to communication packets
250 uint16_t optionLength;
251 // pointer to its data
252 uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH];
256 * Incoming requests handled by the server. Requests are passed in as a parameter to the @ref OCEntityHandler callback API.
257 * @brief The @ref OCEntityHandler callback API must be implemented in the application in order to receive these requests.
260 // Associated resource
261 OCResourceHandle resource;
262 OCRequestHandle requestHandle;
263 // the REST method retrieved from received request PDU
265 // resource query send by client
266 unsigned char * query;
267 // Information associated with observation - valid only when OCEntityHandler
268 // flag includes OC_OBSERVE_FLAG
269 OCObservationInfo obsInfo;
270 // An array of the received vendor specific header options
271 uint8_t numRcvdVendorSpecificHeaderOptions;
272 OCHeaderOption * rcvdVendorSpecificHeaderOptions;
273 // reqJSON is retrieved from the payload of the received request PDU
274 unsigned char * reqJSONPayload;
275 }OCEntityHandlerRequest;
278 * Response from queries to remote servers. Queries are made by calling the @ref OCDoResource API.
281 // Address of remote server
283 // Indicates adaptor type on which the response was received
284 OCConnectivityType connType;
285 // the is the result of our stack, OCStackResult should contain coap/other error codes;
286 OCStackResult result;
287 // If associated with observe, this will represent the sequence of notifications from server.
288 uint32_t sequenceNumber;
289 // resJSONPayload is retrieved from the payload of the received request PDU
290 unsigned const char * resJSONPayload;
291 // An array of the received vendor specific header options
292 uint8_t numRcvdVendorSpecificHeaderOptions;
293 OCHeaderOption rcvdVendorSpecificHeaderOptions[MAX_HEADER_OPTIONS];
297 * Following structure describes the device properties. All non-Null properties will be included
298 * in a device discovery request.
307 char *manufacturerName;
308 char *manufacturerUrl;
310 char *dateOfManufacture;
311 char *platformVersion;
312 char *firmwareVersion;
318 // Request handle is passed to server via the entity handler for each incoming request.
319 // Stack assigns when request is received, server sets to indicate what request response is for
320 OCRequestHandle requestHandle;
321 // New handle for tracking block (or slow) response. Stack assigns, server uses for subsequent calls
322 OCResponseHandle *responseHandle;
324 OCResourceHandle resourceHandle;
325 // Allow the entity handler to pass a result with the response
326 OCEntityHandlerResult ehResult;
327 // this is the pointer to server payload data to be transferred
328 unsigned char *payload;
329 // size of server payload data. I don't think we should rely on null terminated data for size
330 uint16_t payloadSize;
331 // An array of the vendor specific header options the entity handler wishes to use in response
332 uint8_t numSendVendorSpecificHeaderOptions;
333 OCHeaderOption sendVendorSpecificHeaderOptions[MAX_HEADER_OPTIONS];
334 // URI of new resource that entity handler might create
335 unsigned char resourceUri[MAX_URI_LENGTH];
336 // Server sets to true for persistent response buffer, false for non-persistent response buffer
337 uint8_t persistentBufferFlag;
338 } OCEntityHandlerResponse;
341 OC_INIT_FLAG = (1 << 0),
342 OC_REQUEST_FLAG = (1 << 1),
343 OC_OBSERVE_FLAG = (1 << 2)
344 } OCEntityHandlerFlag; //entity_handler_flag_t ;
346 // possible returned values from client application
348 OC_STACK_DELETE_TRANSACTION = 0,
349 OC_STACK_KEEP_TRANSACTION
350 } OCStackApplicationResult;
352 //-----------------------------------------------------------------------------
353 // Callback function definitions
354 //-----------------------------------------------------------------------------
357 * Client applications implement this callback to consume responses received from Servers.
359 typedef OCStackApplicationResult (* OCClientResponseHandler)(void *context, OCDoHandle handle,
360 OCClientResponse * clientResponse);
363 * Client applications using a context pointer implement this callback to delete the
364 * context upon removal of the callback/context pointer from the internal callback-list
366 typedef void (* OCClientContextDeleter)(void *context);
369 * This info is passed from application to OC Stack when initiating a request to Server
373 OCClientResponseHandler cb;
374 OCClientContextDeleter cd;
378 * Application server implementations must implement this callback to consume requests OTA.
379 * Entity handler callback needs to fill the resPayload of the entityHandlerRequest.
381 typedef OCEntityHandlerResult (*OCEntityHandler)
382 (OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest);
385 * Device Entity handler need to use this call back instead of OCEntityHandler
387 typedef OCEntityHandlerResult (*OCDeviceEntityHandler)
388 (OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest, char* uri);
390 //-----------------------------------------------------------------------------
391 // Function prototypes
392 //-----------------------------------------------------------------------------
395 * Initialize the OC Stack. Must be called prior to starting the stack.
398 * IP Address of host device
400 * Port of host device
402 * Host device is client, server, or client-server
405 * OC_STACK_OK - no errors
406 * OC_STACK_ERROR - stack init error
408 OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode);
411 * Stop the OC stack. Use for a controlled shutdown.
413 * Note: OCStop() performs operations similar to OCStopPresence(), as well as OCDeleteResource() on
414 * all resources this server is hosting. OCDeleteResource() performs operations similar to
415 * OCNotifyAllObservers() to notify all client observers that the respective resource is being
419 * OC_STACK_OK - no errors
420 * OC_STACK_ERROR - stack not initialized
422 OCStackResult OCStop();
425 * Called in main loop of OC client or server. Allows low-level processing of
429 * OC_STACK_OK - no errors
430 * OC_STACK_ERROR - stack process error
432 OCStackResult OCProcess();
435 * Discover or Perform requests on a specified resource (specified by that Resource's respective
438 * @param handle - @ref OCDoHandle to refer to the request sent out on behalf of
440 * @param method - @ref OCMethod to perform on the resource
441 * @param requiredUri - URI of the resource to interact with
442 * @param referenceUri - URI of the reference resource
443 * @param request - JSON encoded request
444 * @param qos - quality of service. Note that if this API is called on a uri with
445 * the well-known multicast IP address, the qos will be forced to
447 * since it is impractical to send other QOS levels on such addresses.
448 * @param clientApplicationCB- asynchronous callback function that is invoked
449 * by the stack when discovery or resource interaction is complete
450 * @param options - The address of an array containing the vendor specific
451 * header options to be sent with the request
452 * @param numOptions - Number of header options to be included
454 * Note: Presence subscription amendments (ie. adding additional resource type filters by calling
455 * this API again) require the use of the same base URI as the original request to successfully
456 * amend the presence filters.
459 * OC_STACK_OK - no errors
460 * OC_STACK_INVALID_CALLBACK - invalid callback function pointer
461 * OC_STACK_INVALID_METHOD - invalid resource method
462 * OC_STACK_INVALID_URI - invalid required or reference URI
463 * OC_STACK_INVALID_QUERY - number of resource types specified for filtering presence
464 * notifications exceeds @ref MAX_PRESENCE_FILTERS.
466 OCStackResult OCDoResource(OCDoHandle *handle, OCMethod method, const char *requiredUri,
467 const char *referenceUri, const char *request, OCConnectivityType conType,
468 OCQualityOfService qos, OCCallbackData *cbData,
469 OCHeaderOption * options, uint8_t numOptions);
472 * Cancel a request associated with a specific @ref OCDoResource invocation.
474 * @param handle - Used to identify a specific OCDoResource invocation.
475 * @param qos - used to specify Quality of Service (read below for more info)
476 * @param options- used to specify vendor specific header options when sending
477 * explicit observe cancellation
478 * @param numOptions- Number of header options to be included
481 * OC_STACK_OK - No errors; Success
482 * OC_STACK_INVALID_PARAM - The handle provided is invalid.
484 OCStackResult OCCancel(OCDoHandle handle, OCQualityOfService qos, OCHeaderOption * options,
489 * When operating in @ref OCServer or @ref OCClientServer mode, this API will start sending out
490 * presence notifications to clients via multicast. Once this API has been called with a success,
491 * clients may query for this server's presence and this server's stack will respond via multicast.
493 * Server can call this function when it comes online for the first time, or when it comes back
494 * online from offline mode, or when it re enters network.
496 * @param ttl - Time To Live in seconds
497 * Note: If ttl is '0', then the default stack value will be used (60 Seconds).
500 * OC_STACK_OK - No errors; Success
502 OCStackResult OCStartPresence(const uint32_t ttl);
505 * When operating in @ref OCServer or @ref OCClientServer mode, this API will stop sending out
506 * presence notifications to clients via multicast. Once this API has been called with a success,
507 * this server's stack will not respond to clients querying for this server's presence.
509 * Server can call this function when it is terminating, going offline, or when going
513 * OC_STACK_OK - No errors; Success
516 OCStackResult OCStopPresence();
521 * Set default device entity handler
523 * @param entityHandler - entity handler function that is called by ocstack to handle requests for
524 * any undefined resources or default actions.
525 * if NULL is passed it removes the device default entity handler.
528 * OC_STACK_OK - no errors
529 * OC_STACK_ERROR - stack process error
531 OCStackResult OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandler entityHandler);
534 * Set device information.
536 * @param deviceInfo - Structure passed by the server application containing
537 * the device information.
541 * OC_STACK_OK - no errors
542 * OC_STACK_INVALID_PARAM - invalid paramerter
543 * OC_STACK_ERROR - stack process error
545 OCStackResult OCSetDeviceInfo(OCDeviceInfo deviceInfo);
550 * @param handle - pointer to handle to newly created resource. Set by ocstack. Used to refer to resource
551 * @param resourceTypeName - name of resource type. Example: "core.led"
552 * @param resourceInterfaceName - name of resource interface. Example: "core.rw"
553 * @param uri - URI of the resource. Example: "/a/led"
554 * @param entityHandler - entity handler function that is called by ocstack to handle requests, etc
555 * NULL for default entity handler
556 * @param resourceProperties - properties supported by resource. Example: OC_DISCOVERABLE|OC_OBSERVABLE
559 * OC_STACK_OK - no errors
560 * OC_STACK_ERROR - stack process error
562 OCStackResult OCCreateResource(OCResourceHandle *handle,
563 const char *resourceTypeName,
564 const char *resourceInterfaceName,
566 OCEntityHandler entityHandler,
567 uint8_t resourceProperties);
570 * Create a resource. with host ip address for remote resource
572 * @param handle - pointer to handle to newly created resource. Set by ocstack.
573 * Used to refer to resource
574 * @param resourceTypeName - name of resource type. Example: "core.led"
575 * @param resourceInterfaceName - name of resource interface. Example: "core.rw"
576 * @param host - HOST address of the remote resource. Example: "coap://xxx.xxx.xxx.xxx:xxxxx"
577 * @param uri - URI of the resource. Example: "/a/led"
578 * @param entityHandler - entity handler function that is called by ocstack to handle requests, etc
579 * NULL for default entity handler
580 * @param resourceProperties - properties supported by resource.
581 * Example: OC_DISCOVERABLE|OC_OBSERVABLE
584 * OC_STACK_OK - no errors
585 * OC_STACK_ERROR - stack process error
587 OCStackResult OCCreateResourceWithHost(OCResourceHandle *handle,
588 const char *resourceTypeName,
589 const char *resourceInterfaceName,
592 OCEntityHandler entityHandler,
593 uint8_t resourceProperties);
596 * Add a resource to a collection resource.
598 * @param collectionHandle - handle to the collection resource
599 * @param resourceHandle - handle to resource to be added to the collection resource
602 * OC_STACK_OK - no errors
603 * OC_STACK_ERROR - stack process error
604 * OC_STACK_INVALID_PARAM - invalid collectionhandle
606 OCStackResult OCBindResource(OCResourceHandle collectionHandle, OCResourceHandle resourceHandle);
609 * Remove a resource from a collection resource.
611 * @param collectionHandle - handle to the collection resource
612 * @param resourceHandle - handle to resource to be removed from the collection resource
615 * OC_STACK_OK - no errors
616 * OC_STACK_ERROR - stack process error
617 * OC_STACK_INVALID_PARAM - invalid collectionhandle
619 OCStackResult OCUnBindResource(OCResourceHandle collectionHandle, OCResourceHandle resourceHandle);
622 * Bind a resourcetype to a resource.
624 * @param handle - handle to the resource
625 * @param resourceTypeName - name of resource type. Example: "core.led"
628 * OC_STACK_OK - no errors
629 * OC_STACK_ERROR - stack process error
631 OCStackResult OCBindResourceTypeToResource(OCResourceHandle handle,
632 const char *resourceTypeName);
634 * Bind a resource interface to a resource.
636 * @param handle - handle to the resource
637 * @param resourceInterfaceName - name of resource interface. Example: "core.rw"
640 * OC_STACK_OK - no errors
641 * OC_STACK_ERROR - stack process error
643 OCStackResult OCBindResourceInterfaceToResource(OCResourceHandle handle,
644 const char *resourceInterfaceName);
647 * Bind an entity handler to the resource.
649 * @param handle - handle to the resource that the contained resource is to be bound
650 * @param entityHandler - entity handler function that is called by ocstack to handle requests, etc
652 * OC_STACK_OK - no errors
653 * OC_STACK_ERROR - stack process error
655 OCStackResult OCBindResourceHandler(OCResourceHandle handle, OCEntityHandler entityHandler);
658 * Get the number of resources that have been created in the stack.
660 * @param numResources - pointer to count variable
663 * OC_STACK_OK - no errors
664 * OC_STACK_ERROR - stack process error
667 OCStackResult OCGetNumberOfResources(uint8_t *numResources);
670 * Get a resource handle by index.
672 * @param index - index of resource, 0 to Count - 1
675 * Resource handle - if found
676 * NULL - if not found
678 OCResourceHandle OCGetResourceHandle(uint8_t index);
681 * Delete resource specified by handle. Deletes resource and all resourcetype and resourceinterface
684 * Note: OCDeleteResource() performs operations similar to OCNotifyAllObservers() to notify all
685 * client observers that "this" resource is being deleted.
687 * @param handle - handle of resource to be deleted
690 * OC_STACK_OK - no errors
691 * OC_STACK_ERROR - stack process error
693 OCStackResult OCDeleteResource(OCResourceHandle handle);
696 * Get the URI of the resource specified by handle.
698 * @param handle - handle of resource
700 * URI string - if resource found
701 * NULL - resource not found
703 const char *OCGetResourceUri(OCResourceHandle handle);
706 * Get the properties of the resource specified by handle.
707 * NOTE: that after a resource is created, the OC_ACTIVE property is set
708 * for the resource by the stack.
710 * @param handle - handle of resource
712 * property bitmap - if resource found
713 * NULL - resource not found
715 uint8_t OCGetResourceProperties(OCResourceHandle handle);
718 * Get the number of resource types of the resource.
720 * @param handle - handle of resource
721 * @param numResourceTypes - pointer to count variable
724 * OC_STACK_OK - no errors
725 * OC_STACK_ERROR - stack process error
727 OCStackResult OCGetNumberOfResourceTypes(OCResourceHandle handle, uint8_t *numResourceTypes);
730 * Get name of resource type of the resource.
732 * @param handle - handle of resource
733 * @param index - index of resource, 0 to Count - 1
736 * resource type name - if resource found
737 * NULL - resource not found
739 const char *OCGetResourceTypeName(OCResourceHandle handle, uint8_t index);
742 * Get the number of resource interfaces of the resource.
744 * @param handle - handle of resource
745 * @param numResources - pointer to count variable
748 * OC_STACK_OK - no errors
749 * OC_STACK_ERROR - stack process error
752 OCStackResult OCGetNumberOfResourceInterfaces(OCResourceHandle handle, uint8_t *numResourceInterfaces);
755 * Get name of resource interface of the resource.
757 * @param handle - handle of resource
758 * @param index - index of resource, 0 to Count - 1
761 * resource interface name - if resource found
762 * NULL - resource not found
764 const char *OCGetResourceInterfaceName(OCResourceHandle handle, uint8_t index);
767 * Get methods of resource interface of the resource.
769 * @param handle - handle of resource
770 * @param index - index of resource, 0 to Count - 1
773 * allowed methods - if resource found
774 * NULL - resource not found
776 uint8_t OCGetResourceInterfaceAllowedMethods(OCResourceHandle handle, uint8_t index);
779 * Get resource handle from the collection resource by index.
781 * @param collectionHandle - handle of collection resource
782 * @param index - index of contained resource, 0 to Count - 1
785 * handle to contained resource - if resource found
786 * NULL - resource not found
788 OCResourceHandle OCGetResourceHandleFromCollection(OCResourceHandle collectionHandle, uint8_t index);
791 * Get the entity handler for a resource.
793 * @param handle - handle of resource
796 * entity handler - if resource found
797 * NULL - resource not found
799 OCEntityHandler OCGetResourceHandler(OCResourceHandle handle);
802 * Notify all registered observers that the resource representation has
803 * changed. If observation includes a query the client is notified only
804 * if the query is valid after the resource representation has changed.
806 * @param handle - handle of resource
809 * OC_STACK_OK - no errors
810 * OC_STACK_NO_RESOURCE - invalid resource handle
811 * OC_STACK_NO_OBSERVERS - no more observers intrested in resource
813 OCStackResult OCNotifyAllObservers(OCResourceHandle handle, OCQualityOfService qos);
816 * Notify specific observers with updated value of representation.
817 * Before this API is invoked by entity handler it has finished processing
818 * queries for the associated observers.
820 * @param handle - handle of resource
821 * @param obsIdList - list of observation ids that need to be notified
822 * @param numberOfIds - number of observation ids included in obsIdList
823 * @param notificationJSONPayload - JSON encoded payload to send in notification
824 * @param qos - desired quality of service of the observation notifications
825 * NOTE: The memory for obsIdList and notificationJSONPayload is managed by the
826 * entity invoking the API. The maximum size of the notification is 1015 bytes
827 * for non-Arduino platforms. For Arduino the maximum size is 247 bytes.
830 * OC_STACK_OK - no errors
831 * OC_STACK_NO_RESOURCE - invalid resource handle
834 OCNotifyListOfObservers (OCResourceHandle handle,
835 OCObservationId *obsIdList,
837 unsigned char *notificationJSONPayload,
838 OCQualityOfService qos);
842 * Send a response to a request.
843 * The response can be a normal, slow, or block (i.e. a response that
844 * is too large to be sent in a single PDU and must span multiple transmissions)
846 * @param response - pointer to structure that contains response parameters
849 * OC_STACK_OK - no errors
851 OCStackResult OCDoResponse(OCEntityHandlerResponse *response);
854 * Cancel a response. Applies to a block response
856 * @param responseHandle - response handle set by stack in OCServerResponse after
857 * OCDoResponse is called
860 * OC_STACK_OK - No errors; Success
861 * OC_STACK_INVALID_PARAM - The handle provided is invalid.
863 OCStackResult OCCancelResponse(OCResponseHandle responseHandle);
868 #endif // __cplusplus
870 #endif /* OCSTACK_H_ */