f9d71f90fa9b7b2780c49c7dd130447c79afd67e
[platform/core/connectivity/ua-manager.git] / ua-plugins / include / ua-plugin.h
1 /*
2  * Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 #ifndef __UAM_PLUGIN_H__
19 #define __UAM_PLUGIN_H__
20
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 /* To be used in case user_id is not known */
26 #define USER_ID_UNKNOWN_USER -1
27
28 /* UA Plugin states */
29 typedef enum {
30         UAS_STATE_NOT_READY = 0x00,
31         UAS_STATE_READY
32 } uas_state_e;
33
34 /* Operating System types */
35 typedef enum {
36         UAS_OS_TYPE_UNDEFINED = 0x00,
37         UAS_OS_TYPE_TIZEN,
38         UAS_OS_TYPE_ANDROID,
39         UAS_OS_TYPE_IOS,
40         UAS_OS_TYPE_INVALID
41 } uas_os_type_e;
42
43 /* Supported technologies by device */
44 typedef enum {
45         UAS_TECH_TYPE_NONE = 0x00,
46         UAS_TECH_TYPE_BT = 0x01,
47         UAS_TECH_TYPE_BLE = 0x02,
48         UAS_TECH_TYPE_WIFI = 0x04,
49         UAS_TECH_TYPE_P2P = 0x08,
50 } uas_tech_type_e;
51
52 /* Device Address types */
53 typedef enum {
54         UAS_ADDR_TYPE_BT = 0x01,
55         UAS_ADDR_TYPE_BLE,
56         UAS_ADDR_TYPE_WIFI,
57         UAS_ADDR_TYPE_P2P,
58         UAS_ADDR_TYPE_IPv4,
59         UAS_ADDR_TYPE_IPv6,
60         UAS_ADDR_TYPE_INVALID
61 } uas_address_type_e;
62
63 /* UA plugin return status */
64 #define FOREACH_STATUS(STATUS) \
65         STATUS(UAS_STATUS_SUCCESS, 0x00) \
66         STATUS(UAS_STATUS_FAIL, 0x01) \
67         STATUS(UAS_STATUS_NOT_READY, 0x02) \
68         STATUS(UAS_STATUS_NOMEM, 0x03) \
69         STATUS(UAS_STATUS_BUSY, 0x04) \
70         STATUS(UAS_STATUS_ALREADY_DONE, 0x05) \
71         STATUS(UAS_STATUS_UNSUPPORTED, 0x06) \
72
73 #define GENERATE_STATUS_ENUM(ENUM, offset) ENUM = -offset,
74 #define GENERATE_STATUS_STRING(STRING, offset) #STRING,
75
76 typedef enum {
77         FOREACH_STATUS(GENERATE_STATUS_ENUM)
78 } uas_status_e;
79
80 /*
81  * Plugin capability :
82  *      - User detection Not Supported,
83  *      - User detection supported,
84  */
85 typedef enum {
86         UAS_NOT_SUPPORT_USER, /**< This means that not including user_id */
87         UAS_SUPPORT_USER /**< This means that including user_id */
88 } uas_capability_e;
89
90 /* Detection event types */
91 typedef enum {
92         UAS_PRESENCE = 0x01, /**< Presence event */
93         UAS_ABSENCE = 0x02 /**< Absence event */
94 } uas_detection_type_e;
95
96 /* Device address information structure */
97 typedef struct {
98         uas_address_type_e type; /**< Address fype for the connectivity */
99         char *address; /**< Address data */
100 } uas_address_info_t;
101
102 /* Device ble payload information structure */
103 typedef struct {
104         char service_id; /** Service Id */
105         char device_icon; /** Device icon */
106         char purpose; /** Purpose */
107         char *duid; /** DUID */
108         char *bt_mac; /** BT MAC Address */
109 } uas_ble_payload_t;
110
111 /* Device information structure */
112 typedef struct {
113         int user_id; /**< User ID for the DB */
114         unsigned int supported_techs; /**< Connectivity type */
115         char *device_id; /**< Device ID */
116         int os; /**< OS type (Tizen,Android, iOS) */
117         int num_addr; /**< The number of address list */
118         uas_address_info_t *addr_list; /**< Address list (IP, Subnet Mask, Gateway etc) */
119         int discriminant; /**< Determines whether to judge PRESENCE/ABSENCE */
120         unsigned long long last_seen; /**< Last seen time */
121         uas_ble_payload_t *payload; /**< BLE payload for BLE device filtering */
122 } uas_device_info_t;
123
124 /* Sensor information structure */
125 typedef struct {
126         unsigned int status; /**< Sensor status */
127         unsigned long long timestamp; /**< Last seen time */
128         int accuracy; /**< Accuracy */
129         int count; /**< How many sensor data are there */
130         double *values; /**< Sensor data */
131 } uas_sensor_info_t;
132
133 /* Active scan event types */
134 typedef enum {
135         UAS_ACTIVE_DEVICE_FOUND = 0x01,
136         UAS_ACTIVE_SCAN_COMPLETED = 0x02
137 } uas_active_scan_event_e;
138
139 /* Callback to be invoked on plug-in's state changes (Ready <-> Not Ready) */
140 typedef void (*uas_state_changed_callback)(int state);
141
142 /*
143  * Callback to be invoked on Presen/Absence detection is started/stopped by plug-in's
144  * [Param] state - 0 = detection stopped, 1 = detection started.
145  */
146 typedef void (*uas_detection_state_changed_callback)(int state);
147
148 /*
149  * Callback to be invoked on Presen/Absence detection status during detection operation
150  * by plug-in's which do not support User identification.
151  */
152 typedef void (*uas_detection_status_changed_callback)(uas_detection_type_e type,
153         void *sensor_info);
154
155 /*
156  * Callback to be invoked on Presen/Absence detection by plug-in's which do
157  * not support User identification.
158  */
159 typedef void (*uas_detection_callback)(uas_detection_type_e type, void *sensor_info);
160
161 /*
162  * Callback to be invoked on Presen/Absence detection by plug-in's which
163  * support User identification.
164  *
165  * [Param] device - Device for which Presence/Absence is detected.
166  */
167 typedef void (*uas_device_detection_callback)(uas_detection_type_e type,
168         uas_device_info_t *device);
169
170 /*
171  * Callback to be invoked in response to add_device() API
172  *
173  * [Param] status - Operation status Success/Fail
174  * [Param] device - Device for which add_device() was invoked.
175  */
176 typedef void (*uas_device_added_callback)(int status, uas_device_info_t *device);
177
178 /*
179  * Callback to be invoked in response to search_active_devices() API
180  *
181  * [Param] scan_event - UAS_ACTIVE_DEVICE_FOUND or, UAS_ACTIVE_SCAN_COMPLETED.
182  * [Param] device - Found registerd device info if event is UAS_ACTIVE_DEVICE_FOUND
183  * or, NULL if event is UAS_ACTIVE_SCAN_COMPLETED.
184  */
185 typedef void (*uas_device_active_scan_callback)(
186                 uas_active_scan_event_e event, const uas_device_info_t *device);
187
188
189 /* UA plug-in callback structure */
190 typedef struct {
191         uas_state_changed_callback state_changed_cb; /**< 0:Not ready 1:Ready */
192         uas_detection_state_changed_callback detection_state_cb; /**< 0:Stop 1:Start */
193         uas_detection_status_changed_callback detection_status_cb; /**< 1: change with param */
194         uas_detection_callback detected_cb; /**< For environmental sensors */
195         uas_device_detection_callback device_detected_cb; /**< For connectivity sensors */
196         uas_device_added_callback device_added_cb; /**< For connectivity sensors */
197         uas_device_active_scan_callback device_active_scan_cb; /**< For connectivity sensors */
198 } uas_callbacks_t;
199
200 typedef struct {
201         /* [Sync API] To initialize senspor plug-in */
202         int (*init)(const uas_callbacks_t* callbacks);
203
204         /* [Sync API] To deinitialize senspor plug-in */
205         int (*deinit)(void);
206
207         /* [Sync API] To get plug-in's current state (READY/NOT_READY) */
208         int (*get_state)(int *state);
209
210         /*
211          * [Sync API] To get plug-in's detection capability to help check if
212          * the plug-in supports user detection (Able to identify individual User's
213          * Presence/Absence) or, it only support Presence/Absence detection of without
214          * identifying users.
215          */
216         int (*get_capability)(uas_capability_e *capability);
217
218         /*
219          * [Sync API] To send registered device list from user DB to plug-ins for
220          * user/device detection. Called whenever device list changes (On device addition/removal).
221          *
222          * [Param] devices - List of registered devices relavant to the plug-in's operation.
223          *      For example, for WIFI plugin, list contains only devices that were registered/added
224          *      for WIFI detection.
225          */
226         int (*set_registered_devices)(int num_devices,
227                         uas_device_info_t *devices);
228
229         /*
230          * [Async API] To Add/register device to be used for User Presence/Absence detection.
231          * uas_device_added_callback() will be called with result of the operation.
232          *
233          * [Param] device - Device to be added/registered.
234          *
235          */
236         int (*add_device)(uas_device_info_t *device);
237
238         /*
239          * [Sync API] To remove/unregister device from the list used for User Presence/Absence
240          * detection.
241          *
242          * [Param] device - Device to be removed/unregistered.
243          */
244         int (*remove_device)(uas_device_info_t *device);
245
246         /* [Sync API] To start (User) Presence/Absence detection.
247          *
248          * [Param] type - What kind of event we should detectn.
249          *      This type may use bit-wise operation for instance, if we would like to detect
250          *  presence and absence simultaneously, we can set type like following:
251          *  -> type = UAS_PRESENCE | UAS_ABSENCE.
252          */
253         int (*start_detection)(unsigned int detection_type);
254
255         /* [Sync API] To stop (User) Presence/Absence detection.
256          *
257          * [Param] type - What kind of event we should stop.
258          *      This type may use bit-wise operation.
259          */
260         int (*stop_detection)(unsigned int detection_type);
261
262         /*
263          * [Sync API] To enable/disable suspend mode in plug-in. If suspend mode is
264          * enabled, subsequent call to start_detection() will trigger suspend mode operations
265          * for device detection.
266          * mode = 0 - Disable, mode = 1 - Enable
267          */
268         int (*set_low_power_mode)(int mode);
269
270         /*
271          * [Sync API] To set detection window in plug-in.
272          *
273          * [Param] detection_window - Time in second for which User detection procedure is
274          *      executed.
275          */
276         int (*set_detection_window)(unsigned int detection_window);
277
278         /*
279          * [Sync API] To set detection threshold value in plug-in.
280          *
281          * [Param] presence_threshold - A threshold value for detecting presence [Usage - Optional]
282          *      Ex:- In the case of a light plugin, this value is used as a threshold value for
283          *      detecting presence.
284          *
285          * [Param] absence_threshold - Threshold value for detecting absence [Usage - Optional]
286          *      Ex:- In the case of a light plugin, this value is used as a threshold value for
287          *      detecting absence.
288          */
289         int (*set_detection_threshold)(int presence_threshold, int absence_threshold);
290
291         /*
292          * [Async API] To search for currently active devices in proximity.
293          *
294          * [Param] detection_period - Time in second for which User detection procedure is
295          * executed.
296          *
297          * Once detection_period is over, list of current active devices will be returned using
298          * uas_active_devices_callback().
299          *
300          */
301         int (*scan_active_devices)(int detection_period);
302
303         /*
304          * [Async API] To cancel the ongoing active devices search.
305          */
306         int (*cancel_active_device_scan)(void);
307
308         /*
309          * [Sync API] To set iBeacon adv data in plug-in.
310          *
311          * [Param] adv_len - The value of length of iBeacon adv data to add.
312          *
313          * [Param] iadv - iBeacon adv data to be add.
314          */
315         int (*add_ibeacon_adv)(unsigned int adv_len, const char *iadv);
316 } uas_api_t;
317
318 typedef enum {
319         UAS_PLUGIN_ID_BLE = 0,
320         UAS_PLUGIN_ID_WIFI,
321         UAS_PLUGIN_ID_LIGHT,
322         UAS_PLUGIN_ID_MOTION,
323         UAS_PLUGIN_ID_MAX
324 } uas_plugin_id_e;
325
326 typedef struct {
327         /** Identifier of module */
328         int id;
329
330         /** Name of this module */
331         const char *name;
332
333         /** Author/owner/implementor of the module */
334         const char *author;
335
336         /** Version of the module-specific plugin API */
337         const char *version;
338
339         /** Modules init */
340         int (*init)(uas_api_t **api);
341
342         /** Modules de-init */
343         int (*deinit)(void);
344 } uas_module_t;
345
346 #define UAS_MODULE_ADD(id, name, author, version, init, deinit) \
347         uas_module_t uas_module = { id, name, author, version, init, deinit };
348
349 #ifdef __cplusplus
350 }
351 #endif
352 #endif /* __UAM_PLUGIN_H__ */