- Problem: Once a client app restarts, the previous last seen information is 0.
- Cause: As a requirement, last seen information of service-specific device
should be stored in DB
- Solution: Save the last seen information to the DB.
Change-Id: Ifd1e41c0c822b2274262d3aea6c723e192945822
Signed-off-by: saerome.kim <saerome.kim@samsung.com>
char device_id[UAM_DEVICE_ID_MAX_STRING_LEN]; /**< Device's uniquie ID */
uam_ble_payload_s payload; /**< BLE Payload to parse BLE devices*/
gboolean discriminant; /**< Determines whether to judge PRESENCE/ABSENCE */
- unsigned long long last_seen; /**< Latest timestamp when device was discoverd */
+ unsigned long long last_seen; /**< Latest seen time when device was discoverd */
} uam_device_info_s;
/**
unsigned int sensor_bitmask; /**< Detecting sensor's bitmask */
char account[UAM_USER_ACCOUNT_MAX_STRING_LEN]; /**< User account */
char service[UAM_SERVICE_MAX_STRING_LEN]; /**< Service name */
- unsigned long long timestamp; /**< Timestamp of detection */
+ unsigned long long last_seen; /**< The last time of detection */
char device_id[UAM_DEVICE_ID_MAX_STRING_LEN]; /**< Device's unique ID */
} uam_detection_event_data_s;
const char *device_id, uam_tech_type_e tech_type, gboolean *discriminant);
/**
+ * @brief Gets the last seen time for the device linked in the service.
+ * @since_tizen 5.5
+ *
+ * @param[in] service Service idt.
+ * @param[in] device_id Device id.
+ * @param[in] tech_type Sensor type.
+ * @param[out] last_seen The last seen time.
+ *
+ * @return 0 on success, otherwise a negative error value
+ * @retval #UAM_ERROR_NONE Successful
+ * @retval #UAM_ERROR_INVALID_PARAMETER Invalid parameters
+ * @retval #UAM_ERROR_INTERNAL Internal error
+ *
+ * @exception
+ * @pre
+ * @post
+ */
+int _uam_service_get_device_last_seen(const char *service,
+ const char *device_id, uam_tech_type_e tech_type, unsigned long long *last_seen);
+
+/**
* @brief Sets detction cycle per eash service.
* @since_tizen 5.5
*
REQUEST(UAM_REQUEST_REMOVE_USER_FROM_SERVICE) \
REQUEST(UAM_REQUEST_ADD_DEVICE_TO_SERVICE) \
REQUEST(UAM_REQUEST_REMOVE_DEVICE_FROM_SERVICE) \
- REQUEST(UAM_REQUEST_SET_DEVICE_DISCRIMINANT) \
- REQUEST(UAM_REQUEST_GET_DEVICE_DISCRIMINANT) \
+ REQUEST(UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT) \
+ REQUEST(UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT) \
+ REQUEST(UAM_REQUEST_GET_DEVICE_SERVICES_LAST_SEEN) \
REQUEST(UAM_REQUEST_SET_SERVICE_DETECTION_CYCLE) \
REQUEST(UAM_REQUEST_GET_SERVICE_DETECTION_CYCLE) \
REQUEST(UAM_REQUEST_GET_DETECTION_WINDOW) \
Name: ua-manager
Summary: User awareness manager
-Version: 0.13.2
+Version: 0.13.3
Release: 1
License: Apache-2.0
Source0: %{name}-%{version}.tar.gz
g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
g_array_append_vals(in_param2, str, sizeof(str));
g_array_append_vals(in_param3, &tech_type, sizeof(int));
- g_array_append_vals(in_param4, &discriminant, sizeof(int));
+ g_array_append_vals(in_param4, &discriminant, sizeof(gboolean));
- ret = _uam_sync_request(UAM_REQUEST_SET_DEVICE_DISCRIMINANT,
+ ret = _uam_sync_request(UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT,
in_param1, in_param2, in_param3, in_param4, &out_param);
UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
g_array_append_vals(in_param2, str, sizeof(str));
g_array_append_vals(in_param3, &tech_type, sizeof(int));
- ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_DISCRIMINANT,
+ ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT,
in_param1, in_param2, in_param3, in_param4, &out_param);
if (UAM_ERROR_NONE == ret) {
*discriminant = g_array_index(out_param, gboolean, 0);
return ret;
}
+UAM_EXPORT_API int _uam_service_get_device_last_seen(const char *service,
+ const char *device_id, uam_tech_type_e tech_type, unsigned long long *last_seen)
+{
+ FUNC_ENTRY;
+ int ret;
+ char svc_str[UAM_SERVICE_MAX_STRING_LEN];
+ char str[UAM_DEVICE_ID_MAX_STRING_LEN];
+
+ UAM_VALIDATE_INPUT_PARAMETER(service);
+ UAM_VALIDATE_INPUT_PARAMETER(device_id);
+
+ UAM_INIT_PARAMS();
+ UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
+ g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
+
+ g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
+ g_array_append_vals(in_param2, str, sizeof(str));
+ g_array_append_vals(in_param3, &tech_type, sizeof(int));
+
+ ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_LAST_SEEN,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+ if (UAM_ERROR_NONE == ret) {
+ *last_seen = g_array_index(out_param, unsigned long long, 0);
+ UAM_INFO("Last seen: %llu for %s-%d-%s", *last_seen, device_id,
+ tech_type, service);
+ }
+ UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ FUNC_EXIT;
+ return ret;
+}
+
+
UAM_EXPORT_API int _uam_set_service_detection_cycle(const char *service,
unsigned int cycle)
{
const char *account = NULL;
const char *service = NULL;
const char *device_id = NULL;
- unsigned long long timestamp = 0;
+ unsigned long long last_seen = 0;
- g_variant_get(parameters, "(ut&s&s&s)", &sensor_bitmask, ×tamp, &account,
+ g_variant_get(parameters, "(ut&s&s&s)", &sensor_bitmask, &last_seen, &account,
&service, &device_id);
UAM_DBG("Sensor: 0x%8.8X, User: %s, Device: %s timestamp [%llu]", sensor_bitmask,
- account, device_id, timestamp);
+ account, device_id, last_seen);
event = UAM_EVENT_USER_PRESENCE_DETECTED;
event_data.sensor_bitmask = sensor_bitmask;
g_strlcpy(event_data.account, account,
UAM_USER_ACCOUNT_MAX_STRING_LEN);
g_strlcpy(event_data.service, service, UAM_SERVICE_MAX_STRING_LEN);
- event_data.timestamp = timestamp;
+ event_data.last_seen = last_seen;
g_strlcpy(event_data.device_id, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
__uam_send_event(event, result, &event_data,
unsigned int sensor_bitmask;
char *account = NULL;
char *service = NULL;
- unsigned long long timestamp = 0;
+ unsigned long long last_seen = 0;
- g_variant_get(parameters, "(ut&s&s)", &sensor_bitmask, ×tamp, &account,
- &service);
+ g_variant_get(parameters, "(ut&s&s)",
+ &sensor_bitmask, &last_seen, &account, &service);
- UAM_DBG("Sensor: 0x%8.8X, User: %s timestamp [%llu]", sensor_bitmask, account, timestamp);
+ UAM_DBG("Sensor: 0x%8.8X, User: %s last_seen [%llu]",
+ sensor_bitmask, account, last_seen);
event = UAM_EVENT_USER_ABSENCE_DETECTED;
event_data.sensor_bitmask = sensor_bitmask;
g_strlcpy(event_data.account, account,
UAM_USER_ACCOUNT_MAX_STRING_LEN);
g_strlcpy(event_data.service, service, UAM_SERVICE_MAX_STRING_LEN);
- event_data.timestamp = timestamp;
+ event_data.last_seen = last_seen;
__uam_send_event(event, result, &event_data,
event_info->cb, event_info->user_data);
} else if (0 == strcasecmp(signal_name, UAM_SIGNAL_PRESENCE_DETECTED)) {
uam_sensor_info_s sensor_info;
unsigned int sensor_bitmask;
- unsigned long long timestamp;
+ unsigned long long last_seen;
int accuracy, count;
double values[UAM_SENSOR_MAX_VALUES];
- g_variant_get(parameters, "(utiidddd)", &sensor_bitmask, ×tamp,
+ g_variant_get(parameters, "(utiidddd)", &sensor_bitmask, &last_seen,
&accuracy, &count, &values[0], &values[1],
&values[2], &values[3]);
__uam_copy_sensor_data(&sensor_info, UAM_PRESENCE_STATE_PRESENT, sensor_bitmask,
- timestamp, accuracy, count, values);
+ last_seen, accuracy, count, values);
- UAM_DBG("Sensor: 0x%8.8X, timestamp [%llu]", sensor_bitmask, timestamp);
+ UAM_DBG("Sensor: 0x%8.8X, last_seen [%llu]", sensor_bitmask, last_seen);
event = UAM_EVENT_PRESENCE_DETECTED;
} else if (0 == strcasecmp(signal_name, UAM_SIGNAL_ABSENCE_DETECTED)) {
uam_sensor_info_s sensor_info;
unsigned int sensor_bitmask;
- unsigned long long timestamp;
+ unsigned long long last_seen;
int accuracy, count;
double values[UAM_SENSOR_MAX_VALUES];
- g_variant_get(parameters, "(utiidddd)", &sensor_bitmask, ×tamp,
+ g_variant_get(parameters, "(utiidddd)", &sensor_bitmask, &last_seen,
&accuracy, &count, &values[0], &values[1],
&values[2], &values[3]);
- UAM_DBG("Sensor: 0x%8.8X, timestamp [%llu]", sensor_bitmask, timestamp);
+ UAM_DBG("Sensor: 0x%8.8X, last_seen [%llu]", sensor_bitmask, last_seen);
__uam_copy_sensor_data(&sensor_info, UAM_PRESENCE_STATE_ABSENT,
- sensor_bitmask, timestamp, accuracy, count, values);
+ sensor_bitmask, last_seen, accuracy, count, values);
event = UAM_EVENT_ABSENCE_DETECTED;
tech_type INTEGER,
address TEXT,
ip_address TEXT,
- timestamp LONG,
+ last_seen LONG,
presence_state INTEGER,
os_type INTEGER,
discriminant INTEGER,
#endif
typedef enum {
- UAM_ADDR_TYPE_BT = 0x01,
- UAM_ADDR_TYPE_BLE,
- UAM_ADDR_TYPE_WIFI,
- UAM_ADDR_TYPE_P2P,
- UAM_ADDR_TYPE_IPv4,
- UAM_ADDR_TYPE_IPv6,
+ UAM_ADDR_TYPE_BT = 0x01, /**< Bluetooth device address */
+ UAM_ADDR_TYPE_BLE, /**< BLE device adress */
+ UAM_ADDR_TYPE_WIFI, /**< Wi-Fi Infra. device address */
+ UAM_ADDR_TYPE_P2P, /**< Wi-Fi Direct device address */
+ UAM_ADDR_TYPE_IPv4, /**< IPv4 Address */
+ UAM_ADDR_TYPE_IPv6, /**< IPv6 Address */
UAM_ADDR_TYPE_MAX
} uam_addr_type_e;
typedef struct {
char *name;
- unsigned int cycle;
- int remaining_time;
- int presence_threshold;
- int absence_threshold;
- GSList *monitors;
- GSList *dev_techs;
+ unsigned int cycle; /**< Detection Cycle = Detection Period * cycle */
+ int remaining_time; /**< Time remaining up to detection_cycle (unit: sec) */
+ int presence_threshold; /**< PRESENCE threshold */
+ int absence_threshold; /**< ABSENCE threshold */
+ GSList *monitors; /**< Monitor handle list */
+ GSList *dev_techs; /**< Device list */
} uam_db_service_info_t;
typedef struct {
- char *device_id;
- uam_tech_type_e tech_type;
- char *service;
- int discriminant;
- unsigned long long timestamp;
+ char *device_id; /**< Device ID */
+ uam_tech_type_e tech_type; /**< Connectivity type */
+ char *service; /**< Connected service name */
+ int discriminant; /**< Service dependent discriminant */
+ unsigned long long last_seen; /**< Service dependent last seen time */
} uam_svc_dev_info_t;
typedef struct {
- uam_addr_type_e addr_type;
- char *address;
+ uam_addr_type_e addr_type; /**< Address type (i.e., BT/BLE/Wi-Fi/IPv4/IPv6) */
+ char *address; /**< Address */
} uam_db_address_info_t;
typedef struct {
} uam_db_ble_payload_t;
typedef struct {
- uam_tech_type_e tech_type;
- GSList *addresses;
- int presence_state;
- unsigned long long timestamp;
- gboolean discriminant;
- struct uam_db_device_info *device;
- GSList *svc_list;
- uam_db_ble_payload_t *payload;
+ uam_tech_type_e tech_type; /**< Connectivity type */
+ GSList *addresses; /**< Address list */
+ int presence_state; /**< PRESENCE or ABSENCE */
+ unsigned long long last_seen; /**< Last seen time */
+ gboolean discriminant; /**< Decide whether to detect device or not */
+ struct uam_db_device_info *device; /**< Device info which stored in the DB */
+ GSList *svc_list; /**< Service list */
+ uam_db_ble_payload_t *payload; /**< Filtering info when detecting the BLE payload */
} uam_db_tech_info_t;
typedef struct uam_db_device_info {
- int os;
- char *device_id;
- GSList *tech_list;
- unsigned int supported_techs;
-// int presence_state;
-// long timestamp;
- struct uam_db_user_info *user;
+ int os; /**< OS type */
+ char *device_id; /**< Device ID */
+ GSList *tech_list; /**< Connectivity device info. list (i.e., BT/BLE/Wi-Fi/...)*/
+ unsigned int supported_techs; /**< bitmask to check how many connectivities are supported */
+ struct uam_db_user_info *user; /**< Owner infomation for these devices */
gboolean discriminant; /**< Determines whether to judge PRESENCE/ABSENCE */
} uam_db_device_info_t;
typedef struct uam_db_user_info {
- int user_id;
- char *name;
- char *account;
- GSList *devices;
-// int presence_state;
- unsigned long long timestamp;
+ int user_id; /**< User ID */
+ char *name; /**< User name */
+ char *account; /**< Account */
+ GSList *devices; /**< Device list */
+ unsigned long long last_seen; /**< Last seen time */
} uam_db_user_info_t;
typedef enum {
- UAM_ACTIVE_DEVICE_FOUND = 0x01,
- UAM_ACTIVE_SCAN_COMPLETED = 0x02
+ UAM_ACTIVE_DEVICE_FOUND = 0x01, /**< Found devices using ARPing */
+ UAM_ACTIVE_SCAN_COMPLETED = 0x02 /**< Active ARPing done */
} uam_active_scan_event_e;
int _uam_core_add_user(int *user_id, const char *account, const char *name);
int _uam_core_update_user(uam_user_info_s *user);
-int _uam_core_add_device(const char *account, const uam_device_info_s *dev_info);
+int _uam_core_add_device(const char *account,
+ const uam_device_info_s *dev_info);
-int _uam_core_remove_device(const char *account, const uam_device_info_s *dev_info);
+int _uam_core_remove_device(const char *account,
+ const uam_device_info_s *dev_info);
-int _uam_core_remove_device_by_device_id(const char *device_id, int tech_type);
+int _uam_core_remove_device_by_device_id(const char *device_id,
+ int tech_type);
int _uam_core_remove_device_by_mac(const char *mac);
int _uam_core_get_devcie_by_mac(const char *mac, uam_device_info_s *device);
-int _uam_core_get_user_by_device_id(const char *device_id, uam_user_info_s *user);
+int _uam_core_get_user_by_device_id(const char *device_id,
+ uam_user_info_s *user);
int _uam_core_get_user_by_mac(const char *mac, uam_user_info_s *user);
int _uam_core_set_detection_threshold(unsigned int sensor,
int presence_threshold, int absence_threshold);
-int _uam_core_start_presence_detection(const char *svc_name, char *sender, unsigned int sensors);
+int _uam_core_start_presence_detection(const char *svc_name, char *sender,
+ unsigned int sensors);
-int _uam_core_stop_presence_detection(const char *svc_name, char *sender, unsigned int sensors);
+int _uam_core_stop_presence_detection(const char *svc_name, char *sender,
+ unsigned int sensors);
-int _uam_core_start_absence_detection(const char *svc_name, char *sender, unsigned int sensors);
+int _uam_core_start_absence_detection(const char *svc_name, char *sender,
+ unsigned int sensors);
-int _uam_core_stop_absence_detection(const char *svc_name, char *sender, unsigned int sensors);
+int _uam_core_stop_absence_detection(const char *svc_name, char *sender,
+ unsigned int sensors);
int _uam_core_set_low_power_mode(unsigned int bit_mask, gboolean mode);
void _uam_core_handle_detection_stopped(unsigned int sensor);
-int _uam_core_start_active_device_scan(char *sender, unsigned int sensors, int detection_period);
+int _uam_core_start_active_device_scan(char *sender, unsigned int sensors,
+ int detection_period);
int _uam_core_stop_active_device_scan(char *sender, unsigned int sensors);
-void _uam_core_handle_active_device(uam_active_scan_event_e event, unsigned int sensor, const uam_device_info_s *dev_info);
+void _uam_core_handle_active_device(uam_active_scan_event_e event,
+ unsigned int sensor, const uam_device_info_s *dev_info);
int _uam_core_get_default_service(uam_service_info_s *service_info);
int _uam_core_unregister_service(const char *svc_name);
-int _uam_core_get_service_devices(const char *svc_name, int *count, uam_device_info_s **device_list);
+int _uam_core_get_service_devices(const char *svc_name, int *count,
+ uam_device_info_s **device_list);
-int _uam_core_get_service_users(const char *svc_name, int *count, uam_user_info_s **user_list);
+int _uam_core_get_service_users(const char *svc_name, int *count,
+ uam_user_info_s **user_list);
int _uam_core_get_services(int *count, uam_service_info_s **service_list);
int _uam_core_service_remove_user(const char *service, const char *account);
-int _uam_core_service_add_device(const char *service_name, const char *device_id, int tech_type);
+int _uam_core_service_add_device(const char *service_name,
+ const char *device_id, int tech_type);
+
+int _uam_core_service_remove_device(const char *service_name,
+ const char *device_id, int tech_type);
+
+int _uam_core_service_set_device_discriminant(const char *service_name,
+ const char *device_id, int tech_type, gboolean discriminant);
-int _uam_core_service_remove_device(const char *service_name, const char *device_id, int tech_type);
+int _uam_core_service_get_device_discriminant(const char *service_name,
+ const char *device_id, int tech_type, gboolean *discriminant);
-int _uam_core_service_set_device_discriminant(const char *service_name, const char *device_id, int tech_type, gboolean discriminant);
+int _uam_core_service_set_device_last_seen(const char *svc_name,
+ const char *device_id, int tech_type, unsigned long long last_seen);
-int _uam_core_service_get_device_discriminant(const char *service_name, const char *device_id, int tech_type, gboolean *discriminant);
+int _uam_core_service_get_device_last_seen(const char *svc_name,
+ const char *device_id, int tech_type, unsigned long long *last_seen);
-int _uam_core_set_service_detection_cycle(const char *svc_name, unsigned int cycle);
+int _uam_core_set_service_detection_cycle(const char *svc_name,
+ unsigned int cycle);
-int _uam_core_get_service_detection_cycle(const char *svc_name, unsigned int *cycle);
+int _uam_core_get_service_detection_cycle(const char *svc_name,
+ unsigned int *cycle);
int _uam_core_update_device(const uam_device_info_s *a_device);
int user_id;
uam_device_info_s dev_info;
int presence_state;
- unsigned long long timestamp;
+ unsigned long long last_seen;
} db_device_info_t;
/* db init/deinit */
/* insert */
int _uam_device_db_insert_device_info(
int user_id, const uam_device_info_s *dev_info, int presence_state,
- unsigned long long timestamp);
+ unsigned long long last_seen);
/* update */
-int _uam_device_db_update_device_lastseen(
- char *device_id, int tech_type, char *address, unsigned long long timestamp);
+int _uam_device_db_update_device_last_seen(
+ char *device_id, int tech_type, char *address, unsigned long long last_seen);
int _uam_device_db_update_device_presence(
char *device_id, int tech_type, char *address, int presence_state);
int _uam_device_db_update_device_ip_address(
/* DEVICE_SERVICE QUERIES */
typedef struct {
- char device_id[UAM_DEVICE_ID_MAX_STRING_LEN];
- uam_tech_type_e type;
- char svc[UAM_SERVICE_MAX_STRING_LEN];
- int discriminant;
+ char device_id[UAM_DEVICE_ID_MAX_STRING_LEN]; /**< Device ID */
+ uam_tech_type_e type; /**< Connectivity type */
+ char svc[UAM_SERVICE_MAX_STRING_LEN]; /**< Service name */
+ int discriminant; /**< Discriminant for each service */
+ unsigned long long last_seen; /**< Last seen time for each device of each service */
} db_svc_dev_info_t;
/* db init/deinit */
/* insert */
int _uam_db_insert_service(int device_number, int service_number,
- gboolean discriminant);
+ gboolean discriminant, unsigned long long last_seen);
int _uam_db_insert_device_service_info(const char *device_id, int tech_type,
- const char *address, const char *service_name, int cycle, gboolean discriminant);
+ const char *address, const char *service_name, int cycle, gboolean discriminant,
+ unsigned long long last_seen);
/* update */
int _uam_db_update_device_service_info(const char *device_id, int tech_type,
- const char *address, const char *service_name, gboolean discriminant);
+ const char *address, const char *service_name, gboolean discriminant, unsigned
+ long long last_seen);
+int _uam_db_update_device_service_discriminant(const char *device_id,
+ int tech_type, const char *address, const char *service_name, gboolean discriminant);
+int _uam_db_update_device_service_last_seen(const char *device_id,
+ int tech_type, const char *address, const char *service_name,
+ unsigned long long last_seen);
/* IBEACON_ADV QUERIES */
retv_if(NULL == sensor_info, NULL);
sensor_info->status = info->status;
- sensor_info->timestamp = info->timestamp;
+ sensor_info->timestamp = info->last_seen;
sensor_info->accuracy = info->accuracy;
sensor_info->count = info->count;
for (i = 0; i < info->count; i++) {
device->discriminant = tech->discriminant;
memset(device->payload.duid, 0, UAM_BLE_PAYLOAD_DUID_LEN + 1);
memset(device->payload.bt_mac, 0, UAM_BT_MAC_ADDRESS_STRING_LEN);
- device->last_seen = tech->timestamp;
+ device->last_seen = tech->last_seen;
__uam_copy_payload_info(&(device->payload), tech->payload);
FUNC_EXIT;
static void __uam_core_add_dev_to_list(
uam_db_user_info_t *user, const uam_device_info_s *dev_info,
- int presence_state, unsigned long long timestamp, GSList *svc_list)
+ int presence_state, unsigned long long last_seen, GSList *svc_list)
{
FUNC_ENTRY;
uam_db_tech_info_t *tech;
tech = g_new0(uam_db_tech_info_t, 1);
tech->tech_type = dev_info->type;
tech->presence_state = presence_state;
- tech->timestamp = timestamp;
+ tech->last_seen = last_seen;
tech->device = device;
tech->discriminant = dev_info->discriminant;
return is_ready;
}
-uam_svc_dev_info_t *_uam_core_find_svc_dev_info(const char *device_id, uam_tech_type_e tech_type,
- const char *svc_name)
+static uam_svc_dev_info_t *_uam_core_find_svc_dev_info(const char *device_id,
+ uam_tech_type_e tech_type, const char *svc_name)
{
FUNC_ENTRY;
uam_svc_dev_info_t *svc_dev = NULL;
return NULL;
}
-int _uam_core_update_svc_dev_info(const char *device_id, uam_tech_type_e tech_type,
- const char *svc_name, gboolean discriminant)
+static int _uam_core_update_svc_dev_info(const char *device_id, uam_tech_type_e tech_type,
+ const char *svc_name, gboolean discriminant, unsigned long long last_seen)
{
FUNC_ENTRY;
uam_svc_dev_info_t *svc = NULL;
}
svc->discriminant = discriminant;
+ svc->last_seen = last_seen;
- UAM_DBG("Service [%s] device [%s] tech_type [%d] discriminant [%d]",
+ UAM_DBG("Service [%s] device [%s] tech_type [%d] discriminant [%d] last_seen[%llu]",
+ svc->service, svc->device_id, svc->tech_type, svc->discriminant, svc->last_seen);
+
+ FUNC_EXIT;
+ return UAM_ERROR_NONE;
+}
+
+static int _uam_core_update_svc_dev_info_discriminant(const char *device_id,
+ uam_tech_type_e tech_type, const char *svc_name, gboolean discriminant)
+{
+ FUNC_ENTRY;
+ uam_svc_dev_info_t *svc = NULL;
+
+ retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
+ retv_if(UAM_TECH_TYPE_NONE >= tech_type, UAM_ERROR_INVALID_PARAMETER);
+ retv_if(UAM_TECH_TYPE_MAX <= tech_type, UAM_ERROR_INVALID_PARAMETER);
+ retv_if(NULL == svc_name, UAM_ERROR_INVALID_PARAMETER);
+
+ svc = _uam_core_find_svc_dev_info(device_id, tech_type, svc_name);
+ if (!svc) {
+ svc = g_new0(uam_svc_dev_info_t, 1);
+ svc->device_id = g_strdup(device_id);
+ svc->tech_type = tech_type;
+ svc->service = g_strdup(svc_name);
+ svc_devs = g_slist_append(svc_devs, svc);
+ }
+
+ svc->discriminant = discriminant;
+
+ UAM_DBG("Service [%s] device [%s] tech_type [%d] discriminant [%d]]",
svc->service, svc->device_id, svc->tech_type, svc->discriminant);
FUNC_EXIT;
/* Insert device service info to db */
ret = _uam_db_insert_device_service_info(device->device_id,
tech->tech_type, mac, service->name, service->cycle,
- device->discriminant);
+ device->discriminant, tech->last_seen);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service addition to persistent DB failed");
__uam_db_end_transaction(0);
return ret;
}
- ret = _uam_core_update_svc_dev_info(device->device_id,
- tech->tech_type, service->name, device->discriminant);
+ ret = _uam_core_update_svc_dev_info(device->device_id, tech->tech_type,
+ service->name, device->discriminant, tech->last_seen);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service addition to service device mapping failed");
__uam_db_end_transaction(0);
return NULL;
}
-int _uam_core_service_add_device(const char *svc_name, const char *device_id, int tech_type)
+int _uam_core_service_add_device(const char *svc_name, const char *device_id,
+ int tech_type)
{
FUNC_ENTRY;
GSList *l;
mac = __get_mac_addr(tech_info);
/* Insert device service info to db */
- ret = _uam_db_insert_device_service_info(device_id,
- tech_type, mac, service->name, service->cycle, tech_info->discriminant);
+ ret = _uam_db_insert_device_service_info(device_id, tech_type, mac, service->name,
+ service->cycle, tech_info->discriminant, tech_info->last_seen);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service addition to persistent DB failed");
return ret;
}
- ret = _uam_core_update_svc_dev_info(device_id,
- tech_type, service->name, tech_info->discriminant);
+ ret = _uam_core_update_svc_dev_info(device_id, tech_type, service->name,
+ tech_info->discriminant, tech_info->last_seen);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service addition to svc dev mapping failed");
return ret;
return UAM_ERROR_NONE;
}
-int _uam_core_service_remove_device(const char *svc_name, const char *device_id, int tech_type)
+int _uam_core_service_remove_device(const char *svc_name,
+ const char *device_id, int tech_type)
{
FUNC_ENTRY;
GSList *l;
mac = __get_mac_addr(tech_info);
/* Insert device service info to db */
- ret = _uam_db_update_device_service_info(device_id,
+ ret = _uam_db_update_device_service_discriminant(device_id,
tech_type, mac, service->name, discriminant);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service discriminant update to persistent DB failed");
return ret;
}
- ret = _uam_core_update_svc_dev_info(device_id,
+ ret = _uam_core_update_svc_dev_info_discriminant(device_id,
tech_type, service->name, discriminant);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service discriminant mapping update failed");
return UAM_ERROR_NONE;
}
+int _uam_core_service_get_device_last_seen(const char *svc_name,
+ const char *device_id, int tech_type, unsigned long long *last_seen)
+{
+ FUNC_ENTRY;
+ uam_svc_dev_info_t *svc_dev;
+
+ retv_if(NULL == svc_name, UAM_ERROR_INVALID_PARAMETER);
+ retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
+ retv_if(UAM_TECH_TYPE_NONE >= tech_type, UAM_ERROR_INVALID_PARAMETER);
+ retv_if(UAM_TECH_TYPE_MAX <= tech_type, UAM_ERROR_INVALID_PARAMETER);
+
+ svc_dev = _uam_core_find_svc_dev_info(device_id, tech_type, svc_name);
+ retv_if(NULL == svc_dev, UAM_ERROR_INVALID_PARAMETER);
+ *last_seen = svc_dev->last_seen;
+
+ FUNC_EXIT;
+ return UAM_ERROR_NONE;
+}
+
int _uam_core_set_service_detection_cycle(const char *svc_name, unsigned int new_cycle)
{
FUNC_ENTRY;
svc_list = __convert_db_svc_list_to_uam_svc_list(l1);
__uam_core_add_dev_to_list(user, &(db_info->dev_info),
- db_info->presence_state, db_info->timestamp, svc_list);
+ db_info->presence_state, db_info->last_seen, svc_list);
}
/* Fetch iBeacon adv list */
db_svc_dev_info_t *db_svc = l->data;
_uam_core_update_svc_dev_info(db_svc->device_id, db_svc->type,
- db_svc->svc, db_svc->discriminant);
+ db_svc->svc, db_svc->discriminant, db_svc->last_seen);
}
}
UAM_PRESENCE_STATE_PRESENT, dev_info->last_seen, svc_list);
retv_if(UAM_ERROR_NONE != __uam_db_begin_transaction(), UAM_ERROR_DB_FAILED);
+
/* Add device to database */
- ret = _uam_device_db_insert_device_info(user->user_id,
- dev_info, UAM_PRESENCE_STATE_PRESENT, dev_info->last_seen);
+ ret = _uam_device_db_insert_device_info(user->user_id, dev_info,
+ UAM_PRESENCE_STATE_PRESENT, 0);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device addition to persistent DB failed");
__uam_db_end_transaction(0);
ret = _uam_db_insert_device_service_info(
dev_info->device_id, dev_info->type, dev_info->mac,
UAM_SERVICE_DEFAULT, UAM_DETECTION_CYCLE_DEFAULT,
- dev_info->discriminant);
+ dev_info->discriminant, dev_info->last_seen);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service addition to persistent DB failed");
__send_device_event(ret, UAM_EVENT_DEVICE_ADDED, dev_info);
}
__uam_db_end_transaction(1);
- ret = _uam_core_update_svc_dev_info(
- dev_info->device_id, dev_info->type,
- UAM_SERVICE_DEFAULT, dev_info->discriminant);
+ ret = _uam_core_update_svc_dev_info(dev_info->device_id, dev_info->type,
+ UAM_SERVICE_DEFAULT, dev_info->discriminant, dev_info->last_seen);
if (UAM_ERROR_NONE != ret) {
UAM_WARN("Device service mappiing update failed");
__send_device_event(ret, UAM_EVENT_DEVICE_ADDED, dev_info);
{
FUNC_ENTRY;
GSList *l;
+ unsigned long long timestamp;
UAM_INFO("sensor 0x[%8.8X]", sensor);
return;
}
+ timestamp = _uam_get_timestamp();
+
if (UAM_SENSOR_BITMASK_LIGHT != sensor) {
_uam_manager_send_event(NULL, UAM_EVENT_PRESENCE_DETECTED,
- g_variant_new("(utiidddd)", sensor, sensor_info->timestamp,
+ g_variant_new("(utiidddd)", sensor, timestamp,
sensor_info->accuracy, sensor_info->count, sensor_info->values[0],
sensor_info->values[1], sensor_info->values[2], sensor_info->values[3]));
UAM_DBG("Sent UAM_EVENT_PRESENCE_DETECTED for 0x%8.8X", sensor);
continue;
_uam_manager_send_event(mon->name, UAM_EVENT_PRESENCE_DETECTED,
- g_variant_new("(utiidddd)", sensor, sensor_info->timestamp,
+ g_variant_new("(utiidddd)", sensor, timestamp,
sensor_info->accuracy, sensor_info->count, sensor_info->values[0],
sensor_info->values[1], sensor_info->values[2], sensor_info->values[3]));
UAM_DBG("Sent UAM_EVENT_PRESENCE_DETECTED to %s for 0x%8.8X",
uam_db_user_info_t *user;
uam_svc_dev_info_t *svc_dev = NULL;
gboolean live_monitoring = FALSE;
+ unsigned long long timestamp;
ret_if(NULL == tech);
ret_if(NULL == tech->svc_list);
user = tech->device->user;
- user->timestamp = tech->timestamp;
+ user->last_seen = tech->last_seen;
for (l = tech->svc_list; NULL != l; l = g_slist_next(l)) {
uam_db_service_info_t *svc = l->data;
*/
live_monitoring = TRUE;
+ timestamp = _uam_get_timestamp();
UAM_INFO("sensor [%d]", sensor);
_uam_manager_send_event(mon->name,
UAM_EVENT_USER_PRESENCE_DETECTED,
- g_variant_new("(utsss)", sensor, user->timestamp,
+ g_variant_new("(utsss)", sensor, timestamp,
user->account, svc->name,device_id));
UAM_DBG("Sent UAM_EVENT_USER_PRESENCE_DETECTED to %s"
" on device %s"
mon->name, device_id,
sensor, user->account,
svc->name,
- user->timestamp);
+ timestamp);
}
if (live_monitoring)
- svc_dev->timestamp = tech->timestamp;
+ svc_dev->last_seen = tech->last_seen;
}
FUNC_EXIT;
tech = l->data;
tech->presence_state = UAM_PRESENCE_STATE_PRESENT;
- tech->timestamp = _uam_get_timestamp();
+ tech->last_seen = dev_info->last_seen;
retv_if(UAM_ERROR_NONE != __uam_db_begin_transaction(), UAM_ERROR_INVALID_PARAMETER);
/* Check if IP address was updated then update in DB */
}
/* Update database (presence state & timestamp) */
- ret = _uam_device_db_update_device_lastseen(dev_info->device_id,
+ ret = _uam_device_db_update_device_last_seen(dev_info->device_id,
dev_info->type, dev_info->mac, dev_info->last_seen);
if (UAM_ERROR_NONE != ret) {
- UAM_WARN("_uam_device_db_update_device_lastseen failed");
+ UAM_WARN("_uam_device_db_update_device_last_seen failed");
__uam_db_end_transaction(0);
return ret;
}
if (!user)
continue;
- user->timestamp = 0;
+ user->last_seen = 0;
_uam_manager_send_event(mon->name,
UAM_EVENT_USER_ABSENCE_DETECTED,
- g_variant_new("(utss)", sensor, user->timestamp,
+ g_variant_new("(utss)", sensor, user->last_seen,
user->account, svc->name));
UAM_DBG("Sent UAM_EVENT_USER_ABSENCE_DETECTED to %s"
" for 0x%8.8X, User: %s Service: %s",
UAM_INFO("Count = %d, indx = %d", *count, indx);
- /* Update service specific device timestamp */
+ /* Update service specific device last time */
for (s = svc_devs; s; s = g_slist_next(s)) {
svc_dev = s->data;
g_strcmp0(svc_dev->device_id, dev->device_id))
continue;
- dev->last_seen = svc_dev->timestamp;
+ dev->last_seen = svc_dev->last_seen;
}
}
"tech_type INTEGER, " \
"address TEXT, " \
"ip_address TEXT, " \
- "timestamp LONG, " \
+ "last_seen LONG, " \
"presence_state INTEGER, " \
"os_type INTEGER, " \
"discriminant INTEGER, " \
"device_number INTEGER, " \
"service_number INTEGER, " \
"discriminant INTEGER, " \
+ "last_seen LONG, " \
"FOREIGN KEY(device_number) REFERENCES devices(device_number), " \
"FOREIGN KEY(service_number) REFERENCES services(service_number), " \
"PRIMARY KEY(device_number, service_number) " \
#include "ua-manager-database.h"
#define SELECT_ALL_DEVICES "SELECT device_id, tech_type, address, " \
- "ip_address, timestamp, presence_state, os_type, " \
+ "ip_address, last_seen, presence_state, os_type, " \
"user_id, discriminant, service_id, purpose, duid, device_icon FROM devices"
#define SELECT_DEVICE "SELECT device_id, tech_type, address, " \
- "ip_address, timestamp, presence_state, os_type, " \
+ "ip_address, last_seen, presence_state, os_type, " \
"user_id, discriminant, service_id, purpose, duid, device_icon FROM devices " \
"WHERE device_id = ? AND tech_type = ? AND address = ?"
"WHERE device_id = ? AND tech_type = ? AND address = ?"
#define INSERT_DEVICE "insert into devices " \
- "(device_id, tech_type, address, ip_address, timestamp, " \
+ "(device_id, tech_type, address, ip_address, last_seen, " \
"presence_state, os_type, user_id, discriminant, service_id, " \
"purpose, duid, device_icon)" \
"values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
-#define UPDATE_TIMESTAMP "UPDATE devices " \
- "SET timestamp = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
+#define UPDATE_LAST_SEEN "UPDATE devices " \
+ "SET last_seen = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
#define UPDATE_PRESENCE "UPDATE devices " \
"SET presence_state = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
static sqlite3_stmt *select_device_number;
/* UPDATE statements */
-static sqlite3_stmt *update_timestamp;
+static sqlite3_stmt *update_last_seen;
static sqlite3_stmt *update_presence;
static sqlite3_stmt *update_ip_address;
static sqlite3_stmt *update_device;
{
FUNC_ENTRY;
- FINALIZE(update_timestamp);
+ FINALIZE(update_last_seen);
FINALIZE(update_presence);
FINALIZE(update_ip_address);
FINALIZE(update_device);
return SQLITE_OK;
}
- PREPARE_QUERY(rc, db, update_timestamp,
- UPDATE_TIMESTAMP, __uam_device_finalize_update);
+ PREPARE_QUERY(rc, db, update_last_seen,
+ UPDATE_LAST_SEEN, __uam_device_finalize_update);
PREPARE_QUERY(rc, db, update_presence,
UPDATE_PRESENCE, __uam_device_finalize_update);
PREPARE_QUERY(rc, db, update_ip_address,
return error_code;
}
-int _uam_device_db_update_device_lastseen(char *device_id, int tech_type,
- char *address, unsigned long long timestamp)
+int _uam_device_db_update_device_last_seen(char *device_id, int tech_type,
+ char *address, unsigned long long last_seen)
{
int error_code = UAM_ERROR_NONE;
- sqlite3_stmt *stmt = update_timestamp;
+ sqlite3_stmt *stmt = update_last_seen;
int sql_ret = SQLITE_OK;
retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
- DB_ACTION(sqlite3_bind_int64(stmt, 1, timestamp),
+ DB_ACTION(sqlite3_bind_int64(stmt, 1, last_seen),
error_code, handle_error);
DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
error_code, handle_error);
sql_ret = sqlite3_step(stmt);
if (sql_ret != SQLITE_DONE) {
- UAM_ERR("Failed to update device timestamp [%d:%s]",
+ UAM_ERR("Failed to update device last_seen [%d:%s]",
sql_ret, sqlite3_errmsg(database_handle));
error_code = UAM_ERROR_DB_FAILED;
goto handle_error;
}
- UAM_DBG("Device timestamp updated [%llu]", timestamp);
+ UAM_DBG("Device last_seen updated [%llu]", last_seen);
handle_error:
sqlite3_reset(stmt);
}
int _uam_device_db_insert_device_info(int user_id,
- const uam_device_info_s *dev_info, int presence_state, unsigned long long timestamp)
+ const uam_device_info_s *dev_info, int presence_state, unsigned long long last_seen)
{
FUNC_ENTRY;
int error_code = UAM_ERROR_NONE;
UAM_INFO("%s-%d-%s-%s-%llu-%d-%d-%d-%d-0x%2.2X", dev_info->device_id,
dev_info->type, dev_info->mac, dev_info->ipv4_addr,
- timestamp, presence_state, dev_info->operating_system, dev_info->discriminant,
+ last_seen, presence_state, dev_info->operating_system, dev_info->discriminant,
user_id, dev_info->payload.service_id);
DB_ACTION(sqlite3_bind_text(stmt, 1, dev_info->device_id, -1, SQLITE_TRANSIENT),
error_code, handle_error);
DB_ACTION(sqlite3_bind_text(stmt, 4, dev_info->ipv4_addr, -1, SQLITE_TRANSIENT),
error_code, handle_error);
- DB_ACTION(sqlite3_bind_int64(stmt, 5, timestamp),
+ DB_ACTION(sqlite3_bind_int64(stmt, 5, last_seen),
error_code, handle_error);
DB_ACTION(sqlite3_bind_int(stmt, 6, presence_state),
error_code, handle_error);
UAM_MAC_ADDRESS_STRING_LEN);
g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3),
UAM_IP_ADDRESS_MAX_STRING_LEN);
- info->timestamp = sqlite3_column_int64(stmt, 4);
+ info->last_seen = sqlite3_column_int64(stmt, 4);
info->presence_state = sqlite3_column_int(stmt, 5);
info->dev_info.operating_system = sqlite3_column_int(stmt, 6);
info->user_id = sqlite3_column_int(stmt, 7);
info->dev_info.type,
info->dev_info.mac,
info->dev_info.ipv4_addr,
- info->timestamp,
+ info->last_seen,
info->presence_state,
info->dev_info.operating_system,
info->user_id,
UAM_MAC_ADDRESS_STRING_LEN);
g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3),
UAM_IP_ADDRESS_MAX_STRING_LEN);
- info->timestamp = sqlite3_column_int64(stmt, 4);
+ info->last_seen = sqlite3_column_int64(stmt, 4);
info->presence_state = sqlite3_column_int(stmt, 5);
info->dev_info.operating_system = sqlite3_column_int(stmt, 6);
info->user_id = sqlite3_column_int(stmt, 7);
info->dev_info.type,
info->dev_info.mac,
info->dev_info.ipv4_addr,
- info->timestamp,
+ info->last_seen,
info->presence_state,
info->dev_info.operating_system,
info->user_id,
#define SELECT_DEVICE_SERVICES_COUNT "SELECT count(*) " \
"FROM device_services where device_number = ?"
-#define SELECT_DEVICE_SERVICES "SELECT D.device_id, D.tech_type, S.service_name, P.discriminant " \
+#define SELECT_DEVICE_SERVICES \
+ "SELECT D.device_id, D.tech_type, S.service_name, P.discriminant, P.last_seen " \
"FROM device_services as P JOIN services as S USING(service_number) JOIN devices as D " \
"USING(device_number)"
#define INSERT_DEVICE_SERVICE "insert into device_services " \
- "(device_number, service_number, discriminant) values (?, ?, ?)"
+ "(device_number, service_number, discriminant, last_seen) values (?, ?, ?, ?)"
#define DELETE_ALL_DEVICE_SERVICES "delete from device_services "
#define DELETE_SERVICE "delete from device_services " \
"WHERE service_number = ?"
-#define UPDATE_DEVICE_SERVICE "UPDATE device_services " \
+#define UPDATE_DEVICE_SERVICE_DISCRIMINANT "UPDATE device_services " \
"SET discriminant = ? WHERE device_number = ? AND service_number = ?"
+#define UPDATE_DEVICE_SERVICE_LAST_SEEN "UPDATE device_services " \
+ "SET last_seen = ? WHERE device_number = ? AND service_number = ?"
+
/* DELETE statements */
static sqlite3_stmt *delete_all_device_services;
static sqlite3_stmt *delete_service;
static sqlite3_stmt *insert_device_service;
/* UPDATE statements */
-static sqlite3_stmt *update_device_service;
+static sqlite3_stmt *update_device_service_discriminant;
+static sqlite3_stmt *update_device_service_last_seen;
extern sqlite3 *database_handle;
{
FUNC_ENTRY;
- FINALIZE(update_device_service);
+ FINALIZE(update_device_service_discriminant);
+ FINALIZE(update_device_service_last_seen);
FUNC_EXIT;
}
return SQLITE_OK;
}
- PREPARE_QUERY(rc, db, update_device_service,
- UPDATE_DEVICE_SERVICE, __uam_device_service_finalize_update);
+ PREPARE_QUERY(rc, db, update_device_service_discriminant,
+ UPDATE_DEVICE_SERVICE_DISCRIMINANT, __uam_device_service_finalize_update);
+ PREPARE_QUERY(rc, db, update_device_service_last_seen,
+ UPDATE_DEVICE_SERVICE_DISCRIMINANT, __uam_device_service_finalize_update);
initialized = 1;
FUNC_EXIT;
return rc;
}
-static int __uam_device_service_table_deviceservicesinfo_prepare(sqlite3 *db)
+static int __uam_device_service_table_deviceservicesinfo_prepare(
+ sqlite3 *db)
{
FUNC_ENTRY;
{
FUNC_ENTRY;
- EXEC(UAM_ERROR_NONE, __uam_device_service_table_deviceservicesinfo_prepare(database_handle),
- handle_error);
+ EXEC(UAM_ERROR_NONE, __uam_device_service_table_deviceservicesinfo_prepare(
+ database_handle), handle_error);
FUNC_EXIT;
return UAM_ERROR_NONE;
return UAM_ERROR_DB_FAILED;
}
-int _uam_db_insert_service(int device_number, int service_number, gboolean discriminant)
+int _uam_db_insert_service(int device_number, int service_number,
+ gboolean discriminant, unsigned long long last_seen)
{
FUNC_ENTRY;
int error_code = UAM_ERROR_NONE;
DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
DB_ACTION(sqlite3_bind_int(stmt, 2, service_number), error_code, handle_error);
DB_ACTION(sqlite3_bind_int(stmt, 3, discriminant), error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int64(stmt, 4, last_seen), error_code, handle_error);
sql_ret = sqlite3_step(stmt);
if (sql_ret != SQLITE_DONE) {
goto handle_error;
}
- UAM_DBG("Device-service info inserted [%d] [%d] [%d]", device_number,
- service_number, discriminant);
+ UAM_DBG("Device-service info inserted [%d] [%d] [%d] [%llu]", device_number,
+ service_number, discriminant, last_seen);
handle_error:
sqlite3_reset(stmt);
return error_code;
}
-int _uam_db_update_device_service(int device_number, int service_number,
- gboolean discriminant)
+int _uam_db_insert_device_service_info(const char *device_id, int tech_type,
+ const char *address, const char *service_name, int cycle, gboolean discriminant,
+ unsigned long long last_seen)
+{
+ FUNC_ENTRY;
+ int ret = UAM_ERROR_NONE;
+ db_service_info_t info;
+ int service_number = 0;
+
+ UAM_INFO("%s-%d-%s-%s-%d", device_id, tech_type, address, service_name, cycle);
+
+ int device_number = 0;
+ ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
+ if (UAM_ERROR_NONE != ret)
+ goto handle_error;
+
+ ret = _uam_db_get_service_info(service_name, &info);
+ if (UAM_ERROR_NONE != ret)
+ goto handle_error;
+
+ service_number = info.service_number;
+
+ UAM_INFO("%d-%d", device_number, service_number);
+
+ ret = _uam_db_insert_service(device_number, service_number, discriminant, last_seen);
+ if (UAM_ERROR_NONE != ret)
+ goto handle_error;
+
+ UAM_DBG("Device-service info inserted [%d] [%d] [%d] [%llu]", device_number,
+ service_number, discriminant, last_seen);
+
+handle_error:
+ FUNC_EXIT;
+ return ret;
+}
+
+static int __uam_db_update_discriminant(int device_number,
+ int service_number, gboolean discriminant)
{
FUNC_ENTRY;
int error_code = UAM_ERROR_NONE;
- sqlite3_stmt *stmt = update_device_service;
+ sqlite3_stmt *stmt = update_device_service_discriminant;
int sql_ret = SQLITE_OK;
UAM_INFO("%d-%d", device_number, service_number);
sql_ret = sqlite3_step(stmt);
if (sql_ret != SQLITE_DONE) {
- UAM_ERR("Failed to insert device-service info [%d:%s]",
+ UAM_ERR("Failed to update device-service [%d:%s]",
sql_ret, sqlite3_errmsg(database_handle));
error_code = UAM_ERROR_DB_FAILED;
goto handle_error;
}
- UAM_DBG("Device-service info inserted [%d] [%d] [%d]", device_number,
- service_number, discriminant);
+ UAM_DBG("Device-service info updated [%d] [%d] [%d] ",
+ device_number, service_number, discriminant);
handle_error:
sqlite3_reset(stmt);
return error_code;
}
-int _uam_db_insert_device_service_info(const char *device_id, int tech_type,
- const char *address, const char *service_name, int cycle, gboolean discriminant)
+static int __uam_db_update_last_seen(int device_number,
+ int service_number, unsigned long long last_seen)
+{
+ FUNC_ENTRY;
+ int error_code = UAM_ERROR_NONE;
+ sqlite3_stmt *stmt = update_device_service_last_seen;
+ int sql_ret = SQLITE_OK;
+
+ UAM_INFO("%d-%d", device_number, service_number);
+
+ DB_ACTION(sqlite3_bind_int(stmt, 1, last_seen), error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 2, device_number), error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 3, service_number), error_code, handle_error);
+
+ sql_ret = sqlite3_step(stmt);
+ if (sql_ret != SQLITE_DONE) {
+ UAM_ERR("Failed to update device-service [%d:%s]",
+ sql_ret, sqlite3_errmsg(database_handle));
+ error_code = UAM_ERROR_DB_FAILED;
+ goto handle_error;
+ }
+
+ UAM_DBG("Device-service info updated [%d] [%d] [%llu]",
+ device_number, service_number, last_seen);
+
+handle_error:
+ sqlite3_reset(stmt);
+ FUNC_EXIT;
+ return error_code;
+}
+
+int _uam_db_update_device_service_discriminant(const char *device_id,
+ int tech_type, const char *address, const char *service_name, gboolean discriminant)
{
FUNC_ENTRY;
int ret = UAM_ERROR_NONE;
db_service_info_t info;
int service_number = 0;
- UAM_INFO("%s-%d-%s-%s-%d", device_id, tech_type, address, service_name, cycle);
+ UAM_INFO("%s-%d-%s-%s-%d", device_id, tech_type, address, service_name, discriminant);
int device_number = 0;
ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
} else
goto handle_error;
- UAM_INFO("%d-%d", device_number, service_number);
-
- ret = _uam_db_insert_service(device_number, service_number, discriminant);
+ ret = __uam_db_update_discriminant(device_number, service_number, discriminant);
if (UAM_ERROR_NONE != ret)
goto handle_error;
- UAM_DBG("Device-service info inserted [%d] [%d] [%d]", device_number,
- service_number, discriminant);
+ UAM_DBG("Device-service info updated [%d] [%d]", device_number, service_number);
handle_error:
FUNC_EXIT;
return ret;
}
-int _uam_db_update_device_service_info(const char *device_id, int tech_type,
- const char *address, const char *service_name, gboolean discriminant)
+int _uam_db_update_device_service_last_seen(const char *device_id,
+ int tech_type, const char *address, const char *service_name,
+ unsigned long long last_seen)
{
FUNC_ENTRY;
int ret = UAM_ERROR_NONE;
db_service_info_t info;
int service_number = 0;
- UAM_INFO("%s-%d-%s-%s-%d", device_id, tech_type, address, service_name, discriminant);
+ UAM_INFO("%s-%d-%s-%s-%llu", device_id, tech_type, address, service_name, last_seen);
int device_number = 0;
ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
} else
goto handle_error;
- ret = _uam_db_update_device_service(device_number, service_number, discriminant);
+ ret = __uam_db_update_last_seen(device_number, service_number, last_seen);
if (UAM_ERROR_NONE != ret)
goto handle_error;
return ret;
}
+
int _uam_device_service_db_clear(void)
{
int error_code = UAM_ERROR_NONE;
return error_code;
}
-int _uam_db_delete_device_service_number(int device_number, int service_number)
+int _uam_db_delete_device_service_number(int device_number,
+ int service_number)
{
FUNC_ENTRY;
int error_code = UAM_ERROR_NONE;
return error_code;
}
-int _uam_db_delete_device_service_mapping(const char *device_id, int tech_type,
- const char *address)
+int _uam_db_delete_device_service_mapping(const char *device_id,
+ int tech_type, const char *address)
{
FUNC_ENTRY;
int ret = UAM_ERROR_NONE;
g_strlcpy(info->svc, (char *)sqlite3_column_text(stmt, 2),
UAM_SERVICE_MAX_STRING_LEN);
info->discriminant = sqlite3_column_int(stmt, 3);
+ info->last_seen = sqlite3_column_int64(stmt, 4);
- UAM_INFO("%s-%d-%s-%d",
+ UAM_INFO("%s-%d-%s-%d-%llu",
info->device_id,
info->type,
info->svc,
- info->discriminant);
+ info->discriminant,
+ info->last_seen);
svc_dev_list = g_slist_append(svc_dev_list, info);
break;
result = _uam_core_service_remove_device(svc_name, device_id, tech_type);
break;
}
- case UAM_REQUEST_SET_DEVICE_DISCRIMINANT: {
+ case UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT: {
const char *svc_name;
const char *device_id;
int tech_type;
tech_type, discriminant);
break;
}
- case UAM_REQUEST_GET_DEVICE_DISCRIMINANT: {
+ case UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT: {
const char *svc_name;
const char *device_id;
int tech_type;
svc_name, device_id, tech_type, discriminant);
break;
}
+ case UAM_REQUEST_GET_DEVICE_SERVICES_LAST_SEEN: {
+ const char *svc_name;
+ const char *device_id;
+ int tech_type;
+ unsigned long long last_seen;
+
+ svc_name = (char *)g_variant_get_data(in_param1);
+ device_id = (char *)g_variant_get_data(in_param2);
+ __uam_manager_copy_params(in_param3, &tech_type, sizeof(int));
+ result = _uam_core_service_get_device_last_seen(svc_name, device_id,
+ tech_type, &last_seen);
+ if (UAM_ERROR_NONE == result)
+ g_array_append_vals(*out_param1, &last_seen, sizeof(unsigned long long));
+
+ UAM_DBG("Service: [%s] device_id: [%s], tech_type: %d, last_seen: %llu",
+ svc_name, device_id, tech_type, last_seen);
+ break;
+ }
case UAM_REQUEST_SET_SERVICE_DETECTION_CYCLE: {
const char *svc_name;
unsigned int cycle;
case UAM_REQUEST_REMOVE_USER_FROM_SERVICE:
case UAM_REQUEST_ADD_DEVICE_TO_SERVICE:
case UAM_REQUEST_REMOVE_DEVICE_FROM_SERVICE:
- case UAM_REQUEST_SET_DEVICE_DISCRIMINANT:
- case UAM_REQUEST_GET_DEVICE_DISCRIMINANT:
+ case UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT:
+ case UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT:
case UAM_REQUEST_SET_SERVICE_DETECTION_CYCLE:
case UAM_REQUEST_GET_SERVICE_DETECTION_CYCLE:
case UAM_REQUEST_GET_DETECTION_WINDOW:
sql_ret = sqlite3_step(stmt);
if (sql_ret != SQLITE_DONE) {
- UAM_ERR("Failed to update service timestamp [%d:%s]",
+ UAM_ERR("Failed to update service cycle [%d:%s]",
sql_ret, sqlite3_errmsg(database_handle));
error_code = UAM_ERROR_DB_FAILED;
/* Sensor information structure */
typedef struct {
unsigned int status; /**< Sensor status */
- unsigned long long timestamp; /**< Timestamp */
+ unsigned long long last_seen; /**< Last seen time */
int accuracy; /**< Accuracy */
int count; /**< How many sensor data are there */
double *values; /**< Sensor data */
projects / platform / core / connectivity / ua-manager.git / commitdiff