resource-container: Install unit tests
[iotivity.git] / resource / include / OCPlatform_impl.h
1 //******************************************************************
2 //
3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
4 //
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
6 //
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
10 //
11 //      http://www.apache.org/licenses/LICENSE-2.0
12 //
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.
18 //
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
20
21 /**
22  * @file
23  *
24  * Implementation of the OCPlatform functionality. It contains a singleton
25  * interface that is used only by the OCPlatform namespace and is the
26  * central entrance to the stack.
27  */
28
29 #ifndef OC_PLATFORM_IMPL_H_
30 #define OC_PLATFORM_IMPL_H_
31
32 #include <map>
33
34 #include "OCApi.h"
35 #include "OCResource.h"
36 #include "WrapperFactory.h"
37 #include "OCResourceRequest.h"
38 #include "OCResourceResponse.h"
39 #include "OCRepresentation.h"
40
41 #ifdef WITH_CLOUD
42 #include "OCAccountManager.h"
43 #endif
44
45 #include "oc_logger.hpp"
46
47 namespace OC
48 {
49     class OCPlatform_impl
50     {
51     private:
52         static PlatformConfig& globalConfig();
53     public:
54         static void Configure(const PlatformConfig& config);
55
56         static OCPlatform_impl& Instance();
57
58     public:
59         // typedef for handle to cancel presence info with
60         typedef OCDoHandle OCPresenceHandle;
61
62         virtual ~OCPlatform_impl(void);
63
64         OCStackResult notifyAllObservers(OCResourceHandle resourceHandle);
65
66         OCStackResult notifyAllObservers(OCResourceHandle resourceHandle, QualityOfService QoS);
67
68         OCStackResult notifyListOfObservers(
69                     OCResourceHandle resourceHandle,
70                     ObservationIds& observationIds,
71                     const std::shared_ptr<OCResourceResponse> responsePtr);
72
73         OCStackResult notifyListOfObservers(
74                     OCResourceHandle resourceHandle,
75                     ObservationIds& observationIds,
76                     const std::shared_ptr<OCResourceResponse> responsePtr,
77                     QualityOfService QoS);
78
79         OCResourceHandle getResourceHandleAtUri(const std::string& uri);
80
81         OCStackResult findResource(const std::string& host, const std::string& resourceURI,
82                     OCConnectivityType connectivityType, FindCallback resourceHandler);
83
84         OCStackResult findResource(const std::string& host, const std::string& resourceURI,
85                     OCConnectivityType connectivityType, FindCallback resourceHandler,
86                     QualityOfService QoS);
87
88         OCStackResult findResource(const std::string& host, const std::string& resourceURI,
89                     OCConnectivityType connectivityType, FindCallback resourceHandler,
90                     FindErrorCallback errorHandler);
91
92         OCStackResult findResource(const std::string& host, const std::string& resourceURI,
93                     OCConnectivityType connectivityType, FindCallback resourceHandler,
94                     FindErrorCallback errorHandler, QualityOfService QoS);
95
96         OCStackResult findResourceList(const std::string& host, const std::string& resourceURI,
97                     OCConnectivityType connectivityType, FindResListCallback resourceHandler,
98                     QualityOfService QoS);
99
100         OCStackResult findResourceList(const std::string& host, const std::string& resourceURI,
101                     OCConnectivityType connectivityType, FindResListCallback resourceHandler,
102                     FindErrorCallback errorHandler, QualityOfService Qos);
103
104         OCStackResult getDeviceInfo(const std::string& host, const std::string& deviceURI,
105                     OCConnectivityType connectivityType, FindDeviceCallback deviceInfoHandler);
106
107         OCStackResult getDeviceInfo(const std::string& host, const std::string& deviceURI,
108                     OCConnectivityType connectivityType, FindDeviceCallback deviceInfoHandler,
109                     QualityOfService QoS);
110
111         OCStackResult getPlatformInfo(const std::string& host, const std::string& platformURI,
112                     OCConnectivityType connectivityType, FindPlatformCallback platformInfoHandler);
113
114         OCStackResult getPlatformInfo(const std::string& host, const std::string& platformURI,
115                     OCConnectivityType connectivityType, FindPlatformCallback platformInfoHandler,
116                     QualityOfService QoS);
117
118         /**
119          * API for Device Discovery
120          *
121          * @param host Host IP Address. If null or empty, Multicast is performed.
122          * @param deviceURI Uri containing address to the virtual device in C Stack
123          *                       ("/oic/d")
124          * @param deviceInfoHandler device discovery callback
125          * @param QualityOfService the quality of communication
126          * @return Returns ::OC_STACK_OK if success.
127          * @note OCStackResult is defined in ocstack.h.
128          */
129         OCStackResult getDeviceInfo(const std::string& host, const std::string& deviceURI,
130                     FindDeviceCallback deviceInfoHandler);
131         OCStackResult getDeviceInfo(const std::string& host, const std::string& deviceURI,
132                     FindDeviceCallback deviceInfoHandler, QualityOfService QoS);
133
134         /**
135          * API for Platform Discovery
136          *
137          * @param host Host IP Address. If null or empty, Multicast is performed.
138          * @param platformURI Uri containing address to the virtual platform in C Stack
139          *                       ("/oic/p")
140          * @param platformInfoHandler platform discovery callback
141          * @param QualityOfService the quality of communication
142          * @return Returns ::OC_STACK_OK if success.
143          * @note OCStackResult is defined in ocstack.h.
144          */
145         OCStackResult getPlatformInfo(const std::string& host, const std::string& platformURI,
146                     FindPlatformCallback platformInfoHandler);
147         OCStackResult getPlatformInfo(const std::string& host, const std::string& platformURI,
148                     FindPlatformCallback platformInfoHandler, QualityOfService QoS);
149
150         OCStackResult setPropertyValue(OCPayloadType type, const std::string& tag,
151             const std::string& value);
152         OCStackResult setPropertyValue(OCPayloadType type, const std::string& tag,
153             const std::vector<std::string>& value);
154         OCStackResult getPropertyValue(OCPayloadType type, const std::string& tag,
155             std::string& value);
156         OCStackResult getPropertyList(OCPayloadType type, const std::string& tag,
157             std::vector<std::string>& value);
158
159         /**
160          * This function returns flags of supported endpoint TPS on stack.
161          *
162          * @param[out] supportedTps Bit combinations of supported OCTpsSchemeFlags.
163          *
164          * @return Returns ::OC_STACK_OK if success.
165          */
166         OCStackResult getSupportedTransportsInfo(OCTpsSchemeFlags& supportedTps);
167
168         /**
169         * This API registers a resource with the server
170         * @note This API applies to server side only.
171         *
172         * @param resourceHandle Upon successful registration, resourceHandle will be filled
173         * @param resourceURI The URI of the resource. Example: "a/light". See NOTE below
174         * @param resourceTypeName The resource type. Example: "core.light"
175         * @param resourceInterface The resource interface (whether it is collection etc).
176         * @param entityHandler Entity handler callback.
177         * @param resourceProperty indicates the property of the resource. Defined in octypes.h.
178         * @param resourceTpsTypes Transport Protocol Suites(TPS) types of resource for
179                                   open resource to specific transport adapter (e.g., TCP, UDP)
180                                   with messaging protocol(e.g., COAP, COAPS).
181                                   Example: "OC_COAP | OC_COAP_TCP"
182         * setting resourceProperty as OC_DISCOVERABLE will allow Discovery of this resource
183         * setting resourceProperty as OC_OBSERVABLE will allow observation
184         * setting resourceProperty as OC_DISCOVERABLE | OC_OBSERVABLE will allow both discovery
185         * and observation
186         *
187         * @return Returns ::OC_STACK_OK if success.
188         * @note "a/light" is a relative reference to URI.
189         * Above relative reference to URI will be prepended (by core) with a host IP
190         * Therefore, fully qualified URI format would be
191         * "CoAP(s)+protocol-URI-Scheme://HostIP-Address/relativeURI"
192         * Example, a relative reference to URI: 'a/light' will result in a fully qualified URI:
193         *   "coap://192.168.1.1:5246/a/light", "coaps://192.168.1.1:5246/a/light"
194         * @note OCStackResult is defined in octypes.h.
195         * @note entity handler callback :
196         * When you set specific return value like OC_EH_CHANGED, OC_EH_CONTENT,
197         * OC_EH_SLOW and etc in entity handler callback,
198         * ocstack will be not send response automatically to client
199         * except for error return value like OC_EH_ERROR
200         * If you want to send response to client with specific result,
201         * OCDoResponse API should be called with the result value.
202         */
203         OCStackResult registerResource(OCResourceHandle& resourceHandle,
204                         std::string& resourceURI,
205                         const std::string& resourceTypeName,
206                         const std::string& resourceInterface,
207                         EntityHandler entityHandler,
208                         uint8_t resourceProperty,
209                         OCTpsSchemeFlags resourceTpsTypes);
210
211         /**
212         * This API registers a resource with the server
213         * @note This API applies to server side only.
214         *
215         * @param resourceHandle Upon successful registration, resourceHandle will be filled
216         * @param resourceURI The URI of the resource. Example: "a/light". See NOTE below
217         * @param resourceTypeName The resource type. Example: "core.light"
218         * @param resourceInterface The resource interface (whether it is collection etc).
219         * @param entityHandler entity handler callback.
220         * @param resourceProperty indicates the property of the resource. Defined in octypes.h.
221         * setting resourceProperty as OC_DISCOVERABLE will allow Discovery of this resource
222         * setting resourceProperty as OC_OBSERVABLE will allow observation
223         * setting resourceProperty as OC_DISCOVERABLE | OC_OBSERVABLE will allow both discovery 
224         * and observation
225         *
226         * @return Returns ::OC_STACK_OK if success.
227         * @note "a/light" is a relative reference to URI.
228         * Above relative reference to URI will be prepended (by core) with a host IP
229         * Therefore, fully qualified URI format would be
230         * "CoAP(s)+protocol-URI-Scheme://HostIP-Address/relativeURI"
231         * Example, a relative reference to URI: 'a/light' will result in a fully qualified URI:
232         *   "coap://192.168.1.1:5246/a/light", "coaps://192.168.1.1:5246/a/light"
233         * @note OCStackResult is defined in octypes.h.
234         * @note entity handler callback :
235         * When you set specific return value like OC_EH_CHANGED, OC_EH_CONTENT,
236         * OC_EH_SLOW and etc in entity handler callback,
237         * ocstack will be not send response automatically to client
238         * except for error return value like OC_EH_ERROR
239         * If you want to send response to client with specific result,
240         * OCDoResponse API should be called with the result value.
241         */
242         OCStackResult registerResource(OCResourceHandle& resourceHandle,
243                         std::string& resourceURI,
244                         const std::string& resourceTypeName,
245                         const std::string& resourceInterface,
246                         EntityHandler entityHandler,
247                         uint8_t resourceProperty);
248
249         OCStackResult registerResource(OCResourceHandle& resourceHandle,
250                         const std::shared_ptr<OCResource> resource);
251
252         /**
253          * This API registers all the device specific information
254          *
255          * @deprecated: Use setPropertyValue instead.
256          *
257          * @param deviceInfo Structure containing all the device related information
258          *
259          * @return Returns ::OC_STACK_OK if success
260          * @note OCDeviceInfo is defined in OCStack.h
261          */
262         OCStackResult registerDeviceInfo(const OCDeviceInfo deviceInfo);
263
264         /**
265          * This API registers all the platform specific information
266          *
267          * @param platformInfo Structure containing all the platform related information
268          *
269          * @return Returns ::OC_STACK_OK if success
270          * @note OCPlatformInfo is defined in OCStack.h
271          */
272         OCStackResult registerPlatformInfo(const OCPlatformInfo platformInfo);
273
274         OCStackResult setDefaultDeviceEntityHandler(EntityHandler entityHandler);
275
276         OCStackResult unregisterResource(const OCResourceHandle& resourceHandle) const;
277
278         OCStackResult bindResource(const OCResourceHandle collectionHandle,
279                     const OCResourceHandle resourceHandle);
280
281         OCStackResult bindResources(const OCResourceHandle collectionHandle,
282                     const std::vector<OCResourceHandle>& addedResourceHandleList);
283
284         OCStackResult unbindResource(const OCResourceHandle collectionHandle,
285                     const OCResourceHandle resourceHandle);
286
287         OCStackResult unbindResources(const OCResourceHandle collectionHandle,
288                         const std::vector<OCResourceHandle>& resourceHandleList);
289
290         OCStackResult bindTypeToResource(const OCResourceHandle& resourceHandle,
291                         const std::string& resourceTypeName) const;
292
293         OCStackResult bindInterfaceToResource(const OCResourceHandle& resourceHandle,
294                         const std::string& resourceInterfaceName) const;
295
296         OCStackResult startPresence(const unsigned int ttl);
297
298         OCStackResult stopPresence();
299
300         OCStackResult subscribePresence(OCPresenceHandle& presenceHandle, const std::string& host,
301                         OCConnectivityType connectivityType, SubscribeCallback presenceHandler);
302
303         OCStackResult subscribePresence(OCPresenceHandle& presenceHandle, const std::string& host,
304                         const std::string& resourceType, OCConnectivityType connectivityType,
305                         SubscribeCallback presenceHandler);
306         OCStackResult unsubscribePresence(OCPresenceHandle presenceHandle);
307
308 #ifdef WITH_CLOUD
309         OCStackResult subscribeDevicePresence(OCPresenceHandle& presenceHandle,
310                                               const std::string& host,
311                                               const std::vector<std::string>& di,
312                                               OCConnectivityType connectivityType,
313                                               ObserveCallback callback);
314 #endif
315
316         OCResource::Ptr constructResourceObject(const std::string& host, const std::string& uri,
317                         OCConnectivityType connectivityType, bool isObservable,
318                         const std::vector<std::string>& resourceTypes,
319                         const std::vector<std::string>& interfaces);
320
321         OCStackResult sendResponse(const std::shared_ptr<OCResourceResponse> pResponse);
322         std::weak_ptr<std::recursive_mutex> csdkLock();
323
324 #ifdef WITH_CLOUD
325         OCAccountManager::Ptr constructAccountManagerObject(const std::string& host,
326                                                             OCConnectivityType connectivityType);
327 #endif // WITH_CLOUD
328
329         OCStackResult getDeviceId(OCUUIdentity *myUuid);
330
331         OCStackResult setDeviceId(const OCUUIdentity *myUuid);
332
333         OCStackResult stop();
334         OCStackResult start();
335     private:
336         PlatformConfig m_cfg;
337         OCMode m_modeType;
338
339     private:
340         std::unique_ptr<WrapperFactory> m_WrapperInstance;
341         IServerWrapper::Ptr m_server;
342         IClientWrapper::Ptr m_client;
343         std::shared_ptr<std::recursive_mutex> m_csdkLock;
344         std::mutex m_startCountLock;
345         uint32_t m_startCount;
346
347     private:
348         /**
349         * Constructor for OCPlatform_impl. Constructs a new OCPlatform_impl from a given
350         * PlatformConfig with appropriate fields
351         * @param config PlatformConfig struct which has details such as modeType
352         * (server/client/both), in-proc/out-of-proc etc.
353         */
354         OCPlatform_impl(const PlatformConfig& config);
355
356         /**
357         * Private function to initialize the platform
358         */
359         OCStackResult init(const PlatformConfig& config);
360
361         /**
362         * Private constructor/operators to prevent copying
363         * of this object
364         */
365         OCPlatform_impl(const OCPlatform_impl& other)= delete;
366         OCPlatform_impl& operator=(const OCPlatform_impl&) = delete;
367         OCPlatform_impl& operator=(const OCPlatform_impl&&) = delete;
368     };
369 }
370
371 #endif //__OCPLATFORM_IMPL_H