src/sst_feature.c

   1 /*
   2  * Copyright (c) 2020 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 #include "sst_feature.h"
  17
  18 #include <stdlib.h>
  19 #include <system_info.h>
  20 #include "sst.h"
  21 #include "sst_interface.h"
  22
  23 #define SST_FEATURE_ACCESSIBILITY_GRAYSCALE "tizen.org/feature/accessibility.grayscale"
  24 #define SST_FEATURE_ACCESSIBILITY_NEGATIVE "tizen.org/feature/accessibility.negative"
  25 #define SST_FEATURE_FONT "tizen.org/feature/systemsetting.font"
  26 #define SST_FEATURE_HOME_SCREEN "tizen.org/feature/systemsetting.home_screen"
  27 #define SST_FEATURE_INCOMING_CALL "tizen.org/feature/systemsetting.incoming_call"
  28 #define SST_FEATURE_INPUT_ROTATING_BEZEL "tizen.org/feature/input.rotating_bezel"
  29 #define SST_FEATURE_LOCK_SCREEN "tizen.org/feature/systemsetting.lock_screen"
  30 #define SST_FEATURE_NOTIFICATION_EMAIL "tizen.org/feature/systemsetting.notification_email"
  31 #define SST_FEATURE_PROFILE "tizen.org/feature/profile"
  32 #define SST_FEATURE_TELEPHONY "tizen.org/feature/network.telephony"
  33 #define SST_FEATURE_WIFI "tizen.org/feature/network.wifi"
  34 #define SST_FEATURE_ETHERNET "tizen.org/feature/network.ethernet"
  35
  36 static int _check_feature(const char *path)
  37 {
  38         bool feature_data = false;
  39         int ret = system_info_get_platform_bool(path, &feature_data);
  40         if (ret != SYSTEM_INFO_ERROR_NONE) {
  41                 ERR("system_info_get_platform_bool(%s) Fail(%d)", path, ret);
  42                 return SYSTEM_SETTINGS_ERROR_IO_ERROR;
  43         }
  44
  45         if (feature_data) {
  46                 return SYSTEM_SETTINGS_ERROR_NONE;
  47         } else {
  48                 ERR("Not Support Feature(%s)", path);
  49                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  50         }
  51 }
  52
  53 int sst_feature_check_incoming_call(void *value)
  54 {
  55         static bool first_query = true;
  56         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  57
  58         if (first_query == true) {
  59                 const char *feature = SST_FEATURE_INCOMING_CALL;
  60                 ret = _check_feature(feature);
  61                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
  62                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
  63                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  64                 }
  65                 first_query = false;
  66         }
  67
  68         return ret;
  69 }
  70
  71 int sst_feature_check_home_screen(void *value)
  72 {
  73         static bool first_query = true;
  74         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  75
  76         if (first_query == true) {
  77                 const char *feature = SST_FEATURE_HOME_SCREEN;
  78                 ret = _check_feature(feature);
  79                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
  80                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
  81                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  82                 }
  83                 first_query = false;
  84         }
  85
  86         return ret;
  87 }
  88
  89 int sst_feature_check_lock_screen(void *value)
  90 {
  91         static bool first_query = true;
  92         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  93
  94         if (first_query == true) {
  95                 const char *feature = SST_FEATURE_LOCK_SCREEN;
  96                 ret = _check_feature(feature);
  97                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
  98                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
  99                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 100                 }
 101                 first_query = false;
 102         }
 103
 104         return ret;
 105 }
 106
 107 int sst_feature_check_notification_email(void *value)
 108 {
 109         static bool first_query = true;
 110         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 111
 112         if (first_query == true) {
 113                 const char *feature = SST_FEATURE_NOTIFICATION_EMAIL;
 114                 ret = _check_feature(feature);
 115                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 116                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 117                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 118                 }
 119                 first_query = false;
 120         }
 121
 122         return ret;
 123 }
 124
 125 int sst_feature_check_wifi(void *value)
 126 {
 127         static bool first_query = true;
 128         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 129
 130         if (first_query == true) {
 131                 const char *feature = SST_FEATURE_WIFI;
 132                 ret = _check_feature(feature);
 133                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 134                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 135                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 136                 }
 137                 first_query = false;
 138         }
 139
 140         return ret;
 141 }
 142
 143 int sst_feature_check_telephony(void *value)
 144 {
 145         static bool first_query = true;
 146         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 147
 148         if (first_query == true) {
 149                 const char *feature = SST_FEATURE_TELEPHONY;
 150                 ret = _check_feature(feature);
 151                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 152                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 153                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 154                 }
 155                 first_query = false;
 156         }
 157
 158         return ret;
 159 }
 160
 161 int sst_feature_check_font(void *value)
 162 {
 163         static bool first_query = true;
 164         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 165
 166         if (first_query == true) {
 167                 const char *feature = SST_FEATURE_FONT;
 168                 ret = _check_feature(feature);
 169                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 170                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 171                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 172                 }
 173                 first_query = false;
 174         }
 175
 176         return ret;
 177 }
 178
 179 int sst_feature_check_accessibility_grayscale(void *value)
 180 {
 181         static bool first_query = true;
 182         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 183
 184         if (first_query == true) {
 185                 const char *feature = SST_FEATURE_ACCESSIBILITY_GRAYSCALE;
 186                 ret = _check_feature(feature);
 187                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 188                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 189                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 190                 }
 191                 first_query = false;
 192         }
 193
 194         return ret;
 195 }
 196
 197 int sst_feature_check_accessibility_negative(void *value)
 198 {
 199         static bool first_query = true;
 200         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 201
 202         if (first_query == true) {
 203                 const char *feature = SST_FEATURE_ACCESSIBILITY_NEGATIVE;
 204                 ret = _check_feature(feature);
 205                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 206                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 207                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 208                 }
 209                 first_query = false;
 210         }
 211
 212         return ret;
 213 }
 214
 215 int sst_feature_check_rotary(void *value)
 216 {
 217         static bool first_query = true;
 218         static int result = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 219
 220         if (first_query == true) {
 221                 char *profile = NULL;
 222                 const char *feature = SST_FEATURE_PROFILE;
 223                 int ret = system_info_get_platform_string(feature, &profile);
 224                 if (ret != SYSTEM_INFO_ERROR_NONE) {
 225                         ERR("system_info_get_platform_string(%s) Fail(%d)", feature, ret);
 226                         free(profile);
 227                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 228                 }
 229
 230                 if (profile && SST_EQUAL == strcmp(profile, "wearable")) {
 231                         int can_rotary = _check_feature(SST_FEATURE_INPUT_ROTATING_BEZEL);
 232                         if (can_rotary == SYSTEM_SETTINGS_ERROR_IO_ERROR) {
 233                                 ERR("system_info_get_platform_string(%s) Fail(%d)", feature, ret);
 234                                 free(profile);
 235                                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 236                         }
 237                         result = can_rotary;
 238                 }
 239                 free(profile);
 240                 first_query = false;
 241         }
 242
 243         return result;
 244 }
 245
 246 int sst_feature_check_automatic_time_update(void *value)
 247 {
 248         static bool first_query = true;
 249         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 250         const char *feature[] = {
 251                 SST_FEATURE_TELEPHONY,
 252                 SST_FEATURE_WIFI,
 253                 SST_FEATURE_ETHERNET
 254         };
 255         int cnt = sizeof(feature) / sizeof(char*);
 256
 257         if (first_query == true) {
 258                 for (int i = 0 ; i < cnt ; i++) {
 259                         int feature_result = _check_feature(feature[i]);
 260                         if (SYSTEM_SETTINGS_ERROR_NONE == feature_result) {
 261                                 ret = feature_result;
 262                                 break;
 263                         }
 264                         if (SYSTEM_SETTINGS_ERROR_IO_ERROR == feature_result) {
 265                                 ERR("_check_feature(%s) Fail(%d)", feature[i], ret);
 266                                 ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 267                         }
 268                 }
 269                 first_query = false;
 270         }
 271
 272         return ret;
 273 }