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
  35 static int _check_feature(const char *path)
  36 {
  37         bool feature_data = false;
  38         int ret = system_info_get_platform_bool(path, &feature_data);
  39         if (ret != SYSTEM_INFO_ERROR_NONE) {
  40                 ERR("system_info_get_platform_bool(%s) Fail(%d)", path, ret);
  41                 return SYSTEM_SETTINGS_ERROR_IO_ERROR;
  42         }
  43
  44         if (feature_data) {
  45                 return SYSTEM_SETTINGS_ERROR_NONE;
  46         } else {
  47                 ERR("Not Support Feature(%s)", path);
  48                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  49         }
  50 }
  51
  52 int sst_feature_check_incoming_call(void *value)
  53 {
  54         static bool first_query = true;
  55         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  56
  57         if (first_query == true) {
  58                 const char *feature = SST_FEATURE_INCOMING_CALL;
  59                 ret = _check_feature(feature);
  60                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
  61                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
  62                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  63                 }
  64                 first_query = false;
  65         }
  66
  67         return ret;
  68 }
  69
  70 int sst_feature_check_home_screen(void *value)
  71 {
  72         static bool first_query = true;
  73         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  74
  75         if (first_query == true) {
  76                 const char *feature = SST_FEATURE_HOME_SCREEN;
  77                 ret = _check_feature(feature);
  78                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
  79                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
  80                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  81                 }
  82                 first_query = false;
  83         }
  84
  85         return ret;
  86 }
  87
  88 int sst_feature_check_lock_screen(void *value)
  89 {
  90         static bool first_query = true;
  91         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  92
  93         if (first_query == true) {
  94                 const char *feature = SST_FEATURE_LOCK_SCREEN;
  95                 ret = _check_feature(feature);
  96                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
  97                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
  98                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  99                 }
 100                 first_query = false;
 101         }
 102
 103         return ret;
 104 }
 105
 106 int sst_feature_check_notification_email(void *value)
 107 {
 108         static bool first_query = true;
 109         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 110
 111         if (first_query == true) {
 112                 const char *feature = SST_FEATURE_NOTIFICATION_EMAIL;
 113                 ret = _check_feature(feature);
 114                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 115                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 116                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 117                 }
 118                 first_query = false;
 119         }
 120
 121         return ret;
 122 }
 123
 124 int sst_feature_check_wifi(void *value)
 125 {
 126         static bool first_query = true;
 127         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 128
 129         if (first_query == true) {
 130                 const char *feature = SST_FEATURE_WIFI;
 131                 ret = _check_feature(feature);
 132                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 133                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 134                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 135                 }
 136                 first_query = false;
 137         }
 138
 139         return ret;
 140 }
 141
 142 int sst_feature_check_telephony(void *value)
 143 {
 144         static bool first_query = true;
 145         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 146
 147         if (first_query == true) {
 148                 const char *feature = SST_FEATURE_TELEPHONY;
 149                 ret = _check_feature(feature);
 150                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 151                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 152                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 153                 }
 154                 first_query = false;
 155         }
 156
 157         return ret;
 158 }
 159
 160 int sst_feature_check_font(void *value)
 161 {
 162         static bool first_query = true;
 163         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 164
 165         if (first_query == true) {
 166                 const char *feature = SST_FEATURE_FONT;
 167                 ret = _check_feature(feature);
 168                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 169                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 170                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 171                 }
 172                 first_query = false;
 173         }
 174
 175         return ret;
 176 }
 177
 178 int sst_feature_check_accessibility_grayscale(void *value)
 179 {
 180         static bool first_query = true;
 181         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 182
 183         if (first_query == true) {
 184                 const char *feature = SST_FEATURE_ACCESSIBILITY_GRAYSCALE;
 185                 ret = _check_feature(feature);
 186                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 187                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 188                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 189                 }
 190                 first_query = false;
 191         }
 192
 193         return ret;
 194 }
 195
 196 int sst_feature_check_accessibility_negative(void *value)
 197 {
 198         static bool first_query = true;
 199         static int ret = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 200
 201         if (first_query == true) {
 202                 const char *feature = SST_FEATURE_ACCESSIBILITY_NEGATIVE;
 203                 ret = _check_feature(feature);
 204                 if (SYSTEM_SETTINGS_ERROR_IO_ERROR == ret) {
 205                         ERR("_check_feature(%s) Fail(%d)", feature, ret);
 206                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 207                 }
 208                 first_query = false;
 209         }
 210
 211         return ret;
 212 }
 213
 214 int sst_feature_check_rotary(void *value)
 215 {
 216         static bool first_query = true;
 217         static int result = SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 218
 219         if (first_query == true) {
 220                 char *profile = NULL;
 221                 const char *feature = SST_FEATURE_PROFILE;
 222                 int ret = system_info_get_platform_string(feature, &profile);
 223                 if (ret != SYSTEM_INFO_ERROR_NONE) {
 224                         ERR("system_info_get_platform_string(%s) Fail(%d)", feature, ret);
 225                         free(profile);
 226                         return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 227                 }
 228
 229                 if (profile && SST_EQUAL == strcmp(profile, "wearable")) {
 230                         int can_rotary = _check_feature(SST_FEATURE_INPUT_ROTATING_BEZEL);
 231                         if (can_rotary == SYSTEM_SETTINGS_ERROR_IO_ERROR) {
 232                                 ERR("system_info_get_platform_string(%s) Fail(%d)", feature, ret);
 233                                 free(profile);
 234                                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 235                         }
 236                         result = can_rotary;
 237                 }
 238                 free(profile);
 239                 first_query = false;
 240         }
 241
 242         return result;
 243 }