ua-daemon/src/pm/ua-pm-util.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 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <dlfcn.h>
  21
  22 #include "ua-plugin.h"
  23 #include <ua-plugin-manager.h>
  24
  25 static const char *status_string[] = {
  26         FOREACH_STATUS(GENERATE_STATUS_STRING)
  27 };
  28
  29 const char *_pm_util_uas_status_to_str(int status)
  30 {
  31         int arr_size = (sizeof(status_string)/sizeof(char*));
  32         int id = -status;
  33
  34         UAM_DBG("arr_size: %d, id: %d", arr_size, id);
  35         retv_if(arr_size <= id, NULL);
  36
  37         return status_string[id];
  38 }
  39
  40 unsigned int _pm_util_uas_plugin_id_to_sensor_bitmask(uas_plugin_id_e id)
  41 {
  42         switch (id) {
  43         case UAS_PLUGIN_ID_BLE:
  44                 return UAM_SENSOR_BITMASK_BLE;
  45         case UAS_PLUGIN_ID_WIFI:
  46                 return UAM_SENSOR_BITMASK_WIFI;
  47         case UAS_PLUGIN_ID_LIGHT:
  48                 return UAM_SENSOR_BITMASK_LIGHT;
  49         case UAS_PLUGIN_ID_MOTION:
  50                 return UAM_SENSOR_BITMASK_MOTION;
  51         default:
  52                 UAM_WARN("Unknown Plugin id 0x%8.8X", id);
  53                 return 0;
  54         }
  55 }
  56
  57 unsigned int _pm_util_uam_tech_type_to_plugin_id(uam_tech_type_e type)
  58 {
  59         switch (type) {
  60         case UAM_TECH_TYPE_BLE:
  61                 return UAS_PLUGIN_ID_BLE;
  62         case UAM_TECH_TYPE_WIFI:
  63                 return UAS_PLUGIN_ID_WIFI;
  64         default:
  65                 UAM_WARN("Unknown type 0x%8.8X", type);
  66                 return UAS_PLUGIN_ID_MAX;
  67         }
  68 }
  69
  70 unsigned int _pm_util_uas_plugin_id_to_tech_type(uas_plugin_id_e id)
  71 {
  72         switch (id) {
  73         case UAS_PLUGIN_ID_BLE:
  74                 return UAM_TECH_TYPE_BLE;
  75         case UAS_PLUGIN_ID_WIFI:
  76                 return UAM_TECH_TYPE_WIFI;
  77         default:
  78                 UAM_WARN("Unknown Plugin id 0x%8.8X", id);
  79                 return UAM_TECH_TYPE_NONE;
  80         }
  81 }
  82
  83 int _pm_util_sensor_bitmask_to_plugin_id(unsigned int bitmask)
  84 {
  85         switch (bitmask) {
  86         case UAM_SENSOR_BITMASK_BLE:
  87                 return UAS_PLUGIN_ID_BLE;
  88         case UAM_SENSOR_BITMASK_WIFI:
  89                 return UAS_PLUGIN_ID_WIFI;
  90         case UAM_SENSOR_BITMASK_LIGHT:
  91                 return UAS_PLUGIN_ID_LIGHT;
  92         case UAM_SENSOR_BITMASK_MOTION:
  93                 return UAS_PLUGIN_ID_MOTION;
  94         default:
  95                 UAM_WARN("Unknown sensor 0x%8.8X", bitmask);
  96                 return UAS_PLUGIN_ID_MAX;
  97         }
  98 }
  99
 100 int _pm_util_sensor_bitmask_to_technology_type(unsigned int bitmask)
 101 {
 102         switch (bitmask) {
 103         case UAM_SENSOR_BITMASK_BLE:
 104                 return UAM_TECH_TYPE_BLE;
 105         case UAM_SENSOR_BITMASK_WIFI:
 106                 return UAM_TECH_TYPE_WIFI;
 107         default:
 108                 UAM_WARN("Unknown sensor 0x%8.8X", bitmask);
 109                 return UAM_TECH_TYPE_NONE;
 110         }
 111 }
 112
 113 uas_address_type_e _pm_util_uam_addr_type_to_uas_addr_type(uam_addr_type_e type)
 114 {
 115         switch (type) {
 116         case UAM_ADDR_TYPE_BT:
 117                 return UAS_ADDR_TYPE_BT;
 118         case UAM_ADDR_TYPE_BLE:
 119                 return UAS_ADDR_TYPE_BLE;
 120         case UAM_ADDR_TYPE_WIFI:
 121                 return UAS_ADDR_TYPE_WIFI;
 122         case UAM_ADDR_TYPE_P2P:
 123                 return UAS_ADDR_TYPE_P2P;
 124         case UAM_ADDR_TYPE_IPv4:
 125                 return UAS_ADDR_TYPE_IPv4;
 126         case UAM_ADDR_TYPE_IPv6:
 127                 return UAS_ADDR_TYPE_IPv6;
 128         default:
 129                 UAM_ERR("Unknown address type: %d", type);
 130                 return UAS_ADDR_TYPE_INVALID;
 131         }
 132 }
 133
 134 void _pm_util_uam_db_payload_to_uas_payload(
 135                 uas_payload_info_t *dst_payload, uam_db_payload_info_t *src_payload)
 136 {
 137         if (src_payload) {
 138                 dst_payload->primary_key = src_payload->primary_key;
 139                 dst_payload->device_icon = src_payload->device_icon;
 140                 dst_payload->secondary_key = src_payload->secondary_key;
 141                 dst_payload->device_uid = g_memdup(&(src_payload->device_uid),
 142                                                 UAM_BLE_PAYLOAD_DEVICE_UID_LEN);
 143                 dst_payload->bt_mac = g_memdup(&(src_payload->bt_mac),
 144                                                 UAM_BT_MAC_ADDRESS_STRING_LEN);
 145         }
 146         UAM_DBG("payload primary key: [%d]", dst_payload->primary_key);
 147 }
 148
 149 void _pm_util_uas_device_info_free(uas_device_info_t *device)
 150 {
 151         FUNC_ENTRY;
 152         int i;
 153
 154         g_free(device->device_id);
 155
 156         for (i = 0; i < device->num_addr; i++)
 157                 g_free(device->addr_list[i].address);
 158
 159         g_free(device->addr_list);
 160         g_free(device);
 161
 162         FUNC_EXIT;
 163 }
 164
 165 void _pm_util_uam_db_dev_to_uas_dev(unsigned int tech_type,
 166                 uam_db_device_info_t *dev, uas_device_info_t **device)
 167 {
 168         FUNC_ENTRY;
 169         int i = 0;
 170         GSList *l;
 171         int len = 0;
 172
 173         ret_if(NULL == dev);
 174         ret_if(NULL == dev->user);
 175         ret_if(NULL == dev->tech_list);
 176         ret_if(NULL == device);
 177
 178         if (NULL == *device)
 179                 *device = g_new0(uas_device_info_t, 1);
 180         else
 181                 memset(*device, 0x00, sizeof(uas_device_info_t));
 182
 183         (*device)->user_id = dev->user->user_id;
 184         (*device)->os = dev->os;
 185         (*device)->device_id = g_strdup(dev->device_id);
 186
 187         for (l = dev->tech_list; NULL != l; l = g_slist_next(l)) {
 188                 uam_db_tech_info_t *tech = l->data;
 189                 GSList *l1;
 190
 191                 if (!tech || !tech->addresses)
 192                         continue;
 193
 194                 if (tech_type != tech->tech_type)
 195                         continue;
 196
 197                 (*device)->discriminant = tech->discriminant;
 198                 (*device)->num_addr = g_slist_length(tech->addresses);
 199                 (*device)->addr_list = g_new0(uas_address_info_t, (*device)->num_addr);
 200                 for (l1 = tech->addresses; NULL != l1; l1 = g_slist_next(l1)) {
 201                         uam_db_address_info_t *addr = l1->data;
 202
 203                         if (!addr)
 204                                 continue;
 205
 206                         (*device)->addr_list[i].type = _pm_util_uam_addr_type_to_uas_addr_type(addr->addr_type);
 207                         (*device)->addr_list[i++].address = g_strdup(addr->address);
 208                 }
 209
 210                 /** update payload list */
 211                 len = g_slist_length(tech->svc_dev_list);
 212                 (*device)->num_payload = len;
 213                 (*device)->payload = g_new0(uas_payload_info_t, len);
 214                 for (l1 = tech->svc_dev_list; NULL != l1; l1 = g_slist_next(l1)) {
 215                         uam_svc_dev_info_t *svc_dev = l1->data;
 216                         uam_db_payload_info_t *payload = svc_dev->payload;
 217
 218                         if (!payload)
 219                                 continue;
 220
 221                         _pm_util_uam_db_payload_to_uas_payload(&(*device)->payload[i], payload);
 222                 }
 223         }
 224
 225         FUNC_EXIT;
 226 }
 227
 228 uas_device_info_t *_pm_util_uam_dev_info_to_uas_dev_info(const uam_device_info_s *dev)
 229 {
 230         FUNC_ENTRY;
 231         uas_device_info_t *device;
 232         int type = UAS_ADDR_TYPE_INVALID;
 233         char *mac = NULL;
 234         char *ipv4_addr = NULL;
 235         int i = 0;
 236
 237         retv_if(NULL == dev, NULL);
 238
 239         device = g_new0(uas_device_info_t, 1);
 240         retv_if(NULL == device, NULL);
 241
 242         device->os = dev->operating_system;
 243         device->discriminant = dev->discriminant;
 244
 245         if (0 < strlen(dev->mac)) {
 246                 switch (dev->type) {
 247                 case UAM_TECH_TYPE_BLE:
 248                         type = UAS_ADDR_TYPE_BLE;
 249                         break;
 250                 case UAM_TECH_TYPE_BT:
 251                         type = UAS_ADDR_TYPE_BT;
 252                         break;
 253                 case UAM_TECH_TYPE_P2P:
 254                         type = UAS_ADDR_TYPE_P2P;
 255                         break;
 256                 case UAM_TECH_TYPE_WIFI:
 257                         type = UAS_ADDR_TYPE_WIFI;
 258                         break;
 259                 default:
 260                         UAM_ERR("Unknown tech type: %d", dev->type);
 261                 }
 262
 263                 if (UAS_ADDR_TYPE_INVALID != type) {
 264                         mac = g_strdup(dev->mac);
 265                         device->num_addr += 1;
 266                 }
 267         }
 268
 269         if (0 < strlen(dev->ipv4_addr)) {
 270                 ipv4_addr = g_strdup(dev->ipv4_addr);
 271                 device->num_addr += 1;
 272         }
 273
 274         if (0 >= device->num_addr)
 275                 UAM_WARN("device->num_addr = %d", device->num_addr);
 276
 277         device->device_id = g_strdup(dev->device_id);
 278
 279         device->addr_list = g_new0(uas_address_info_t, device->num_addr);
 280         if (mac) {
 281                 device->addr_list[i].type = type;
 282                 device->addr_list[i++].address = mac;
 283         }
 284
 285         if (ipv4_addr) {
 286                 device->addr_list[i].type = UAS_ADDR_TYPE_IPv4;
 287                 device->addr_list[i++].address = ipv4_addr;
 288         }
 289
 290         device->payload = NULL;
 291
 292         FUNC_EXIT;
 293         return device;
 294 }
 295
 296 uam_device_info_s *_pm_util_uas_dev_info_to_uam_dev_info(const uas_device_info_t *dev)
 297 {
 298         FUNC_ENTRY;
 299         uam_device_info_s *device;
 300         int i = 0;
 301
 302         retv_if(NULL == dev, NULL);
 303
 304         device = g_new0(uam_device_info_s, 1);
 305         retv_if(NULL == device, NULL);
 306
 307         device->operating_system = dev->os;
 308         device->discriminant = dev->discriminant;
 309         device->last_seen = dev->last_seen;
 310         g_strlcpy(device->device_id, dev->device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 311
 312         for (i = 0; i < dev->num_addr; i++) {
 313                 UAM_DBG("Address[%d]: %s", i, dev->addr_list[i].address);
 314                 switch (dev->addr_list[i].type) {
 315                 case UAS_ADDR_TYPE_BLE:
 316                         device->type = UAM_TECH_TYPE_BLE;
 317                         g_strlcpy(device->mac, dev->addr_list[i].address,
 318                                         UAM_MAC_ADDRESS_STRING_LEN);
 319                         break;
 320                 case UAS_ADDR_TYPE_BT:
 321                         device->type = UAM_TECH_TYPE_BT;
 322                         g_strlcpy(device->mac, dev->addr_list[i].address,
 323                                         UAM_MAC_ADDRESS_STRING_LEN);
 324                         break;
 325                 case UAS_ADDR_TYPE_P2P:
 326                         device->type = UAM_TECH_TYPE_P2P;
 327                         g_strlcpy(device->mac, dev->addr_list[i].address,
 328                                         UAM_MAC_ADDRESS_STRING_LEN);
 329                         break;
 330                 case UAS_ADDR_TYPE_WIFI:
 331                         device->type = UAM_TECH_TYPE_WIFI;
 332                         g_strlcpy(device->mac, dev->addr_list[i].address,
 333                                         UAM_MAC_ADDRESS_STRING_LEN);
 334                         break;
 335                 case UAS_ADDR_TYPE_IPv4:
 336                         g_strlcpy(device->ipv4_addr, dev->addr_list[i].address,
 337                                         UAM_IP_ADDRESS_MAX_STRING_LEN);
 338                         break;
 339                 case UAS_ADDR_TYPE_IPv6:
 340                 default:
 341                         UAM_ERR("Unsupported address type: %d", dev->addr_list[i].type);
 342                 }
 343         }
 344
 345         FUNC_EXIT;
 346         return device;
 347 }
 348
 349 uam_active_scan_event_e _pm_util_uas_scan_event_to_uam_scan_event(uas_active_scan_event_e event)
 350 {
 351         switch (event) {
 352         case UAS_ACTIVE_DEVICE_FOUND:
 353                 return UAM_ACTIVE_DEVICE_FOUND;
 354         case UAS_ACTIVE_SCAN_COMPLETED:
 355                 return UAM_ACTIVE_SCAN_COMPLETED;
 356         default:
 357                 UAM_WARN("Unknown event 0x%8.8X", event);
 358                 return 0;
 359         }
 360 }
 361
 362 uam_sensor_info_s *_pm_util_uas_sensor_info_to_uam_sensor_info(
 363         const uas_sensor_info_t *info)
 364 {
 365         FUNC_ENTRY;
 366         uam_sensor_info_s *sensor_info;
 367         unsigned int i = 0;
 368         retv_if(NULL == info, NULL);
 369
 370         sensor_info = g_new0(uam_sensor_info_s, 1);
 371         retv_if(NULL == sensor_info, NULL);
 372
 373         sensor_info->status = info->status;
 374         sensor_info->timestamp = info->timestamp;
 375         sensor_info->accuracy = info->accuracy;
 376         sensor_info->count = info->count;
 377         for (i = 0; i < info->count; i++) {
 378                 sensor_info->values[i] = info->values[i];
 379         }
 380
 381         UAM_INFO("t [%llu] Accuaracy [%d] Count [%d] Lux [%f] CCT [%f] Lv[%f] Cv[%f]",
 382                 sensor_info->timestamp, sensor_info->accuracy, sensor_info->count,
 383                 sensor_info->values[0], sensor_info->values[1], sensor_info->values[2],
 384                 sensor_info->values[3]);
 385
 386         FUNC_EXIT;
 387         return sensor_info;
 388 }