src/libraries/bt-util.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.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://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing,
  11  * software 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 <bluetooth.h>
  18 #include <vconf.h>
  19 #include <aul.h>
  20
  21 #include "bt-main-ug.h"
  22 #include "bt-util.h"
  23 #include "bt-debug.h"
  24 #include "bt-string-define.h"
  25 #include "bt-net-connection.h"
  26
  27 /**********************************************************************
  28 *                                                Common Functions
  29 ***********************************************************************/
  30
  31 gboolean _bt_util_get_service_mask_from_uuid_list(char **uuids,
  32                                       int no_of_service,
  33                                       bt_service_class_t *service_mask_list)
  34 {
  35         FN_START;
  36
  37         int i = 0;
  38         unsigned int service = 0;
  39         char **parts = NULL;
  40         bt_service_class_t service_mask = 0;
  41
  42         retvm_if(uuids == NULL, FALSE,
  43                  "Invalid argument: service_list_array is NULL\n");
  44
  45         BT_DBG("no_of_service = %d\n", no_of_service);
  46
  47         for (i = 0; i < no_of_service; i++) {
  48                 parts = g_strsplit(uuids[i], "-", -1);
  49
  50                 if (parts == NULL || parts[0] == NULL) {
  51                         g_strfreev(parts);
  52                         continue;
  53                 }
  54
  55                 service = g_ascii_strtoull(parts[0], NULL, 16);
  56                 g_strfreev(parts);
  57
  58                 switch (service) {
  59                 case BT_SPP_PROFILE_UUID:
  60                         service_mask |= BT_SC_SPP_SERVICE_MASK;
  61                         break;
  62
  63                 case BT_LAP_PROFILE_UUID:
  64                         service_mask |= BT_SC_LAP_SERVICE_MASK;
  65                         break;
  66
  67                 case BT_DUN_PROFILE_UUID:
  68                         service_mask |= BT_SC_DUN_SERVICE_MASK;
  69                         break;
  70
  71                 case BT_OBEX_IR_MC_SYNC_SERVICE_UUID:
  72                         service_mask |= BT_SC_SYNC_SERVICE_MASK;
  73                         break;
  74
  75                 case BT_OBEX_OBJECT_PUSH_SERVICE_UUID:
  76                         service_mask |= BT_SC_OPP_SERVICE_MASK;
  77                         break;
  78
  79                 case BT_OBEX_FILE_TRANSFER_UUID:
  80                         service_mask |= BT_SC_FTP_SERVICE_MASK;
  81                         break;
  82
  83                 case BT_HS_PROFILE_UUID:
  84                         service_mask |= BT_SC_HSP_SERVICE_MASK;
  85                         break;
  86
  87                 case BT_CTP_PROFILE_UUID:
  88                         service_mask |= BT_SC_CTP_SERVICE_MASK;
  89                         break;
  90
  91                 case BT_AUDIO_SOURCE_UUID:
  92                         service_mask |= BT_SC_NONE;
  93                         break;
  94
  95                 case BT_AUDIO_SINK_UUID:
  96                         service_mask |= BT_SC_A2DP_SERVICE_MASK;
  97                         break;
  98
  99                 case BT_VIDEO_SOURCE_UUID:
 100                         service_mask |= BT_SC_NONE;
 101                         break;
 102
 103                 case BT_VIDEO_SINK_UUID:
 104                         service_mask |= BT_SC_NONE;
 105                         break;
 106
 107                 case BT_AV_REMOTE_CONTROL_TARGET_UUID:
 108                         service_mask |= BT_SC_NONE;
 109                         break;
 110
 111                 case BT_ADVANCED_AUDIO_PROFILE_UUID:
 112                         service_mask |= BT_SC_A2DP_SERVICE_MASK;
 113                         break;
 114
 115                 case BT_AV_REMOTE_CONTROL_UUID:
 116                         service_mask |= BT_SC_AVRCP_SERVICE_MASK;
 117                         break;
 118
 119                 case BT_ICP_PROFILE_UUID:
 120                         service_mask |= BT_SC_ICP_SERVICE_MASK;
 121                         break;
 122
 123                 case BT_FAX_PROFILE_UUID:
 124                         service_mask |= BT_SC_FAX_SERVICE_MASK;
 125                         break;
 126
 127                 case BT_HEADSET_AG_SERVICE_UUID:
 128                         service_mask |= BT_SC_NONE; /* BT_SC_HSP_SERVICE_MASK */
 129                         break;
 130
 131                 case BT_PAN_PANU_PROFILE_UUID:
 132                         service_mask |= BT_SC_PANU_SERVICE_MASK;
 133                         break;
 134
 135                 case BT_PAN_NAP_PROFILE_UUID:
 136                         service_mask |= BT_SC_NAP_SERVICE_MASK;
 137                         break;
 138
 139                 case BT_PAN_GN_PROFILE_UUID:
 140                         service_mask |= BT_SC_GN_SERVICE_MASK;
 141                         break;
 142
 143                 case BT_REFERENCE_PRINTING:
 144                         service_mask |= BT_SC_NONE;
 145                         break;
 146
 147                 case BT_OBEX_IMAGING_UUID:
 148                         service_mask |= BT_SC_NONE;
 149                         break;
 150
 151                 case BT_OBEX_IMAGING_RESPONDER_UUID:
 152                         service_mask |= BT_SC_BIP_SERVICE_MASK;
 153                         break;
 154
 155                 case BT_HF_PROFILE_UUID:
 156                         service_mask |= BT_SC_HFP_SERVICE_MASK;
 157                         break;
 158
 159                 case BT_HFG_PROFILE_UUID:
 160                         service_mask |= BT_SC_NONE;
 161                         break;
 162
 163                 case BT_DIRECT_PRINTING_REFERENCE_OBJ_UUID:
 164                         service_mask |= BT_SC_NONE;
 165                         break;
 166
 167                 case BT_BASIC_PRINTING:
 168                         service_mask |= BT_SC_NONE;
 169                         break;
 170
 171                 case BT_HID_PROFILE_UUID:
 172                         service_mask |= BT_SC_HID_SERVICE_MASK;
 173                         break;
 174
 175                 case BT_SIM_ACCESS_PROFILE_UUID:
 176                         service_mask |= BT_SC_SAP_SERVICE_MASK;
 177                         break;
 178
 179                 case BT_OBEX_PBA_PROFILE_UUID:
 180                         service_mask |= BT_SC_PBAP_SERVICE_MASK;
 181                         break;
 182
 183                 case BT_OBEX_BPPS_PROFILE_UUID:
 184                         service_mask |= BT_SC_BPP_SERVICE_MASK;
 185                         break;
 186
 187                 case BT_PNP_INFORMATION_UUID:
 188                         service_mask |= BT_SC_NONE;
 189                         break;
 190
 191                 case BT_OBEX_PRINTING_STATUS_UUID:
 192                         service_mask |= BT_SC_BPP_SERVICE_MASK;
 193                         break;
 194
 195                 case BT_HCR_PROFILE_UUID:
 196                         service_mask |= BT_SC_NONE;
 197                         break;
 198
 199                 case BT_OBEX_SYNCML_TRANSFER_UUID:
 200                         service_mask |= BT_SC_NONE;
 201                         break;
 202
 203                 default:
 204                         break;
 205                 }
 206
 207         }
 208
 209         *service_mask_list = service_mask;
 210         BT_DBG("service_mask = %x, service_mask_lis = %x\n", service_mask,
 211                service_mask_list);
 212
 213         FN_END;
 214         return TRUE;
 215 }
 216
 217 int _bt_util_parse_file_list(const char *bundle_txt, char ***filelist,
 218                              int number_of_files)
 219 {
 220         FN_START;
 221         retv_if(bundle_txt == NULL || filelist == NULL, BT_UG_FAIL);
 222
 223         char *token = NULL;
 224         char *param = NULL;
 225         int i = 0;
 226
 227         param = (char *)bundle_txt;
 228         while (((token = strstr(param, "?")) != NULL) && i < number_of_files) {
 229                 *token = '\0';
 230                 *filelist[i] = param;
 231                 BT_DBG("File [%d] [%s]\n", i, *filelist[i]);
 232                 param = token + 1;
 233                 i++;
 234         }
 235         if (i == (number_of_files - 1)) {
 236                 *filelist[i] = param;
 237                 BT_DBG("File [%d] [%s]\n", i, *filelist[i]);
 238         } else {
 239                 BT_DBG("Not match : [%d] / [%d]\n", number_of_files, i);
 240                 return BT_UG_FAIL;
 241         }
 242
 243         FN_END;
 244         return BT_UG_ERROR_NONE;
 245 }
 246
 247 void _bt_util_set_value(const char *req, unsigned int *search_type,
 248                         unsigned int *op_mode)
 249 {
 250         FN_START;
 251         ret_if(req == NULL);
 252         ret_if(search_type == NULL);
 253         ret_if(op_mode == NULL);
 254
 255         if (!strcasecmp(req, "send") || !strcasecmp(req, "browse")) {
 256                 *search_type = BT_COD_SC_OBJECT_TRANSFER;
 257                 *op_mode = BT_LAUNCH_SEND_FILE;
 258         } else if (!strcasecmp(req, "print")) {
 259                 *search_type = BT_DEVICE_MAJOR_MASK_IMAGING;
 260                 *op_mode = BT_LAUNCH_PRINT_IMAGE;
 261         } else if (!strcasecmp(req, "call") || !strcasecmp(req, "sound")) {
 262                 *search_type = BT_DEVICE_MAJOR_MASK_AUDIO;
 263                 *op_mode = BT_LAUNCH_CONNECT_HEADSET;
 264         } else if (!strcasecmp(req, "nfc")) {
 265                 *search_type = BT_DEVICE_MAJOR_MASK_MISC;
 266                 *op_mode = BT_LAUNCH_USE_NFC;
 267         } else if (!strcasecmp(req, "pick")) {
 268                 *search_type = BT_DEVICE_MAJOR_MASK_MISC;
 269                 *op_mode = BT_LAUNCH_PICK;
 270         } else if (!strcasecmp(req, "visibility")) {
 271                 *search_type = BT_DEVICE_MAJOR_MASK_MISC;
 272                 *op_mode = BT_LAUNCH_VISIBILITY;
 273         } else {
 274                 *search_type = BT_DEVICE_MAJOR_MASK_MISC;
 275                 *op_mode = BT_LAUNCH_NORMAL;
 276         }
 277
 278         FN_END;
 279
 280         return;
 281 }
 282
 283 gboolean _bt_util_store_get_value(const char *key, bt_store_type_t store_type,
 284                               unsigned int size, void *value)
 285 {
 286         FN_START;
 287         retv_if(value == NULL, FALSE);
 288
 289         int ret = 0;
 290         int int_value = 0;
 291         int *intval = NULL;
 292         gboolean *boolean = FALSE;
 293         char *str = NULL;
 294
 295         switch (store_type) {
 296         case BT_STORE_BOOLEAN:
 297                 boolean = (gboolean *)value;
 298                 ret = vconf_get_bool(key, &int_value);
 299                 if (ret != 0) {
 300                         BT_DBG("Get bool is failed\n");
 301                         *boolean = FALSE;
 302                         return FALSE;
 303                 }
 304                 *boolean = (int_value != FALSE);
 305                 break;
 306         case BT_STORE_INT:
 307                 intval = (int *)value;
 308                 ret = vconf_get_int(key, intval);
 309                 if (ret != 0) {
 310                         BT_DBG("Get int is failed\n");
 311                         *intval = 0;
 312                         return FALSE;
 313                 }
 314                 break;
 315         case BT_STORE_STRING:
 316                 str = vconf_get_str(key);
 317                 if (str == NULL) {
 318                         BT_DBG("Get string is failed\n");
 319                         return FALSE;
 320                 }
 321                 if (size > 1)
 322                         strncpy((char *)value, str, size - 1);
 323
 324                 free(str);
 325                 break;
 326         default:
 327                 BT_DBG("Unknown Store Type\n");
 328                 return FALSE;
 329         }
 330
 331         FN_END;
 332         return TRUE;
 333 }
 334
 335 void _bt_util_set_phone_name(void)
 336 {
 337         char *phone_name = NULL;
 338         char *ptr = NULL;
 339
 340         phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
 341         if (!phone_name)
 342                 return;
 343
 344         if (strlen(phone_name) != 0) {
 345                 if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
 346                         *ptr = '\0';
 347
 348                 bt_adapter_set_name(phone_name);
 349         }
 350
 351         free(phone_name);
 352 }
 353
 354 int _bt_util_get_phone_name(char *phone_name, int size)
 355 {
 356         FN_START;
 357         retv_if(phone_name == NULL, BT_UG_FAIL);
 358
 359         if (_bt_util_store_get_value(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
 360                                  BT_STORE_STRING, size,
 361                                  (void *)phone_name) < 0) {
 362                 g_strlcpy(phone_name, BT_DEFAULT_PHONE_NAME, size);
 363         }
 364
 365         FN_END;
 366         return BT_UG_ERROR_NONE;
 367 }
 368
 369 int _bt_util_get_timeout_string(int timeout, char *buf, int size)
 370 {
 371         FN_START;
 372         retv_if(buf == NULL, BT_UG_FAIL);
 373
 374         switch (timeout) {
 375         case BT_ZERO:
 376                 g_strlcpy(buf, BT_STR_OFF, size);
 377                 break;
 378         case BT_TWO_MINUTES:
 379                 g_strlcpy(buf, BT_STR_TWO_MINUTES, size);
 380                 break;
 381         case BT_FIVE_MINUTES:
 382                 g_strlcpy(buf, BT_STR_FIVE_MINUTES, size);
 383                 break;
 384         case BT_ONE_HOUR:
 385                 g_strlcpy(buf, BT_STR_ONE_HOUR, size);
 386                 break;
 387         case BT_ALWAYS_ON:
 388                 g_strlcpy(buf, BT_STR_ALWAYS_ON, size);
 389                 break;
 390         default:
 391                 g_strlcpy(buf, BT_STR_OFF, size);
 392                 break;
 393         }
 394
 395         FN_END;
 396         return BT_UG_ERROR_NONE;
 397 }
 398
 399 int _bt_util_get_timeout_value(int index)
 400 {
 401         FN_START;
 402
 403         int timeout;
 404
 405         switch (index) {
 406         case 0:
 407                 timeout = BT_ZERO;
 408                 break;
 409         case 1:
 410                 timeout = BT_TWO_MINUTES;
 411                 break;
 412         case 2:
 413                 timeout = BT_FIVE_MINUTES;
 414                 break;
 415         case 3:
 416                 timeout = BT_ONE_HOUR;
 417                 break;
 418         case 4:
 419                 timeout = BT_ALWAYS_ON;
 420                 break;
 421         default:
 422                 timeout = BT_ZERO;
 423                 break;
 424         }
 425
 426         FN_END;
 427         return timeout;
 428 }
 429
 430 int _bt_util_get_timeout_index(int timeout)
 431 {
 432         FN_START;
 433
 434         int index = 0;
 435
 436         switch (timeout) {
 437         case BT_ZERO:
 438                 index = 0;
 439                 break;
 440         case BT_TWO_MINUTES:
 441                 index = 1;
 442                 break;
 443         case BT_FIVE_MINUTES:
 444                 index = 2;
 445                 break;
 446         case BT_ONE_HOUR:
 447                 index = 3;
 448                 break;
 449         case BT_ALWAYS_ON:
 450                 index = 4;
 451                 break;
 452         default:
 453                 index = 0;
 454                 break;
 455         }
 456
 457         BT_DBG("index: %d", index);
 458
 459         FN_END;
 460         return index;
 461 }
 462
 463 gboolean _bt_util_is_battery_low(void)
 464 {
 465         FN_START;
 466
 467         int value = 0;
 468         int charging = 0;
 469
 470         if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, (void *)&charging))
 471                 BT_DBG("Get the battery charging status fail");
 472
 473         if (charging == 1)
 474                 return FALSE;
 475
 476         BT_DBG("charging: %d", charging);
 477
 478         if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, (void *)&value))
 479                 BT_DBG("Get the battery low status fail");
 480
 481         if (value <= VCONFKEY_SYSMAN_BAT_POWER_OFF)
 482                 return TRUE;
 483
 484         FN_END;
 485         return FALSE;
 486 }
 487
 488 gboolean _bt_util_is_flight_mode(void)
 489 {
 490         FN_START;
 491
 492         bool mode = FALSE;
 493
 494         if (vconf_get_bool(VCONFKEY_SETAPPL_FLIGHT_MODE_BOOL, (void *)&mode)) {
 495                 BT_DBG("Get the flight mode fail");
 496                 return FALSE;
 497         }
 498
 499         BT_DBG("flight mode: %d", mode);
 500
 501         FN_END;
 502         return mode;
 503 }
 504
 505 void _bt_util_show_device_list(Eina_List *list)
 506 {
 507         FN_START;
 508
 509         int index = 0;
 510         bt_dev_t *item = NULL;
 511         Eina_List *l = NULL;
 512
 513         retm_if(list == NULL, "Invalid argument: list is NULL\n");
 514
 515         EINA_LIST_FOREACH(list, l, item) {
 516                 if (item) {
 517                         BT_DBG("count: %d", index++);
 518                         BT_DBG("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
 519                                item->bd_addr[0], item->bd_addr[1],
 520                                item->bd_addr[2], item->bd_addr[3],
 521                                item->bd_addr[4], item->bd_addr[5]);
 522                         BT_DBG("name: %s", item->name);
 523                 }
 524         }
 525
 526         FN_END;
 527 }
 528
 529
 530 /* status - 0 : No operation, 1 : Activate , 2 : Deactivate, 3 : Search Test*/
 531 /* run_type - No window change, 1 : Top window, 2 : Background*/
 532 void _bt_util_launch_bt_service(int status, int run_type)
 533 {
 534         FN_START;
 535
 536         bundle *kb;
 537         char status_val[5] = { 0, };
 538         char run_type_val[5] = { 0, };
 539
 540         snprintf(status_val, sizeof(status_val), "%d", status);
 541         snprintf(run_type_val, sizeof(run_type_val),  "%d", run_type);
 542
 543         BT_DBG("status: %s, run_type: %s", status_val, run_type_val);
 544
 545         kb = bundle_create();
 546         ret_if(kb == NULL);
 547
 548         bundle_add(kb, "launch-type", "setstate");
 549         bundle_add(kb, "status", status_val);
 550         bundle_add(kb, "run-type", run_type_val);
 551
 552         aul_launch_app("com.samsung.bluetooth", kb);
 553
 554         bundle_free(kb);
 555
 556         FN_END;
 557 }
 558
 559 void _bt_util_addr_type_to_addr_string(char *address,
 560                                                unsigned char *addr)
 561 {
 562         FN_START;
 563
 564         ret_if(address == NULL);
 565         ret_if(addr == NULL);
 566
 567         snprintf(address, BT_ADDRESS_STR_LEN, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", addr[0],
 568                 addr[1], addr[2], addr[3], addr[4], addr[5]);
 569
 570         FN_END;
 571 }
 572
 573 void _bt_util_addr_type_to_addr_result_string(char *address,
 574                                                unsigned char *addr)
 575 {
 576         FN_START;
 577
 578         ret_if(address == NULL);
 579         ret_if(addr == NULL);
 580
 581         snprintf(address, BT_ADDRESS_STR_LEN, "%2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2X", addr[0],
 582                 addr[1], addr[2], addr[3], addr[4], addr[5]);
 583
 584         FN_END;
 585 }
 586
 587 void _bt_util_addr_type_to_addr_net_string(char *address,
 588                                                unsigned char *addr)
 589 {
 590         FN_START;
 591
 592         ret_if(address == NULL);
 593         ret_if(addr == NULL);
 594
 595         snprintf(address, BT_ADDRESS_STR_LEN, "%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X", addr[0],
 596                 addr[1], addr[2], addr[3], addr[4], addr[5]);
 597
 598         FN_END;
 599 }
 600
 601 void _bt_util_addr_string_to_addr_type(unsigned char *addr,
 602                                                   const char *address)
 603 {
 604         FN_START
 605
 606         int i;
 607         char *ptr = NULL;
 608
 609         if (!address || !addr)
 610                 return;
 611
 612         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 613                 addr[i] = strtol(address, &ptr, 16);
 614                 if (ptr != NULL) {
 615                         if (ptr[0] != ':') {
 616                                 BT_DBG("Unexpected string\n");
 617                                 return;
 618                         }
 619
 620                         address = ptr + 1;
 621                 }
 622         }
 623
 624         FN_END;
 625 }
 626
 627 void _bt_util_convert_time_to_string(unsigned int remain_time,
 628                                         char *buf, int size)
 629 {
 630         FN_START;
 631         int minute;
 632         int second;
 633
 634         ret_if(remain_time > BT_TIMEOUT_MAX);
 635         ret_if(size < BT_EXTRA_STR_LEN);
 636         ret_if(buf == NULL);
 637
 638         /* Get seconds */
 639         second = remain_time % 60;
 640
 641         /* Get minutes */
 642         minute = remain_time / 60;
 643
 644         snprintf(buf, size, "%d:%02d", minute, second);
 645
 646         FN_END;
 647 }
 648
 649 void _bt_util_launch_no_event(void *data, void *obj, void *event)
 650 {
 651         FN_START;
 652         BT_DBG
 653             ("End key is pressed. But there is no action to process in popup");
 654         FN_END;
 655 }
 656
 657 void _bt_util_set_list_disabled(Evas_Object *genlist, Eina_Bool disable)
 658 {
 659         Elm_Object_Item *item = NULL;
 660         Elm_Object_Item *next = NULL;
 661
 662         item = elm_genlist_first_item_get(genlist);
 663
 664         while (item != NULL) {
 665                 next = elm_genlist_item_next_get(item);
 666                 elm_object_item_disabled_set(item, disable);
 667                 elm_genlist_item_update(item);
 668                 item = next;
 669         }
 670 }
 671
 672 void _bt_util_free_device_uuids(bt_dev_t *item)
 673 {
 674         int i;
 675
 676         ret_if(item == NULL);
 677
 678         if(item->uuids) {
 679                 for (i = 0; item->uuids[i] != NULL; i++)
 680                         g_free(item->uuids[i]);
 681
 682                 g_free(item->uuids);
 683                 item->uuids = NULL;
 684         }
 685 }
 686
 687 void _bt_util_free_device_item(bt_dev_t *item)
 688 {
 689         ret_if(item == NULL);
 690
 691         _bt_util_free_device_uuids(item);
 692         _bt_unset_profile_state_changed_cb(item->net_profile);
 693
 694         free(item);
 695 }
 696