src/config.c

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (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, 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 "config.h"
  19 #include "log.h"
  20
  21 #include <stdio.h>
  22 #include <glib.h>
  23 #include <stdlib.h>
  24 #include <app_common.h>
  25
  26 #define CONFIG_FILENAME "config.ini"
  27
  28 static GKeyFile *gk = NULL;
  29
  30 static char *_config_file_path_get()
  31 {
  32         char *ret = NULL;
  33         char *data = app_get_data_path();
  34
  35         if (!data)
  36                 return NULL;
  37
  38         if (asprintf(&ret, "%s%s", data, CONFIG_FILENAME) == -1) {
  39                 ret = NULL;
  40         }
  41
  42         free(data);
  43         return ret;
  44 }
  45
  46 int config_init()
  47 {
  48         GError *error = NULL;
  49
  50         if (gk) {
  51                 _D("config_init already called.");
  52                 return 0;
  53         }
  54
  55         gk = g_key_file_new();
  56         if (!gk) {
  57                 _E("g_key_file_new failed.");
  58                 return -1;
  59         }
  60
  61         char *path = _config_file_path_get();
  62
  63         if (!g_key_file_load_from_file(gk, path, G_KEY_FILE_NONE, &error)) {
  64                 if (error->code != G_FILE_ERROR_NOENT) {
  65                         _E("g_key_file_load_from_file failed. %s", error->message);
  66                         g_key_file_free(gk);
  67                         g_error_free(error);
  68                         free(path);
  69                         return -1;
  70                 }
  71                 g_error_free(error);
  72         }
  73
  74         free(path);
  75         return 0;
  76 }
  77
  78 int config_save()
  79 {
  80         GError *error = NULL;
  81
  82         retv_if(!gk, -1);
  83
  84         char *path = _config_file_path_get();
  85
  86         if (!g_key_file_save_to_file(gk, path, &error)) {
  87                 _E("g_key_file_save_to_file failed: %s", error->message);
  88                 g_error_free(error);
  89                 free(path);
  90                 return -1;
  91         }
  92         free(path);
  93         return 0;
  94 }
  95
  96 void config_shutdown()
  97 {
  98         if (gk) g_key_file_free(gk);
  99         gk = NULL;
 100 }
 101
 102 int config_get_string(const char *group, const char *key, char **out)
 103 {
 104         GError *error = NULL;
 105         char *value;
 106
 107         retv_if(!gk, -1);
 108         retv_if(!group, -1);
 109         retv_if(!key, -1);
 110         retv_if(!out, -1);
 111
 112         value = g_key_file_get_string(gk, group, key, &error);
 113         if (error) {
 114                 _E("g_key_file_get_string failed: %s", error->message);
 115                 g_error_free(error);
 116                 return -1;
 117         }
 118         *out = value;
 119         return 0;
 120 }
 121
 122 void config_set_string(const char *group, const char *key, const char *value)
 123 {
 124         ret_if(!gk);
 125         ret_if(!group);
 126         ret_if(!key);
 127
 128         g_key_file_set_string(gk, group, key, value);
 129 }
 130
 131 int config_get_int(const char *group, const char *key, int *out)
 132 {
 133         GError *error = NULL;
 134         int value;
 135
 136         retv_if(!gk, -1);
 137         retv_if(!group, -1);
 138         retv_if(!key, -1);
 139         retv_if(!out, -1);
 140
 141         value = g_key_file_get_integer(gk, group, key, &error);
 142         if (error) {
 143                 _E("g_key_file_get_integer failed: %s", error->message);
 144                 g_error_free(error);
 145                 return -1;
 146         }
 147         *out = value;
 148         return 0;
 149 }
 150
 151 void config_set_int(const char *group, const char *key, int value)
 152 {
 153         ret_if(!gk);
 154         ret_if(!group);
 155         ret_if(!key);
 156
 157         g_key_file_set_integer(gk, group, key, value);
 158 }
 159
 160 int config_get_double(const char *group, const char *key, double *out)
 161 {
 162         GError *error = NULL;
 163         double value;
 164
 165         retv_if(!gk, -1);
 166         retv_if(!group, -1);
 167         retv_if(!key, -1);
 168         retv_if(!out, -1);
 169
 170         value = g_key_file_get_double(gk, group, key, &error);
 171         if (error) {
 172                 _E("g_key_file_get_double failed: %s", error->message);
 173                 g_error_free(error);
 174                 return -1;
 175         }
 176         *out = value;
 177         return 0;
 178 }
 179
 180 void config_set_double(const char *group, const char *key, double value)
 181 {
 182         ret_if(!gk);
 183         ret_if(!group);
 184         ret_if(!key);
 185
 186         g_key_file_set_double(gk, group, key, value);
 187 }
 188
 189 int config_get_bool(const char *group, const char *key, bool *out)
 190 {
 191         GError *error = NULL;
 192         bool value;
 193
 194         retv_if(!gk, -1);
 195         retv_if(!group, -1);
 196         retv_if(!key, -1);
 197         retv_if(!out, -1);
 198
 199         value = g_key_file_get_boolean(gk, group, key, &error);
 200         if (error) {
 201                 _E("g_key_file_get_boolean failed: %s", error->message);
 202                 g_error_free(error);
 203                 return -1;
 204         }
 205         *out = value;
 206         return 0;
 207 }
 208
 209 void config_set_bool(const char *group, const char *key, bool value)
 210 {
 211         ret_if(!gk);
 212         ret_if(!group);
 213         ret_if(!key);
 214
 215         g_key_file_set_boolean(gk, group, key, value);
 216 }
 217
 218 int config_remove_key(const char *group, const char *key)
 219 {
 220         retv_if(!gk, -1);
 221         retv_if(!group, -1);
 222         retv_if(!key, -1);
 223
 224         return g_key_file_remove_key(gk, group, key, NULL) ? 0 : 1;
 225 }
 226
 227 int config_remove_group(const char *group)
 228 {
 229         retv_if(!gk, -1);
 230         retv_if(!group, -1);
 231
 232         return g_key_file_remove_group(gk, group, NULL) ? 0 : 1;
 233 }
 234
 235 bool config_get_string_or_set_default(char *group, char *key, char *default_value, char **value)
 236 {
 237         bool modified = false;
 238
 239         if (config_get_string(group, key, value) != 0) {
 240                 config_set_string(group, key, default_value);
 241
 242                 *value = strdup(default_value);
 243
 244                 modified = true;
 245         }
 246
 247         return modified;
 248 }
 249
 250 bool config_get_int_with_default(char *group, char *key, int default_value, int *value)
 251 {
 252         bool modified = false;
 253
 254         if (config_get_int(group, key, value) != 0) {
 255                 config_set_int(group, key, default_value);
 256
 257                 *value = default_value;
 258                 modified = true;
 259         }
 260
 261         return modified;
 262 }
 263
 264 bool config_get_rgb_with_default(char *group, char *key,
 265                 int default_r, int default_g, int default_b,
 266                 int *red, int *green, int *blue)
 267 {
 268         bool modified = false;
 269         int color;
 270
 271         if (config_get_int(group, key, &color) != 0) {
 272
 273                 color  = (default_r & 0xFF) << 16;
 274                 color += (default_g & 0xFF) << 8;
 275                 color += (default_b & 0xFF) << 0;
 276
 277                 config_set_int(group, key, color);
 278
 279                 modified = true;
 280         }
 281
 282         *red   = (color >> 16) & 0xFF;
 283         *green = (color >>  8) & 0xFF;
 284         *blue  = (color >>  0) & 0xFF;
 285
 286         return modified;
 287 }