ua-api/src/ua-event-handler.c

   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 #include "ua-api.h"
  19 #include "ua-internal.h"
  20 #include "ua-common.h"
  21
  22 typedef struct {
  23         guint id;
  24         void *cb;
  25         void *user_data;
  26 } uam_event_handler_data_t;
  27
  28 static gboolean is_registered = FALSE;
  29 static uam_event_handler_data_t *event_handler_data = NULL;
  30
  31 static void __uam_copy_sensor_data(uam_sensor_info_s *sensor_info, int status,
  32         unsigned int bitmask, unsigned long long timestamp, int accuracy, int count, double *values)
  33 {
  34         FUNC_ENTRY;
  35
  36         ret_if(NULL == sensor_info);
  37
  38         memset(sensor_info, 0, sizeof(uam_sensor_info_s));
  39         sensor_info->status = status;
  40         sensor_info->sensor_bitmask = bitmask;
  41         sensor_info->timestamp = timestamp;
  42         sensor_info->accuracy = accuracy;
  43         sensor_info->count = count;
  44         for (int i = 0; i < UAM_SENSOR_MAX_VALUES; i++) {
  45                 sensor_info->values[i] = values[i];
  46         }
  47
  48         UAM_INFO("status [%d] sensor bitmask [%u] timestamp [%llu] accuracy [%d]" \
  49                 "count [%d] value0 [%f] value1 [%f] value2 [%f] value3 [%f]",
  50                 sensor_info->status, sensor_info->sensor_bitmask, sensor_info->timestamp,
  51                 sensor_info->accuracy, sensor_info->count, sensor_info->values[0],
  52                 sensor_info->values[1], sensor_info->values[2], sensor_info->values[3]);
  53
  54         FUNC_EXIT;
  55 }
  56
  57 static void __uam_send_event(int event, int result,
  58                 void *data, void *callback, void *user_data)
  59 {
  60         FUNC_ENTRY;
  61         uam_event_data_s event_data;
  62
  63         UAM_INFO("Event: %s [0x%4.4X], result= %s [0x%4.4X]",
  64                         _uam_event_to_str(event), event,
  65                         _uam_error_to_str(result), result);
  66
  67         ret_if(NULL == callback);
  68
  69         memset(&event_data, 0x00, sizeof(uam_event_data_s));
  70         event_data.result = result;
  71         event_data.data = data;
  72
  73         ((uam_event_cb)callback)(event, &event_data, user_data);
  74
  75         FUNC_EXIT;
  76 }
  77
  78 static void __uam_event_handler(GDBusConnection *connection,
  79                 const gchar *sender_name,
  80                 const gchar *object_path,
  81                 const gchar *interface_name,
  82                 const gchar *signal_name,
  83                 GVariant *parameters,
  84                 gpointer user_data)
  85 {
  86         FUNC_ENTRY;
  87         int result = UAM_ERROR_NONE;
  88         int event = -1;
  89
  90         uam_event_handler_data_t *event_info = user_data;
  91
  92         ret_if(NULL == event_info);
  93
  94         if (0 != strcasecmp(object_path, UAM_EVENT_PATH))
  95                 return;
  96
  97         if (0 != strcasecmp(interface_name, UAM_EVENT_INTERFACE))
  98                 return;
  99
 100         if (0 == strcasecmp(signal_name, UAM_SIGNAL_USER_PRESENCE_DETECTED)) {
 101                 uam_detection_event_data_s event_data;
 102                 unsigned int sensor_bitmask;
 103                 const char *account = NULL;
 104                 const char *service = NULL;
 105                 const char *device_id = NULL;
 106                 unsigned long long timestamp;
 107
 108                 g_variant_get(parameters, "(u&s&s&st)", &sensor_bitmask, &account,
 109                               &service, &device_id, &timestamp);
 110
 111                 UAM_DBG("Sensor: 0x%8.8X, User: %s, Device: %s", sensor_bitmask,
 112                         account, device_id);
 113                 event = UAM_EVENT_USER_PRESENCE_DETECTED;
 114                 event_data.sensor_bitmask = sensor_bitmask;
 115                 g_strlcpy(event_data.account, account,
 116                                 UAM_USER_ACCOUNT_MAX_STRING_LEN);
 117                 g_strlcpy(event_data.service, service, UAM_SERVICE_MAX_STRING_LEN);
 118                 event_data.timestamp = timestamp;
 119                 g_strlcpy(event_data.device_id, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 120
 121                 __uam_send_event(event, result, &event_data,
 122                                 event_info->cb, event_info->user_data);
 123         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_USER_ABSENCE_DETECTED)) {
 124                 uam_detection_event_data_s event_data;
 125                 unsigned int sensor_bitmask;
 126                 char *account = NULL;
 127                 char *service = NULL;
 128                 unsigned long long timestamp;
 129
 130                 g_variant_get(parameters, "(u&s&st)", &sensor_bitmask, &account,
 131                               &service, &timestamp);
 132
 133                 UAM_DBG("Sensor: 0x%8.8X, User: %s", sensor_bitmask, account);
 134                 event = UAM_EVENT_USER_ABSENCE_DETECTED;
 135                 event_data.sensor_bitmask = sensor_bitmask;
 136                 g_strlcpy(event_data.account, account,
 137                                 UAM_USER_ACCOUNT_MAX_STRING_LEN);
 138                 g_strlcpy(event_data.service, service, UAM_SERVICE_MAX_STRING_LEN);
 139                 event_data.timestamp = timestamp;
 140
 141                 __uam_send_event(event, result, &event_data,
 142                                 event_info->cb, event_info->user_data);
 143         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_PRESENCE_DETECTED)) {
 144                 uam_sensor_info_s sensor_info;
 145                 unsigned int sensor_bitmask;
 146                 unsigned long long timestamp;
 147                 int accuracy, count;
 148                 double values[UAM_SENSOR_MAX_VALUES];
 149
 150                 g_variant_get(parameters, "(utiidddd)", &sensor_bitmask, &timestamp,
 151                                                 &accuracy, &count, &values[0], &values[1],
 152                                                 &values[2], &values[3]);
 153
 154                 __uam_copy_sensor_data(&sensor_info, 0, sensor_bitmask, timestamp,
 155                                         accuracy, count, values);
 156
 157                 event = UAM_EVENT_PRESENCE_DETECTED;
 158
 159                 __uam_send_event(event, result, &sensor_info,
 160                                 event_info->cb, event_info->user_data);
 161         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_ABSENCE_DETECTED)) {
 162                 uam_sensor_info_s sensor_info;
 163                 unsigned int sensor_bitmask;
 164                 unsigned long long timestamp;
 165                 int accuracy, count;
 166                 double values[UAM_SENSOR_MAX_VALUES];
 167
 168                 g_variant_get(parameters, "(utiidddd)", &sensor_bitmask, &timestamp,
 169                                                 &accuracy, &count, &values[0], &values[1],
 170                                                 &values[2], &values[3]);
 171
 172                 __uam_copy_sensor_data(&sensor_info, 0, sensor_bitmask, timestamp,
 173                                         accuracy, count, values);
 174
 175                 event = UAM_EVENT_ABSENCE_DETECTED;
 176
 177                 __uam_send_event(event, result, &sensor_info,
 178                                 event_info->cb, event_info->user_data);
 179         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_SENSOR_STATE_READY)) {
 180                 unsigned int sensor;
 181
 182                 g_variant_get(parameters, "(iu)", &result,
 183                                 &sensor);
 184
 185                 event = UAM_EVENT_SENSOR_STATE_READY;
 186                 __uam_send_event(event, result, &sensor,
 187                                 event_info->cb, event_info->user_data);
 188         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_SENSOR_STATE_NOT_READY)) {
 189                 unsigned int sensor;
 190
 191                 g_variant_get(parameters, "(iu)", &result,
 192                                 &sensor);
 193
 194                 event = UAM_EVENT_SENSOR_STATE_NOT_READY;
 195                 __uam_send_event(event, result, &sensor,
 196                                 event_info->cb, event_info->user_data);
 197         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_USER_ADDED)) {
 198                 uam_user_info_s user_info;
 199                 char *account = NULL;
 200                 char *name = NULL;
 201
 202                 memset(&user_info, 0, sizeof(uam_user_info_s));
 203                 g_variant_get(parameters, "(i&s&s)", &result,
 204                                 &account, &name);
 205
 206                 g_strlcpy(user_info.account,
 207                                 account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 208                 g_strlcpy(user_info.name,
 209                                 name, UAM_USER_NAME_MAX_STRING_LEN);
 210
 211                 event = UAM_EVENT_USER_ADDED;
 212                 __uam_send_event(event, result, &user_info,
 213                                 event_info->cb, event_info->user_data);
 214         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_USER_REMOVED)) {
 215                 uam_user_info_s user_info;
 216                 char *account = NULL;
 217                 char *name = NULL;
 218
 219                 memset(&user_info, 0, sizeof(uam_user_info_s));
 220                 g_variant_get(parameters, "(i&s&s)", &result,
 221                                 &account, &name);
 222
 223                 g_strlcpy(user_info.account,
 224                                 account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 225                 g_strlcpy(user_info.name,
 226                                 name, UAM_USER_NAME_MAX_STRING_LEN);
 227
 228                 event = UAM_EVENT_USER_REMOVED;
 229                 __uam_send_event(event, result, &user_info,
 230                                 event_info->cb, event_info->user_data);
 231         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_DEVICE_ADDED)) {
 232                 uam_device_info_s dev_info;
 233                 int os, type;
 234                 char *mac = NULL;
 235                 char *ipv4_addr = NULL;
 236                 char *device_id = NULL;
 237
 238                 g_variant_get(parameters, "(iii&s&s&s)", &result,
 239                                 &os, &type, &mac, &ipv4_addr, &device_id);
 240
 241                 dev_info.operating_system = os;
 242                 dev_info.type = type;
 243                 g_strlcpy(dev_info.mac,
 244                                 mac, UAM_MAC_ADDRESS_STRING_LEN);
 245                 g_strlcpy(dev_info.ipv4_addr,
 246                                 ipv4_addr, UAM_IP_ADDRESS_MAX_STRING_LEN);
 247                 g_strlcpy(dev_info.device_id,
 248                                 device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 249
 250                 event = UAM_EVENT_DEVICE_ADDED;
 251                 __uam_send_event(event, result, &dev_info,
 252                                 event_info->cb, event_info->user_data);
 253         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_DEVICE_REMOVED)) {
 254                 uam_device_info_s dev_info;
 255                 int os, type;
 256                 char *mac = NULL;
 257                 char *ipv4_addr = NULL;
 258                 char *device_id = NULL;
 259
 260                 g_variant_get(parameters, "(iii&s&s&s)", &result,
 261                                 &os, &type, &mac, &ipv4_addr, &device_id);
 262
 263                 dev_info.operating_system = os;
 264                 dev_info.type = type;
 265                 g_strlcpy(dev_info.mac,
 266                                 mac, UAM_MAC_ADDRESS_STRING_LEN);
 267                 g_strlcpy(dev_info.ipv4_addr,
 268                                 ipv4_addr, UAM_IP_ADDRESS_MAX_STRING_LEN);
 269                 g_strlcpy(dev_info.device_id,
 270                                 device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 271
 272                 event = UAM_EVENT_DEVICE_REMOVED;
 273                 __uam_send_event(event, result, &dev_info,
 274                                 event_info->cb, event_info->user_data);
 275         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_DETECTION_STARTED)) {
 276                 __uam_send_event(UAM_EVENT_DETECTION_STARTED, result, NULL,
 277                                 event_info->cb, event_info->user_data);
 278         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_DETECTION_STOPPED)) {
 279                 __uam_send_event(UAM_EVENT_DETECTION_STOPPED, result, NULL,
 280                                 event_info->cb, event_info->user_data);
 281         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_DEVICE_FOUND)) {
 282                 uam_device_info_s dev_info;
 283                 int os, type;
 284                 char *mac = NULL;
 285                 char *ipv4_addr = NULL;
 286                 char *device_id = NULL;
 287
 288                 g_variant_get(parameters, "(iii&s&s&s)", &result,
 289                                 &os, &type, &mac, &ipv4_addr, &device_id);
 290
 291                 dev_info.operating_system = os;
 292                 dev_info.type = type;
 293                 g_strlcpy(dev_info.mac,
 294                                 mac, UAM_MAC_ADDRESS_STRING_LEN);
 295                 g_strlcpy(dev_info.ipv4_addr,
 296                                 ipv4_addr, UAM_IP_ADDRESS_MAX_STRING_LEN);
 297                 g_strlcpy(dev_info.device_id,
 298                                 device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 299
 300                 event = UAM_EVENT_DEVICE_FOUND;
 301                 __uam_send_event(event, result, &dev_info,
 302                                 event_info->cb, event_info->user_data);
 303         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_SCAN_COMPLETED)) {
 304
 305                 event = UAM_EVENT_SCAN_COMPLETED;
 306                 __uam_send_event(event, result, NULL,
 307                                 event_info->cb, event_info->user_data);
 308         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_SERVICE_REGISTERED)) {
 309                 uam_service_info_s svc_info;
 310                 char *name = NULL;
 311
 312                 memset(&svc_info, 0, sizeof(uam_service_info_s));
 313                 g_variant_get(parameters, "(i&s)", &result, &name);
 314
 315                 g_strlcpy(svc_info.name,
 316                                 name, UAM_SERVICE_MAX_STRING_LEN);
 317
 318                 event = UAM_EVENT_SERVICE_REGISTERED;
 319                 __uam_send_event(event, result, &svc_info,
 320                                 event_info->cb, event_info->user_data);
 321         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_SERVICE_UNREGISTERED)) {
 322                 uam_service_info_s svc_info;
 323                 char *name = NULL;
 324
 325                 memset(&svc_info, 0, sizeof(uam_service_info_s));
 326                 g_variant_get(parameters, "(i&s)", &result, &name);
 327
 328                 g_strlcpy(svc_info.name,
 329                                 name, UAM_SERVICE_MAX_STRING_LEN);
 330
 331                 event = UAM_EVENT_SERVICE_UNREGISTERED;
 332                 __uam_send_event(event, result, &svc_info,
 333                                 event_info->cb, event_info->user_data);
 334         } else if (0 == strcasecmp(signal_name, UAM_SIGNAL_SENSOR_STATUS_CHANGED)) {
 335                 uam_sensor_info_s sensor_info;
 336                 unsigned int sensor_bitmask;
 337                 unsigned long long timestamp;
 338                 int status, accuracy, count;
 339                 double values[UAM_SENSOR_MAX_VALUES];
 340
 341                 g_variant_get(parameters, "(uutiidddd)", &status, &sensor_bitmask, &timestamp,
 342                                                 &accuracy, &count, &values[0], &values[1],&values[2], &values[3]);
 343
 344                 __uam_copy_sensor_data(&sensor_info, status, sensor_bitmask, timestamp,
 345                                         accuracy, count, values);
 346
 347                 event = UAM_EVENT_SENSOR_STATUS_CHANGED;
 348
 349                 __uam_send_event(event, result, &sensor_info,
 350                         event_info->cb, event_info->user_data);
 351         } else {
 352                 UAM_WARN("Unknown signal received: %s", signal_name);
 353         }
 354
 355         FUNC_EXIT;
 356 }
 357
 358 int _uam_register_event_handler(uam_event_cb event_cb, void *user_data)
 359 {
 360         FUNC_ENTRY;
 361         GDBusConnection *conn;
 362         const char *path = UAM_EVENT_PATH;
 363         const char *interface = UAM_EVENT_INTERFACE;
 364         GDBusSignalCallback event_func = __uam_event_handler;
 365
 366         retv_if(TRUE == is_registered, UAM_ERROR_ALREADY_REGISTERED);
 367
 368         conn = _uam_get_gdbuam_conn();
 369         retv_if(NULL == conn, UAM_ERROR_INTERNAL);
 370
 371         event_handler_data = g_malloc0(sizeof(uam_event_handler_data_t));
 372         if (event_handler_data) {
 373                 event_handler_data->cb = event_cb;
 374                 event_handler_data->user_data = user_data;
 375                 event_handler_data->id = g_dbus_connection_signal_subscribe(conn,
 376                 NULL, interface, NULL, path, NULL, 0,
 377                 event_func, event_handler_data, NULL);
 378         } else {
 379                 UAM_ERR("Memory allocation error");
 380                 return UAM_ERROR_OUT_OF_MEMORY;
 381         }
 382
 383         is_registered = TRUE;
 384
 385         FUNC_EXIT;
 386         return UAM_ERROR_NONE;
 387 }
 388
 389 int _uam_unregister_event_handler(void)
 390 {
 391         FUNC_ENTRY;
 392         GDBusConnection *conn;
 393
 394         retv_if(FALSE == is_registered, UAM_ERROR_NOT_REGISTERED);
 395         is_registered = FALSE;
 396
 397         retv_if(NULL == event_handler_data, UAM_ERROR_INTERNAL);
 398
 399         conn = _uam_get_gdbuam_conn();
 400         retv_if(NULL == conn, UAM_ERROR_INTERNAL);
 401
 402         g_dbus_connection_signal_unsubscribe(conn, event_handler_data->id);
 403         memset(event_handler_data, 0, sizeof(uam_event_handler_data_t));
 404         g_free(event_handler_data);
 405         event_handler_data = NULL;
 406
 407         FUNC_EXIT;
 408         return UAM_ERROR_NONE;
 409 }