src/sst_api.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 "system_settings.h"
  17
  18 #include "sst.h"
  19 #include "sst_vconf.h"
  20 #include "sst_sound.h"
  21 #include "sst_interface.h"
  22
  23 API int system_settings_set_value_int(system_settings_key_e key, int value)
  24 {
  25         int ret;
  26         sst_interface *iface = NULL;
  27         ret = sst_get_interface(key, &iface);
  28         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
  29                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
  30                 return ret;
  31         }
  32
  33         if (SYSTEM_SETTING_DATA_TYPE_INT != iface->data_type) {
  34                 ERR("Invalide type for key(%d) : %d", key, iface->data_type);
  35                 return SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
  36         }
  37
  38         if (NULL == iface->setter.i) {
  39                 ERR("No setter for key(%d)", key);
  40                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  41         }
  42
  43         ret = iface->setter.i(iface, value);
  44         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
  45                 ERR("setter(%d) Fail(%d)", key, ret);
  46                 return ret;
  47         }
  48
  49         return SYSTEM_SETTINGS_ERROR_NONE;
  50 }
  51
  52 API int system_settings_get_value_int(system_settings_key_e key, int *value)
  53 {
  54         int ret;
  55         sst_interface *iface = NULL;
  56         ret = sst_get_interface(key, &iface);
  57         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
  58                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
  59                 return ret;
  60         }
  61
  62         if (SYSTEM_SETTING_DATA_TYPE_INT != iface->data_type) {
  63                 ERR("Invalide type for key(%d) : %d", key, iface->data_type);
  64                 return SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
  65         }
  66
  67         if (NULL == iface->getter.i) {
  68                 ERR("No getter for key(%d)", key);
  69                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
  70         }
  71
  72         int result = 0;
  73         ret = iface->getter.i(iface, &result);
  74         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
  75                 ERR("getter(%d) Fail(%d)", key, ret);
  76                 return ret;
  77         }
  78
  79         *value = result;
  80         return SYSTEM_SETTINGS_ERROR_NONE;
  81 }
  82
  83 API int system_settings_set_value_bool(system_settings_key_e key, bool value)
  84 {
  85         int ret;
  86         sst_interface *iface = NULL;
  87         ret = sst_get_interface(key, &iface);
  88         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
  89                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
  90                 return ret;
  91         }
  92
  93         if (SYSTEM_SETTING_DATA_TYPE_BOOL != iface->data_type) {
  94                 ERR("Invalide type for key(%d) : %d", key, iface->data_type);
  95                 return SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
  96         }
  97
  98         if (NULL == iface->setter.b) {
  99                 ERR("No setter for key(%d)", key);
 100                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 101         }
 102
 103         ret = iface->setter.b(iface, value);
 104         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 105                 ERR("setter(%d) Fail(%d)", key, ret);
 106                 return ret;
 107         }
 108
 109         return SYSTEM_SETTINGS_ERROR_NONE;
 110 }
 111
 112 API int system_settings_get_value_bool(system_settings_key_e key, bool *value)
 113 {
 114         int ret;
 115         sst_interface *iface = NULL;
 116         ret = sst_get_interface(key, &iface);
 117         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 118                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 119                 return ret;
 120         }
 121
 122         if (SYSTEM_SETTING_DATA_TYPE_BOOL != iface->data_type) {
 123                 ERR("Invalide type for key(%d) : %d", key, iface->data_type);
 124                 return SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
 125         }
 126
 127         if (NULL == iface->getter.b) {
 128                 ERR("No getter for key(%d)", key);
 129                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 130         }
 131
 132         bool result = 0;
 133         ret = iface->getter.b(iface, &result);
 134         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 135                 ERR("getter(%d) Fail(%d)", key, ret);
 136                 return ret;
 137         }
 138
 139         *value = result;
 140         return SYSTEM_SETTINGS_ERROR_NONE;
 141 }
 142
 143 API int system_settings_set_value_string(system_settings_key_e key, const char *value)
 144 {
 145         int ret;
 146         sst_interface *iface = NULL;
 147         ret = sst_get_interface(key, &iface);
 148         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 149                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 150                 return ret;
 151         }
 152
 153         if (SYSTEM_SETTING_DATA_TYPE_STRING != iface->data_type) {
 154                 ERR("Invalide type for key(%d) : %d", key, iface->data_type);
 155                 return SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
 156         }
 157
 158         if (NULL == iface->setter.s) {
 159                 ERR("No setter for key(%d)", key);
 160                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 161         }
 162
 163         ret = iface->setter.s(iface, value);
 164         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 165                 ERR("setter(%d) Fail(%d)", key, ret);
 166                 return ret;
 167         }
 168
 169         return SYSTEM_SETTINGS_ERROR_NONE;
 170 }
 171
 172 API int system_settings_get_value_string(system_settings_key_e key, char **value)
 173 {
 174         int ret;
 175         sst_interface *iface = NULL;
 176         ret = sst_get_interface(key, &iface);
 177         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 178                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 179                 return ret;
 180         }
 181
 182         if (SYSTEM_SETTING_DATA_TYPE_STRING != iface->data_type) {
 183                 ERR("Invalide type for key(%d) : %d", key, iface->data_type);
 184                 return SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
 185         }
 186
 187         if (NULL == iface->getter.s) {
 188                 ERR("No getter for key(%d)", key);
 189                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 190         }
 191
 192         char *result = NULL;
 193         ret = iface->getter.s(iface, &result);
 194         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 195                 ERR("getter(%d) Fail(%d)", key, ret);
 196                 return ret;
 197         }
 198
 199         *value = result;
 200         return SYSTEM_SETTINGS_ERROR_NONE;
 201 }
 202
 203 //todo: need to deprecate
 204 API int system_settings_set_changed_cb(system_settings_key_e key, system_settings_changed_cb callback, void *user_data)
 205 {
 206         int ret;
 207
 208         RETV_IF(NULL == callback, SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER);
 209
 210         sst_interface *iface = NULL;
 211         ret = sst_get_interface(key, &iface);
 212         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 213                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 214                 return ret;
 215         }
 216
 217         if (NULL == iface->vconf_key) {
 218                 ERR("NULL set_changed_cb of key(%d)", key);
 219                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 220         }
 221
 222         return sst_vconf_set_cb(iface, callback, user_data);
 223 }
 224
 225 //todo: need to deprecate
 226 API int system_settings_unset_changed_cb(system_settings_key_e key)
 227 {
 228         sst_interface *iface = NULL;
 229         int ret = sst_get_interface(key, &iface);
 230         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 231                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 232                 return ret;
 233         }
 234
 235         if (NULL == iface->vconf_key) {
 236                 ERR("NULL set_changed_cb of key(%d)", key);
 237                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 238         }
 239
 240         return sst_vconf_unset_cb(iface);
 241 }
 242
 243 API int system_settings_foreach_value_string(system_settings_key_e key, system_settings_iter_cb callback, void *value)
 244 {
 245         DBG("Enter");
 246         RETVM_IF(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE != key,
 247                 SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER,
 248                 "Invalid Key(%d)", key);
 249
 250         return sst_sound_get_call_ringtone_list(key, callback, value);
 251 }
 252
 253 API int system_settings_add_value_string(system_settings_key_e key, const char* value)
 254 {
 255         DBG("Enter");
 256         RETVM_IF(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE != key,
 257                 SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER,
 258                 "Invalid Key(%d)", key);
 259
 260         return sst_sound_add_call_ringtone(key, value);
 261 }
 262
 263 API int system_settings_delete_value_string(system_settings_key_e key, const char* value)
 264 {
 265         DBG("Enter");
 266         RETVM_IF(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE != key,
 267                 SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER,
 268                 "Invalid Key(%d)", key);
 269
 270         return sst_sound_del_call_ringtone(key, value);
 271 }
 272
 273 API int system_settings_add_changed_cb(system_settings_key_e key, system_settings_changed_cb callback, void *user_data)
 274 {
 275         int ret;
 276
 277         RETV_IF(NULL == callback, SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER);
 278
 279         sst_interface *iface = NULL;
 280         ret = sst_get_interface(key, &iface);
 281         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 282                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 283                 return ret;
 284         }
 285
 286         if (NULL == iface->vconf_key) {
 287                 ERR("NULL vconf_key of key(%d)", key);
 288                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 289         }
 290
 291         INFO("key = %d, %s", key, iface->vconf_key);
 292
 293         ret = sst_vconf_add_multi_cb(iface, callback, user_data);
 294         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 295                 ERR("sst_vconf_add_multi_cb() Fail(%d)", ret);
 296                 return ret;
 297         }
 298
 299         return SYSTEM_SETTINGS_ERROR_NONE;
 300 }
 301
 302 API int system_settings_remove_changed_cb(system_settings_key_e key, system_settings_changed_cb callback)
 303 {
 304         int ret;
 305
 306         RETV_IF(NULL == callback, SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER);
 307
 308         sst_interface *iface = NULL;
 309         ret = sst_get_interface(key, &iface);
 310         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 311                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 312                 return ret;
 313         }
 314
 315         if (NULL == iface->vconf_key) {
 316                 ERR("NULL vconf_key of key(%d)", key);
 317                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 318         }
 319
 320         ret = sst_vconf_del_multi_cb(iface, callback);
 321         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 322                 ERR("sst_vconf_del_multi_cb() Fail(%d)", ret);
 323                 return ret;
 324         }
 325
 326         return SYSTEM_SETTINGS_ERROR_NONE;
 327 }
 328
 329 int system_settings_subscribe_changes(system_settings_key_e key, system_settings_changed_cb callback, void *user_data, system_settings_cb_id *id)
 330 {
 331         int ret;
 332
 333         RETV_IF(NULL == id, SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER);
 334         RETV_IF(NULL == callback, SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER);
 335
 336         sst_interface *iface = NULL;
 337         ret = sst_get_interface(key, &iface);
 338         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 339                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 340                 return ret;
 341         }
 342
 343         if (NULL == iface->vconf_key) {
 344                 ERR("NULL vconf_key of key(%d)", key);
 345                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 346         }
 347
 348         ret = sst_vconf_subscribe(iface, callback, user_data, id);
 349         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 350                 ERR("sst_vconf_subscribe() Fail(%d)", ret);
 351                 return ret;
 352         }
 353         return SYSTEM_SETTINGS_ERROR_NONE;
 354 }
 355
 356 int system_settings_unsubscribe_changes(system_settings_key_e key, system_settings_cb_id id)
 357 {
 358         int ret;
 359
 360         RETV_IF(NULL == id, SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER);
 361
 362         sst_interface *iface = NULL;
 363         ret = sst_get_interface(key, &iface);
 364         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 365                 ERR("sst_get_interface(%d) Fail(%d)", key, ret);
 366                 return ret;
 367         }
 368
 369         if (NULL == iface->vconf_key) {
 370                 ERR("NULL vconf_key of key(%d)", key);
 371                 return SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED;
 372         }
 373
 374         ret = sst_vconf_unsubscribe(iface, id);
 375         if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
 376                 ERR("sst_vconf_unsubscribe() Fail(%d)", ret);
 377                 return ret;
 378         }
 379         return SYSTEM_SETTINGS_ERROR_NONE;
 380
 381
 382 }