src/tethering_private.c

   1 /*
   2 * Copyright (c) 2011 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 #define _GNU_SOURCE
  18 #include <pthread.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <system_info.h>
  22 #include "tethering_private.h"
  23
  24 static pthread_mutex_t g_tethering_thread_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
  25 static bool is_feature_checked[TETHERING_SUPPORTED_FEATURE_MAX] = {0, };
  26 static bool feature_supported[TETHERING_SUPPORTED_FEATURE_MAX] = {0, };
  27 static GSList *tethering_handle_list = NULL;
  28
  29 void _tethering_lock(void)
  30 {
  31         pthread_mutex_lock(&g_tethering_thread_mutex);
  32 }
  33
  34 void _tethering_unlock(void)
  35 {
  36         pthread_mutex_unlock(&g_tethering_thread_mutex);
  37 }
  38
  39 bool __check_feature_supported(const char *key, tethering_supported_feature_e feature)
  40 {
  41         TETHERING_LOCK;
  42         bool is_supported = false;
  43
  44         if (!is_feature_checked[feature]) {
  45                 if (system_info_get_platform_bool(key, &feature_supported[feature]) < 0) {
  46                         ERR("Get feature is failed");
  47                         TETHERING_UNLOCK;
  48                         return false;
  49                 }
  50
  51                 is_feature_checked[feature] = true;
  52         }
  53
  54         is_supported = feature_supported[feature];
  55
  56         TETHERING_UNLOCK;
  57         return is_supported;
  58 }
  59
  60 int _tethering_check_feature_supported(const char* feature, ...)
  61 {
  62         va_list list;
  63         const char *key;
  64         bool value = false;
  65         bool supported = false;
  66
  67         va_start(list, feature);
  68         key = feature;
  69
  70         while (1) {
  71                 if ((strcmp(key, TETHERING_FEATURE) == 0))
  72                         value = __check_feature_supported(key, TETHERING_SUPPORTED_FEATURE);
  73                 if ((strcmp(key, TETHERING_WIFI_FEATURE) == 0))
  74                         value = __check_feature_supported(key, TETHERING_SUPPORTED_FEATURE_WIFI);
  75                 if ((strcmp(key, TETHERING_BT_FEATURE) == 0))
  76                         value = __check_feature_supported(key, TETHERING_SUPPORTED_FEATURE_BT);
  77                 if ((strcmp(key, TETHERING_USB_FEATURE) == 0))
  78                         value = __check_feature_supported(key, TETHERING_SUPPORTED_FEATURE_USB);
  79                 if ((strcmp(key, TETHERING_WIFI_DIRECT_FEATURE) == 0))
  80                         value = __check_feature_supported(key, TETHERING_SUPPORTED_FEATURE_WIFI_DIRECT);
  81
  82                 supported |= value;
  83                 key = va_arg(list, const char *);
  84                 if (!key) break;
  85         }
  86
  87         if (!supported) {
  88                 ERR("Not supported feature");
  89                 set_last_result(TETHERING_ERROR_NOT_SUPPORT_API);
  90                 va_end(list);
  91                 return TETHERING_ERROR_NOT_SUPPORT_API;
  92         }
  93         va_end(list);
  94         set_last_result(TETHERING_ERROR_NONE);
  95
  96         return TETHERING_ERROR_NONE;
  97 }
  98
  99 void _tethering_add_handle(tethering_h handle)
 100 {
 101         TETHERING_LOCK;
 102         tethering_handle_list = g_slist_append(tethering_handle_list, handle);
 103         TETHERING_UNLOCK;
 104 }
 105
 106 void _tethering_remove_handle(tethering_h handle)
 107 {
 108         TETHERING_LOCK;
 109         tethering_handle_list = g_slist_remove(tethering_handle_list, handle);
 110         TETHERING_UNLOCK;
 111 }
 112
 113 bool _tethering_check_handle(tethering_h handle)
 114 {
 115         TETHERING_LOCK;
 116
 117         if (g_slist_find(tethering_handle_list, handle) != NULL) {
 118                 TETHERING_UNLOCK;
 119                 return true;
 120         }
 121
 122         TETHERING_UNLOCK;
 123         return false;
 124 }
 125