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_uas_device_info_free(uas_device_info_t *device)
 135 {
 136         FUNC_ENTRY;
 137         int i;
 138
 139         g_free(device->device_id);
 140
 141         for (i = 0; i < device->num_addr; i++)
 142                 g_free(device->addr_list[i].address);
 143
 144         g_free(device->addr_list);
 145
 146         if (device->payload) {
 147                 g_free(device->payload->duid);
 148                 g_free(device->payload);
 149         }
 150
 151         g_free(device);
 152
 153         FUNC_EXIT;
 154 }
 155
 156 void _pm_util_uam_db_dev_to_uas_dev(unsigned int tech_type,
 157                 uam_db_device_info_t *dev, uas_device_info_t **device)
 158 {
 159         FUNC_ENTRY;
 160         int i = 0;
 161         GSList *l;
 162
 163         ret_if(NULL == dev);
 164         ret_if(NULL == dev->user);
 165         ret_if(NULL == dev->tech_list);
 166         ret_if(NULL == device);
 167
 168         if (NULL == *device)
 169                 *device = g_new0(uas_device_info_t, 1);
 170         else
 171                 memset(*device, 0x00, sizeof(uas_device_info_t));
 172
 173         (*device)->user_id = dev->user->user_id;
 174         (*device)->os = dev->os;
 175         (*device)->device_id = g_strdup(dev->device_id);
 176
 177         for (l = dev->tech_list; NULL != l; l = g_slist_next(l)) {
 178                 uam_db_tech_info_t *tech = l->data;
 179                 GSList *l1;
 180
 181                 if (!tech || !tech->addresses)
 182                         continue;
 183
 184                 if (tech_type != tech->tech_type)
 185                         continue;
 186
 187                 (*device)->discriminant = tech->discriminant;
 188                 (*device)->num_addr = g_slist_length(tech->addresses);
 189                 (*device)->addr_list = g_new0(uas_address_info_t, (*device)->num_addr);
 190                 for (l1 = tech->addresses; NULL != l1; l1 = g_slist_next(l1)) {
 191                         uam_db_address_info_t *addr = l1->data;
 192
 193                         if (!addr)
 194                                 continue;
 195
 196                         (*device)->addr_list[i].type = _pm_util_uam_addr_type_to_uas_addr_type(addr->addr_type);
 197                         (*device)->addr_list[i++].address = g_strdup(addr->address);
 198                 }
 199                 (*device)->payload = g_new0(uas_ble_payload_t, 1);
 200                 (*device)->payload->service_id = tech->payload->service_id;
 201                 (*device)->payload->purpose = tech->payload->purpose;
 202                 (*device)->payload->device_icon = tech->payload->device_icon;
 203                 (*device)->payload->duid = g_memdup(tech->payload->duid, UAM_BLE_PAYLOAD_DUID_LEN);
 204                 (*device)->payload->bt_mac = g_memdup(tech->payload->bt_mac, UAM_BT_MAC_ADDRESS_STRING_LEN);
 205         }
 206
 207         FUNC_EXIT;
 208 }
 209
 210 uas_device_info_t *_pm_util_uam_dev_info_to_uas_dev_info(const uam_device_info_s *dev)
 211 {
 212         FUNC_ENTRY;
 213         uas_device_info_t *device;
 214         int type = UAS_ADDR_TYPE_INVALID;
 215         char *mac = NULL;
 216         char *ipv4_addr = NULL;
 217         int i = 0;
 218
 219         retv_if(NULL == dev, NULL);
 220
 221         device = g_new0(uas_device_info_t, 1);
 222         retv_if(NULL == device, NULL);
 223
 224         device->os = dev->operating_system;
 225         device->discriminant = dev->discriminant;
 226
 227         if (0 < strlen(dev->mac)) {
 228                 switch (dev->type) {
 229                 case UAM_TECH_TYPE_BLE:
 230                         type = UAS_ADDR_TYPE_BLE;
 231                         break;
 232                 case UAM_TECH_TYPE_BT:
 233                         type = UAS_ADDR_TYPE_BT;
 234                         break;
 235                 case UAM_TECH_TYPE_P2P:
 236                         type = UAS_ADDR_TYPE_P2P;
 237                         break;
 238                 case UAM_TECH_TYPE_WIFI:
 239                         type = UAS_ADDR_TYPE_WIFI;
 240                         break;
 241                 default:
 242                         UAM_ERR("Unknown tech type: %d", dev->type);
 243                 }
 244
 245                 if (UAS_ADDR_TYPE_INVALID != type) {
 246                         mac = g_strdup(dev->mac);
 247                         device->num_addr += 1;
 248                 }
 249         }
 250
 251         if (0 < strlen(dev->ipv4_addr)) {
 252                 ipv4_addr = g_strdup(dev->ipv4_addr);
 253                 device->num_addr += 1;
 254         }
 255
 256         if (0 >= device->num_addr)
 257                 UAM_WARN("device->num_addr = %d", device->num_addr);
 258
 259         device->device_id = g_strdup(dev->device_id);
 260
 261         device->payload = g_new0(uas_ble_payload_t, 1);
 262         device->payload->service_id = dev->payload.service_id;
 263         device->payload->purpose = dev->payload.purpose;
 264         device->payload->device_icon = dev->payload.device_icon;
 265         device->payload->duid = g_memdup(&(dev->payload.duid), UAM_BLE_PAYLOAD_DUID_LEN);
 266         device->payload->bt_mac = g_memdup(&(dev->payload.bt_mac), UAM_BT_MAC_ADDRESS_STRING_LEN);
 267
 268         device->addr_list = g_new0(uas_address_info_t, device->num_addr);
 269         if (mac) {
 270                 device->addr_list[i].type = type;
 271                 device->addr_list[i++].address = mac;
 272         }
 273
 274         if (ipv4_addr) {
 275                 device->addr_list[i].type = UAS_ADDR_TYPE_IPv4;
 276                 device->addr_list[i++].address = ipv4_addr;
 277         }
 278
 279         FUNC_EXIT;
 280         return device;
 281 }
 282
 283 uam_device_info_s *_pm_util_uas_dev_info_to_uam_dev_info(const uas_device_info_t *dev)
 284 {
 285         FUNC_ENTRY;
 286         uam_device_info_s *device;
 287         int i = 0;
 288
 289         retv_if(NULL == dev, NULL);
 290
 291         device = g_new0(uam_device_info_s, 1);
 292         retv_if(NULL == device, NULL);
 293
 294         device->operating_system = dev->os;
 295         device->discriminant = dev->discriminant;
 296         g_strlcpy(device->device_id, dev->device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 297
 298         memset(device->payload.duid, 0, UAM_BLE_PAYLOAD_DUID_LEN + 1);
 299         memset(device->payload.bt_mac, 0, UAM_BT_MAC_ADDRESS_STRING_LEN);
 300         if (dev->payload) {
 301                 device->payload.service_id = dev->payload->service_id;
 302                 device->payload.device_icon = dev->payload->device_icon;
 303                 device->payload.purpose = dev->payload->purpose;
 304                 if (dev->payload->duid)
 305                         memcpy(device->payload.duid, dev->payload->duid, UAM_BLE_PAYLOAD_DUID_LEN);
 306                 if (dev->payload->bt_mac)
 307                         g_strlcpy(device->payload.bt_mac,
 308                         dev->payload->bt_mac, UAM_BT_MAC_ADDRESS_STRING_LEN);
 309         }
 310
 311         for (i = 0; i < dev->num_addr; i++) {
 312                 UAM_DBG("Address[%d]: %s", i, dev->addr_list[i].address);
 313                 switch (dev->addr_list[i].type) {
 314                 case UAS_ADDR_TYPE_BLE:
 315                         device->type = UAM_TECH_TYPE_BLE;
 316                         g_strlcpy(device->mac, dev->addr_list[i].address,
 317                                         UAM_MAC_ADDRESS_STRING_LEN);
 318                         break;
 319                 case UAS_ADDR_TYPE_BT:
 320                         device->type = UAM_TECH_TYPE_BT;
 321                         g_strlcpy(device->mac, dev->addr_list[i].address,
 322                                         UAM_MAC_ADDRESS_STRING_LEN);
 323                         break;
 324                 case UAS_ADDR_TYPE_P2P:
 325                         device->type = UAM_TECH_TYPE_P2P;
 326                         g_strlcpy(device->mac, dev->addr_list[i].address,
 327                                         UAM_MAC_ADDRESS_STRING_LEN);
 328                         break;
 329                 case UAS_ADDR_TYPE_WIFI:
 330                         device->type = UAM_TECH_TYPE_WIFI;
 331                         g_strlcpy(device->mac, dev->addr_list[i].address,
 332                                         UAM_MAC_ADDRESS_STRING_LEN);
 333                         break;
 334                 case UAS_ADDR_TYPE_IPv4:
 335                         g_strlcpy(device->ipv4_addr, dev->addr_list[i].address,
 336                                         UAM_IP_ADDRESS_MAX_STRING_LEN);
 337                         break;
 338                 case UAS_ADDR_TYPE_IPv6:
 339                 default:
 340                         UAM_ERR("Unsupported address type: %d", dev->addr_list[i].type);
 341                 }
 342         }
 343
 344         FUNC_EXIT;
 345         return device;
 346 }
 347
 348 uam_active_scan_event_e _pm_util_uas_scan_event_to_uam_scan_event(uas_active_scan_event_e event)
 349 {
 350         switch (event) {
 351         case UAS_ACTIVE_DEVICE_FOUND:
 352                 return UAM_ACTIVE_DEVICE_FOUND;
 353         case UAS_ACTIVE_SCAN_COMPLETED:
 354                 return UAM_ACTIVE_SCAN_COMPLETED;
 355         default:
 356                 UAM_WARN("Unknown event 0x%8.8X", event);
 357                 return 0;
 358         }
 359 }
 360
 361 uam_sensor_info_s *_pm_util_uas_sensor_info_to_uam_sensor_info(
 362         const uas_sensor_info_t *info)
 363 {
 364         FUNC_ENTRY;
 365         uam_sensor_info_s *sensor_info;
 366         unsigned int i = 0;
 367         retv_if(NULL == info, NULL);
 368
 369         sensor_info = g_new0(uam_sensor_info_s, 1);
 370         retv_if(NULL == sensor_info, NULL);
 371
 372         sensor_info->timestamp = info->timestamp;
 373         sensor_info->accuracy = info->accuracy;
 374         sensor_info->count = info->count;
 375         for (i = 0; i < info->count; i++) {
 376                 sensor_info->values[i] = info->values[i];
 377         }
 378
 379         UAM_INFO("t [%llu] Accuaracy [%d] Count [%d] Lux [%f] CCT [%f] Lv[%f] Cv[%f]",
 380                 sensor_info->timestamp, sensor_info->accuracy, sensor_info->count,
 381                 sensor_info->values[0], sensor_info->values[1], sensor_info->values[2],
 382                 sensor_info->values[3]);
 383
 384         FUNC_EXIT;
 385         return sensor_info;
 386 }