setting-common/src/setting-common-data-slp-setting.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <setting-common-data-slp-setting.h>
  22 #include <Elementary.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <openssl/sha.h>
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30
  31 #include <stdlib.h>
  32 #include <libxml/xmlmemory.h>
  33 #include <libxml/parser.h>
  34 #include <libxml/tree.h>
  35 #include <glib.h>
  36
  37 #include <glib.h>
  38 #include <json-glib/json-glib.h>
  39
  40 #define SETTING_DATA_DIR_PATH "/opt/apps/org.tizen.setting/data/"
  41 #define SETTING_CFG_JSON_FILE_PATH      SETTING_DATA_DIR_PATH"exported.json"
  42 #define EXPORT_FILE             SETTING_DATA_DIR_PATH"setting_export.xml"
  43
  44
  45 typedef enum {
  46     eBOOL,
  47     eINT,
  48     eSTRING,
  49 } vconftype;
  50
  51 typedef union {
  52         int i;
  53         bool b;
  54         char *c;
  55 } vconfval;
  56
  57
  58 typedef struct VconfNode VconfNode;
  59 struct VconfNode {
  60         const char *public_key;                                 /** key for importing & exporting */
  61         const char *public_groupkey;                    /** category for importing & exporting */
  62         /*------------------------------------------------------------------------------------- */
  63         int key;                                                                /** vconf id definded in Setting app */
  64         const char *vconf_key;                                  /** vconf string defined in libslp-setting */
  65         vconftype type;                                                 /** BOOL, INT, STRING */
  66         vconfval value;                                                 /** variable by union */
  67         void (*export)(VconfNode *pnode, void *data);           /** method for exporting current state */
  68         void (*import)(VconfNode *pnode, void *data);           /** method for importing state from cloud */
  69 };
  70
  71 int get_vconf(VconfNode node, VconfNode *result);
  72 int set_vconf(VconfNode node, VconfNode *result);
  73
  74 static VconfNode *g_sortedarr;
  75
  76 /* export function for each vconf key */
  77 EXPORT_PUBLIC
  78 void export_default(VconfNode *node, void *root)
  79 {
  80
  81         xmlNodePtr *root_node = (xmlNodePtr *)root;
  82
  83         if (node) {
  84                 char *val = NULL;
  85                 char *type = NULL;
  86
  87                 char arr[1024];
  88                 if (node->vconf_key == NULL) return; /* NO DOTHING IF null */
  89                 VconfNode result;
  90                 switch (node->type) {
  91                         case eBOOL:
  92                                 SETTING_TRACE("EXPORTING key : %s : %d : %d", node->vconf_key, node->type, node->value.b);
  93                                 /* call vconf_get */
  94
  95                                 get_vconf(*node, &result);
  96
  97                                 val = "boolval";
  98                                 type = "bool";
  99                                 if (result.value.b)
 100                                         val = "true";
 101                                 else
 102                                         val = "false";
 103
 104                                 break;
 105                         case eINT:
 106                                 SETTING_TRACE("EXPORTING key : %s : %d : %d", node->vconf_key, node->type, node->value.i);
 107                                 /* call vconf_get */
 108                                 get_vconf(*node, &result);
 109                                 type = "int";
 110
 111                                 SETTING_TRACE(">>(%d)<<", result.value.i);
 112                                 sprintf(arr, "%d", result.value.i);
 113                                 /*node->value.i */
 114                                 val = arr;
 115                                 break;
 116                         case eSTRING:
 117                                 SETTING_TRACE("EXPORTING key : %s : %d : %s", node->vconf_key, node->type, node->value.c);
 118                                 /* call vconf_get */
 119                                 get_vconf(*node, &result);
 120                                 val = result.value.c;
 121                                 type = "string";
 122                                 break;
 123                 }
 124
 125                 xmlNodePtr xmlnode = xmlNewChild(*root_node, NULL, BAD_CAST "config", BAD_CAST val);
 126                 xmlNewProp(xmlnode, BAD_CAST "key", BAD_CAST node->vconf_key);
 127                 xmlNewProp(xmlnode, BAD_CAST "type", BAD_CAST type);
 128                 xmlAddChild(*root_node, xmlnode);
 129         }
 130 }
 131
 132 /*----------------------------------------------------------------------------------------------- */
 133
 134 /* export function for each vconf key */
 135 EXPORT_PUBLIC
 136 void export_json(VconfNode *node, void *root)
 137 {
 138         JsonArray *array = (JsonArray *)root;
 139
 140         if (node) {
 141                 char *val = NULL;
 142                 /*char *type = NULL; */
 143
 144                 char arr[1024];
 145                 if (node->vconf_key == NULL) return; /* NO DOTHING IF null */
 146                 VconfNode result;
 147                 switch (node->type) {
 148                         case eBOOL:
 149                                 SETTING_TRACE("EXPORTING key : %s : %d : %d", node->vconf_key, node->type, node->value.b);
 150                                 /* call vconf_get */
 151
 152                                 get_vconf(*node, &result);
 153
 154                                 val = "boolval";
 155                                 /*type = "bool"; */
 156                                 if (result.value.b)
 157                                         val = "true";
 158                                 else
 159                                         val = "false";
 160
 161                                 break;
 162                         case eINT:
 163                                 SETTING_TRACE("EXPORTING key : %s : %d : %d", node->vconf_key, node->type, node->value.i);
 164                                 /* call vconf_get */
 165                                 get_vconf(*node, &result);
 166                                 /*type = "int"; */
 167
 168                                 SETTING_TRACE(">>(%d)<<", result.value.i);
 169                                 sprintf(arr, "%d", result.value.i);
 170                                 /*node->value.i */
 171                                 val = arr;
 172                                 break;
 173                         case eSTRING:
 174                                 SETTING_TRACE("EXPORTING key : %s : %d : %s", node->vconf_key, node->type, node->value.c);
 175                                 /* call vconf_get */
 176                                 get_vconf(*node, &result);
 177                                 val = result.value.c;
 178                                 /*type = "string"; */
 179                                 break;
 180                 }
 181
 182                 JsonNode *item = json_node_new(JSON_NODE_OBJECT);
 183                 JsonObject *obj = json_object_new();
 184
 185                 json_node_take_object(item, obj);
 186                 json_object_set_string_member(obj, "key", node->public_key);
 187                 json_object_set_string_member(obj, "value", val);
 188                 json_array_add_element(array, item);
 189         }
 190 }
 191
 192 /* /opt/usr/data/setting/aaa.xml */
 193 /* import function for each vconf key */
 194 EXPORT_PUBLIC
 195 void import_default(VconfNode *node, void *data)
 196 {
 197         /*xmlNodePtr* root_node =(xmlNodePtr*)data; */
 198
 199         switch (node->type) {
 200                 case eBOOL:
 201                         SETTING_TRACE("IMPORTING key : %s : %d : %d", node->vconf_key, node->type, node->value);
 202                         break;
 203                 case eINT:
 204                         SETTING_TRACE("IMPORTING key : %s : %d : %d", node->vconf_key, node->type, node->value);
 205                         break;
 206                 case eSTRING:
 207                         SETTING_TRACE("IMPORTING key : %s : %d : %s", node->vconf_key, node->type, node->value);
 208                         break;
 209         }
 210 }
 211
 212 /** bool vconf table */
 213 static VconfNode g_btable[] = {
 214
 215         {"power_on_lock", "security", BOOL_SLP_SETTING_POWER_ON_LOCK, VCONFKEY_SETAPPL_STATE_POWER_ON_LOCK_BOOL, eBOOL, {0}, export_json, import_default}, /* node[0] */
 216         {"simple_password", "security", BOOL_SLP_SETTING_SIMPLE_PASSWORD, VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, eBOOL, {0}, export_json, import_default}, /* node[0] */
 217
 218         {"automatic_time", "datetime", BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, eBOOL, {0}, export_json, import_default},
 219
 220         {"transaction_tracking", "license", BOOL_SLP_SETTING_TRANSACTION_TRACKING, VCONFKEY_SETAPPL_STATE_TRANSACTION_TRACKING_BOOL, eBOOL, {0}, export_json, import_default},
 221         {"expiry_reminer", "license", BOOL_SLP_SETTING_EXPIRY_REMINDER, VCONFKEY_SETAPPL_STATE_EXPIRY_REMINDER_BOOL, eBOOL, {0}, export_json, import_default},
 222
 223         {"filight_mode", "connectivity", BOOL_SLP_SETTING_FLIGHT_MODE, VCONFKEY_TELEPHONY_FLIGHT_MODE, eBOOL, {0}, export_json, import_default},
 224         {"multi_window", "device", BOOL_SLP_SETTING_MULTI_WINDOW_MODE, VCONFKEY_QUICKSETTING_MULTIWINDOW_ENABLED, eBOOL, {0}, export_json, import_default},
 225         {"net_restriction_mode", "connectivity", BOOL_SLP_SETTING_NET_RESTRICTION_MODE, VCONFKEY_SETAPPL_NETWORK_RESTRICT_MODE, eBOOL, {0}, export_json, import_default},
 226         {"data_roaming", "connectivity", BOOL_SLP_SETTING_DATA_ROAMING, VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, eBOOL, {0}, export_json, import_default},
 227         {"nfc_mode", "connectivity", BOOL_SLP_SETTING_NFC_STATUS, VCONFKEY_NFC_STATE, eBOOL, {0}, export_json, import_default},
 228         {"sbeam_mode", "connectivity", BOOL_SLP_SETTING_NFC_SBEAM, VCONFKEY_NFC_SBEAM, eBOOL, {0}, export_json, import_default},
 229
 230         {"use_packetdata", "connectivity", BOOL_SLP_SETTING_USE_PACKET_DATA, VCONFKEY_3G_ENABLE, eBOOL, {0}, export_json, import_default},
 231         {"high_contract", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_HIGH_CONTRAST, VCONFKEY_SETAPPL_ACCESSIBILITY_HIGH_CONTRAST, eBOOL, {0}, export_json, import_default},
 232         {"screen_zoom", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_SCREEN_ZOOM, VCONFKEY_SETAPPL_ACCESSIBILITY_SCREEN_ZOOM, eBOOL, {0}, export_json, import_default},
 233         {"assistive_light", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_ASSISTIVE_LIGHT, VCONFKEY_SETAPPL_ACCESSIBILITY_TORCH_LIGHT, eBOOL, {0}, export_json, import_default},
 234         {"speak_password", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_SPEAK_PASSWD, VCONFKEY_SETAPPL_ACCESSIBILITY_SPEAK_PASSWD_BOOL, eBOOL, {0}, export_json, import_default},
 235         {"mono_audio", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_MONO_AUDIO, VCONFKEY_SETAPPL_ACCESSIBILITY_MONO_AUDIO, eBOOL, {0}, export_json, import_default},
 236         {"turn_off_all_sounds", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_TURN_OFF_ALL_SOUNDS, VCONFKEY_SETAPPL_ACCESSIBILITY_TURN_OFF_ALL_SOUNDS, eBOOL, {0}, export_json, import_default},
 237         {"led_notify", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_LED_NOTIFY, VCONFKEY_SETAPPL_ACCESSIBILITY_LED_NOTIFY, eBOOL, {0}, export_json, import_default},
 238         {"accept_call", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_ACCEPT_CALL, VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL, eBOOL, {0}, export_json, import_default},
 239         {"powerkey_end_calls", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_POWERKEY_END_CALLS, VCONFKEY_CISSAPPL_POWER_KEY_ENDS_CALL_BOOL, eBOOL, {0}, export_json, import_default},
 240         {"easy_touch_mode", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_EASY_TOUCH_MODE, VCONFKEY_SETAPPL_EASY_TOUCH_MODE_BOOL, eBOOL, {0}, export_json, import_default},
 241         {"rapid_key_input", "accessibility", BOOL_SLP_SETTING_ACCESSIBILITY_RAPID_KEY_INPUT, VCONFKEY_SETAPPL_ACCESSIBILITY_RAPID_KEY_INPUT, eBOOL, {0}, export_json, import_default},
 242
 243         /*datausage */
 244         {"data_usage_limit_bool", "datausage", BOOL_SLP_SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_BOOL, VCONFKEY_SETAPPL_SET_DATA_USAGE_LIMIT_BOOL, eBOOL, {0}, export_json, import_default},
 245         {"data_usage_limit_roaming_bool", "datausage", BOOL_SLP_SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_ROAMING_BOOL, VCONFKEY_SETAPPL_SET_DATA_USAGE_LIMIT_ROAMING_BOOL, eBOOL, {0}, export_json, import_default},
 246
 247         /* motion */
 248         {"motion_activation", "motion", BOOL_SLP_SETTING_MOTION_ACTIVATION, VCONFKEY_SETAPPL_MOTION_ACTIVATION, eBOOL, {0}, export_json, import_default},
 249         {"use_pick_up_call", "motion", BOOL_SLP_SETTING_MOTION_USE_PICK_UP_CALL, VCONFKEY_SETAPPL_USE_PICK_UP_CALL, eBOOL, {0}, export_json, import_default},
 250         {"use_pick_up", "motion", BOOL_SLP_SETTING_MOTION_USE_PICK_UP, VCONFKEY_SETAPPL_USE_PICK_UP, eBOOL, {0}, export_json, import_default},
 251         {"use_double_tap", "motion", BOOL_SLP_SETTING_MOTION_USE_DOUBLE_TAP, VCONFKEY_SETAPPL_USE_DOUBLE_TAP, eBOOL, {0}, export_json, import_default},
 252         {"use_tilt", "motion", BOOL_SLP_SETTING_MOTION_USE_TILT, VCONFKEY_SETAPPL_USE_TILT, eBOOL, {0}, export_json, import_default},
 253         {"use_panning", "motion", BOOL_SLP_SETTING_MOTION_USE_PANNING, VCONFKEY_SETAPPL_USE_PANNING, eBOOL, {0}, export_json, import_default},
 254         {"use_panning_browser", "motion", BOOL_SLP_SETTING_MOTION_USE_PANNING_BROWSER, VCONFKEY_SETAPPL_USE_PANNING_BROWSER, eBOOL, {0}, export_json, import_default},
 255         {"use_shake", "motion", BOOL_SLP_SETTING_MOTION_USE_SHAKE, VCONFKEY_SETAPPL_USE_SHAKE, eBOOL, {0}, export_json, import_default},
 256         {"use_turn_over", "motion", BOOL_SLP_SETTING_MOTION_USE_TURN_OVER, VCONFKEY_SETAPPL_USE_TURN_OVER, eBOOL, {0}, export_json, import_default},
 257         {"palm_swip_capture", "motion", BOOL_SLP_SETTING_MOTION_PALM_SWIP_CAPTURE, VCONFKEY_SETAPPL_PALM_SWIP_CAPTURE, eBOOL, {0}, export_json, import_default},
 258         {"palm_touch_mute", "motion", BOOL_SLP_SETTING_MOTION_PALM_TOUCH_MUTE, VCONFKEY_SETAPPL_PALM_TOUCH_MUTE, eBOOL, {0}, export_json, import_default},
 259         {"tab_twist", "motion", BOOL_SLP_SETTING_MOTION_TAP_TWIST, VCONFKEY_SETAPPL_TAP_TWIST, eBOOL, {0}, export_json, import_default},
 260         {"use_mute_pause", "motion", BOOL_SLP_SETTING_MOTION_USE_MUTE_PAUSE, VCONFKEY_SETAPPL_USE_MUTE_PAUSE, eBOOL, {0}, export_json, import_default},
 261         /*---- */
 262         {NULL, "groupname", SETTING_BOOL_SLP_LIST_MAX, NULL, eBOOL, {0}, export_json, import_default},
 263 };
 264
 265
 266 /** int vconf table */
 267 static VconfNode g_itable[] = {
 268         {"lcd_brightness", "display", INT_SLP_SETTING_LCD_BRIGHTNESS, VCONFKEY_SETAPPL_LCD_BRIGHTNESS, eINT, {0}, export_json, import_default},
 269         {"lcd_timeout_normal", "display", INT_SLP_SETTING_LCD_TIMEOUT_NORMAL, VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, eINT, {0}, export_json, import_default},
 270         {"lcd_timeout_normal_backup", "display", INT_SLP_SETTING_LCD_TIMEOUT_NORMAL_BACKUP, VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, eINT, {0}, export_json, import_default},
 271
 272         {"automatic_brightness", "display", INT_SLP_SETTING_AUTOMATIC_BRIGHTNESS, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, eINT, {0}, export_json, import_default},
 273
 274         {"select_network", "network", INT_SLP_SETTING_SELECT_NETWORK, VCONFKEY_SETAPPL_SELECT_NETWORK_INT, eINT, {0}, export_json, import_default},
 275         {"network_mode", "network", INT_SLP_SETTING_NETWORK_MODE, VCONFKEY_SETAPPL_NETWORK_MODE_INT, eINT, {0}, export_json, import_default},
 276         {"regionformat_time1224", "datetime", INT_SLP_SETTING_REGIONFORMAT_TIME1224, VCONFKEY_REGIONFORMAT_TIME1224, eINT, {0}, export_json, import_default},
 277         {"dateformat", "datetime", INT_SLP_SETTING_DATE_FORMAT, VCONFKEY_SETAPPL_DATE_FORMAT_INT, eINT, {0}, export_json, import_default},
 278         {"weekformat", "datetime", INT_SLP_SETTING_WEEK_FORMAT, VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, eINT, {0}, export_json, import_default},
 279
 280         /* CALL_ALERT_VIB */
 281         {"call_alert_vib", "sound", INT_SLP_SETTING_CALL_ALERT_VIB, VCONFKEY_SETAPPL_CALL_VIBRATION_PATTERN_INT, eINT, {0}, export_json, import_default},
 282
 283         /*****/
 284         {"msg_alert_repeat", "sound", INT_SLP_SETTING_MSG_ALERT_REPEAT, VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, eINT, {0}, export_json, import_default},
 285         {"email_alert_repeat", "sound", INT_SLP_SETTING_EMAIL_ALERT_REPEAT, VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT, eINT, {0}, export_json, import_default},
 286
 287         /*****/
 288         {"font_size", "font", INT_SLP_SETTING_FONT_SIZE, VCONFKEY_SETAPPL_FONT_SIZE_INT, eINT, {0}, export_json, import_default},
 289         {"font_type", "font", INT_SLP_SETTING_FONT_TYPE, VCONFKEY_SETAPPL_FONT_TYPE_INT, eINT, {0}, export_json, import_default},
 290         {"language_index", "display", INT_SLP_SETTING_LANG, VCONFKEY_SETAPPL_LANG_INT, eINT, {0}, export_json, import_default},
 291         {"bluetooth_switch", "connectivity", INT_SLP_SETTING_BT_STATUS, VCONFKEY_BT_STATUS, eINT, {0}, export_json, import_default},
 292         {"wifi_state", "connectivity", INT_SLP_SETTING_WIFI_STATUS, VCONFKEY_WIFI_STATE, eINT, {0}, export_json, import_default},
 293         {"mobile_hotspot_mode", "connectivity", INT_SLP_SETTING_MOBILE_AP_STATUS, VCONFKEY_MOBILE_HOTSPOT_MODE, eINT, {0}, export_json, import_default},
 294         {"roaming_network", "connectivity", INT_SLP_SETTING_ROAMING_NETWORK, VCONFKEY_SETAPPL_ROAMING_NETWORK_INT, eINT, {0}, export_json, import_default},
 295         {"usb_mode", "connectivity", INT_SLP_SETTING_USB_MODE, VCONFKEY_SETAPPL_USB_MODE_INT, eINT, {0}, export_json, import_default},
 296
 297 #ifdef UNUSED_VCONFKEY
 298         {"viewtype", "taskswitch", INT_SLP_SETTING_TASKSWITCHER_VIEWTYPE, VCONFKEY_TASKSWITCHER_VIEWTYPE, eINT, {0}, export_json, import_default},
 299 #endif
 300         /* memory */
 301         /*{"mem_wap", "memory", INT_SLP_SETTING_DEFAULT_MEM_WAP,VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, eINT, {0}, export_json, import_default}, */
 302         {"mem_bluetooth", "memory", INT_SLP_SETTING_DEFAULT_MEM_BLUETOOTH, VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, eINT, {0}, export_json, import_default},
 303         {"mem_camera", "memory", INT_SLP_SETTING_DEFAULT_MEM_CAMERA, VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, eINT, {0}, export_json, import_default},
 304         {"mem_voicerecorder", "memory", INT_SLP_SETTING_DEFAULT_MEM_VOICE_RECORDER, VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, eINT, {0}, export_json, import_default},
 305         {"mem_download", "memory", INT_SLP_SETTING_DEFAULT_MEM_WAP, VCONFKEY_SETAPPL_DEFAULT_MEM_DOWNLOAD_INT, eINT, {0}, export_json, import_default},
 306         {"mem_nfc", "memory", INT_SLP_SETTING_DEFAULT_MEM_NFC, VCONFKEY_SETAPPL_DEFAULT_MEM_DOWNLOAD_NFC_INT, eINT, {0}, export_json, import_default},
 307         {"mem_downloadcontents", "memory", INT_SLP_SETTING_DEFAULT_MEM_DOWNLOADCONTENTS, VCONFKEY_SETAPPL_DEFAULT_MEM_DOWNLOAD_CONTENTS_INT, eINT, {0}, export_json, import_default},
 308         {"mem_downloadapplication", "memory", INT_SLP_SETTING_DEFAULT_MEM_DOWNLOADAPPLICATION, VCONFKEY_SETAPPL_DEFAULT_MEM_DOWNLOAD_APPLICATION_INT, eINT, {0}, export_json, import_default},
 309         {"mem_wifidirect", "memory", INT_SLP_SETTING_DEFAULT_MEM_WIFIDIRECT, VCONFKEY_SETAPPL_DEFAULT_MEM_WIFI_DIRECT_INT, eINT, {0}, export_json, import_default},
 310         {"mem_installapplications", "memory", INT_SLP_SETTING_DEFAULT_MEM_INSTALLAPPLICATIONS, VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT, eINT, {0}, export_json, import_default},
 311         /*{"mem_fm_radio", "memory", INT_SLP_SETTING_DEFAULT_MEM_FM_RADIO,VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, eINT, {0}, export_json, import_default}, */
 312         /*{"mem_allshare", "memory", INT_SLP_SETTING_DEFAULT_MEM_ALL_SHARE,VCONFKEY_SETAPPL_DEFAULT_MEM_ALL_SHARE_INT, eINT, {0}, export_json, import_default}, */
 313         /*{"mem_adobe_air", "memory", INT_SLP_SETTING_DEFAULT_MEM_ADOBE_AIR,VCONFKEY_SETAPPL_DEFAULT_MEM_ADOBE_AIR_INT, eINT, {0}, export_json, import_default}, */
 314         /*{"mem_dvb_h", "memory", INT_SLP_SETTING_DEFAULT_MEM_DVB_H,VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, eINT, {0}, export_json, import_default}, */
 315
 316         /* other module */
 317         {"sim_slot", "security", INT_SLP_SETTING_SIM_SLOT, VCONFKEY_TELEPHONY_SIM_SLOT, eINT, {0}, export_json, import_default},
 318         {"phone_lock_attempt", "security", INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT, VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT, eINT, {0}, export_json, import_default},
 319         {"sime_lock_attempt", "security", INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT, VCONFKEY_SETAPPL_SIM_LOCK_ATTEMPTS_LEFT_INT, eINT, {0}, export_json, import_default},
 320
 321         /* accessibility setting */
 322         {"enable_auto_answer", "accessibility", INT_SLP_SETTING_ACCESSIBILITY_ENABLE_AUTO_ANSWER, VCONFKEY_CISSAPPL_ANSWERING_MODE_INT, eINT, {0}, export_json, import_default},
 323         {"font_size", "accessibility", INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, eINT, {0}, export_json, import_default},
 324 #if SUPPORT_FONT_STYLE
 325         {"font_style", "accessibility", INT_SLP_SETTING_ACCESSIBILITY_FONT_STYLE, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_STYLE, eINT, {0}, export_json, import_default},
 326 #endif
 327         {"auto_answer", "accessibility", INT_SLP_SETTING_ACCESSIBILITY_AUTO_ANSWER,     VCONFKEY_CISSAPPL_ANSWERING_MODE_TIME_INT, eINT, {0}, export_json, import_default},
 328         {"power_key_hold", "accessibility", INT_SLP_SETTING_ACCESSIBILITY_POWER_KEY_HOLD, VCONFKEY_SETAPPL_ACCESSIBILITY_POWER_KEY_HOLD, eINT, {0}, export_json, import_default},
 329         {"speech_rate", "accessibility", INT_SLP_SETTING_ACCESSIBILITY_SPEECH_RATE, VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, eINT, {0}, export_json, import_default},
 330         {"sound_balance", "accessibility", INT_SLP_SETTING_ACCESSIBILITY_SOUND_BALANCE, VCONFKEY_SETAPPL_SOUND_BALANCE_INT, eINT, {0}, export_json, import_default},
 331
 332         /*powersaving */
 333         {"powersaving_at", "powersaving", INT_SLP_SETTING_POWERSAVING_AT, VCONFKEY_SETAPPL_PWRSV_CUSTMODE_AT, eINT, {0}, export_json, import_default},
 334         {"screen_timeout", "powersaving", INT_SLP_SETTING_POWERSAVING_SCREEN_TIMEOUT, VCONFKEY_SETAPPL_PWRSV_CUSTMODE_BLTIME, eINT, {0}, export_json, import_default},
 335         {"bgprocess", "developeroptions", INT_SLP_SETTING_DEVOPTION_BGPROCESS, VCONFKEY_SETAPPL_DEVOPTION_BGPROCESS, eINT, {0}, export_json, import_default},
 336
 337         /* data usage */
 338         {"usage_cycle", "datausage", INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, VCONFKEY_SETAPPL_DATA_USAGE_CYCLE_INT, eINT, {0}, export_json, import_default},
 339         {"data_limit", "datausage", INT_SLP_SETTING_DATAUSAGE_DATA_LIMIT_INT, VCONFKEY_SETAPPL_DATA_LIMIT_INT, eINT, {0}, export_json, import_default},
 340         {"data_limit_roaming", "datausage", INT_SLP_SETTING_DATAUSAGE_DATA_LIMIT_ROAMING_INT, VCONFKEY_SETAPPL_DATA_LIMIT_ROAMING_INT, eINT, {0}, export_json, import_default},
 341         {"each_month", "datausage", INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, VCONFKEY_SETAPPL_DATA_EACH_MONTH_INT, eINT, {0}, export_json, import_default},
 342         {"each_month_app", "datausage", INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_APP_INT, VCONFKEY_SETAPPL_DATA_EACH_MONTH_APP_INT, eINT, {0}, export_json, import_default},
 343         {"data_usage_auto_sync_data", "datausage", INT_SLP_SETTING_DATAUSAGE_AUTO_SYNC_DATA_INT, VCONFKEY_ACCOUNT_AUTO_SYNC_STATUS_INT, eINT, {0}, export_json, import_default},
 344
 345         /* accessories */
 346         {"accessories/audio_output", "accessories", INT_SLP_SETTING_ACCESSORIES_AUDIO_OUTPUT_INT, VCONFKEY_SETAPPL_ACCESSORY_AUDIO_OUTPUT, eINT, {0}, export_json, import_default},
 347         {"display/touchkey_light_duration", "display", INT_SLP_SETTING_TOUCHKEY_LIGHT_DURATION_INT, VCONFKEY_SETAPPL_TOUCHKEY_LIGHT_DURATION, eINT, {0}, export_json, import_default},
 348         {"display/screen_capture_destination", "display", INT_SLP_SETTING_SCREEN_CAPTURE_DESTINATION_INT, VCONFKEY_SETAPPL_SCREEN_CAPTURE_DESTINATION, eINT, {0}, export_json, import_default},
 349         /*---- */
 350         {NULL, "groupkey", SETTING_INT_SLP_LIST_MAX, NULL, eINT, {0}, export_json, import_default},
 351
 352 };
 353
 354
 355 /** string vconf table */
 356 static VconfNode g_stable[] = {
 357         /* password code - special processing */
 358         {"phone_password", "security",  STR_SLP_LIST_PHONE_PASSWORD, NULL, eSTRING, {0}, export_json, import_default },
 359         {"phonelock_timestamp", "security",     STR_SLP_SETTING_PHONE_LOCK_TIMESTAMP, VCONFKEY_SETAPPL_PHONE_LOCK_TIMESTAMP_STR, eSTRING, {0}, export_json, import_default },
 360         {"simlock_timestamp", "security",       STR_SLP_SETTING_SIM_LOCK_TIMESTAMP, VCONFKEY_SETAPPL_SIM_LOCK_TIMESTAMP_STR, eSTRING, {0}, export_json, import_default },
 361         {"selected_phonenum", "about",  STR_SLP_SETTING_SELECT_NUM, VCONFKEY_SETAPPL_SELECTED_NUM, eSTRING, {0}, export_json, import_default },
 362         /*---- */
 363         {NULL, "groupkey",      STR_SLP_LIST_MAX, NULL, eSTRING, {0}, export_json, import_default},
 364 };
 365
 366
 367 /**
 368  * import
 369  */
 370 int sync_adapter_restore_set_data(void *data, unsigned long long size)
 371 {
 372
 373         /*if(size <=  0) */
 374         /*      SETTING_TRACE("error"); */
 375
 376         /*SETTING_TRACE("%s: data is %s", __func__, (char *)data); */
 377         /*SETTING_TRACE("%s: size is %lld", __func__, size); */
 378         return 0;
 379 }
 380
 381
 382
 383 static int getconfsize()
 384 {
 385         /*---- */
 386         int bcount = sizeof(g_btable) / sizeof(g_btable[0]) - 1;
 387         int icount = sizeof(g_itable) / sizeof(g_itable[0]) - 1;
 388         int scount = sizeof(g_stable) / sizeof(g_stable[0]) - 1; /* why?? buggy */
 389         int total = bcount + icount + scount;
 390
 391         return total;
 392 }
 393
 394 /**
 395  * leaf node
 396  *
 397  * g_sortedarr from caller
 398  */
 399 void __foreach_attr(JsonObject *object, const gchar *public_key, JsonNode *member_node, gpointer user_data)
 400 {
 401         char *public_groupname = (char *)user_data;
 402         char *retstr = (char *)json_object_get_string_member(object, public_key);
 403
 404         /*SETTING_TRACE(" public_groupname : %s", public_groupname); */
 405
 406         /* LOOKUP(group, key) ----> vconf_key */
 407         int total = getconfsize();
 408
 409         int i;
 410         static int ncount = 0;
 411         int run = 1;
 412         for (i = 0; i < total && run == 1; i++) {
 413                 /*SETTING_TRACE(" >> g_sortedarr[%d].public_groupkey : %s",i, g_sortedarr[i].public_groupkey ); */
 414                 /*SETTING_TRACE(" >> g_sortedarr[%d].public_key : %s",i, g_sortedarr[i].public_key ); */
 415                 /*SETTING_TRACE(" >> public_key : %s",public_key ); */
 416
 417                 if (g_sortedarr[i].public_groupkey &&
 418                     safeStrCmp(g_sortedarr[i].public_groupkey, public_groupname) == 0 &&
 419                     g_sortedarr[i].public_key &&
 420                     safeStrCmp(g_sortedarr[i].public_key, public_key) == 0) {
 421                         ncount += 1;
 422                         SETTING_TRACE(" FOUND ---> group name %s : public key %s --- vconf key (%s) - type (%d) -- strval : [%s] ", g_sortedarr[i].public_groupkey, g_sortedarr[i].public_key, g_sortedarr[i].vconf_key, g_sortedarr[i].type, retstr);
 423
 424                         /* set value from vconf (key/value) */
 425                         /* retstr */
 426                         VconfNode result;
 427                         switch (g_sortedarr[i].type) {
 428                                 case eBOOL:
 429                                         /* "true"  --> 1  "false" --> 0 */
 430                                         if (retstr && safeStrCmp(retstr, "true") == 0) {
 431                                                 g_sortedarr[i].value.b = 1;
 432                                         }       else if (retstr && safeStrCmp(retstr, "false") == 0) {
 433                                                 g_sortedarr[i].value.b = 0;
 434                                         }
 435                                         break;
 436
 437                                 case eINT: {
 438                                                 int num = -1;
 439                                                 /* "111" --> 1111 */
 440                                                 if (retstr)
 441                                                         num = atoi(retstr);
 442                                                 g_sortedarr[i].value.i = num;
 443                                         }
 444                                         break;
 445
 446                                 case eSTRING:
 447                                         /* "hello world"  --> "hello world" */
 448                                         if (retstr)
 449                                                 g_sortedarr[i].value.c = retstr;
 450                                         else
 451                                                 g_sortedarr[i].value.c = "";    /* error handler */
 452                                         break;
 453
 454                         }
 455
 456                         if (g_sortedarr[i].vconf_key)
 457                                 set_vconf(g_sortedarr[i], &result);
 458                         else {
 459                                 SETTING_TRACE("vconf key is NULL");
 460                         }
 461
 462                         run = 0; /* stop loop */
 463                 }
 464         }
 465         SETTING_TRACE(" n - FOUND %d ", ncount);
 466 }
 467
 468 void __func_cb(JsonObject *object, const gchar *member_name, JsonNode *member_node, gpointer user_data)
 469 {
 470         /*JsonArray *array = json_node_get_array(member_node); */
 471         /*SETTING_TRACE(" ----> member name : %s ", member_name); */
 472         JsonObject *child = json_object_get_object_member(object, member_name);
 473         json_object_foreach_member(child, __foreach_attr, (gpointer)member_name);
 474 }
 475
 476 int __compareByCategory(const void *arg1, const void *arg2)
 477 {
 478         char *str1 = (char *)(((VconfNode *)arg1)->public_groupkey);
 479         char *str2 = (char *)(((VconfNode *)arg2)->public_groupkey);
 480
 481         if (!str1 || !str2) return -1;
 482
 483         return safeStrCmp(str1, str2);
 484 }
 485
 486 EXPORT_PUBLIC
 487 void setting_import_json(status_handler_fp fp, void *data)
 488 {
 489         SETTING_TRACE_BEGIN;
 490         /*--------------------------------------------------------------------------------- */
 491         JsonParser *parser;
 492         JsonNode *root;
 493         GError *error;
 494
 495         /*---- */
 496         int bcount = sizeof(g_btable) / sizeof(g_btable[0]) - 1;
 497         int icount = sizeof(g_itable) / sizeof(g_itable[0]) - 1;
 498         int scount = sizeof(g_stable) / sizeof(g_stable[0]) - 1; /* why?? buggy */
 499         int total = bcount + icount + scount;
 500         SETTING_TRACE(" >>> total : %d ", total);
 501
 502         VconfNode *arr3 = (VconfNode *)malloc(sizeof(VconfNode) * total);
 503         if (!arr3) return;
 504         memcpy(arr3, g_btable, sizeof(VconfNode) * (bcount));
 505         memcpy(&arr3[bcount - 1], g_itable, sizeof(g_itable));
 506         memcpy(&arr3[bcount - 1 + icount - 1], g_stable, sizeof(g_stable));
 507         qsort(arr3, total, sizeof(VconfNode), __compareByCategory);
 508         /*---- */
 509
 510         g_sortedarr = arr3;
 511
 512         parser = json_parser_new();
 513
 514         error = NULL;
 515         json_parser_load_from_file(parser, SETTING_CFG_JSON_FILE_PATH, &error);
 516         if (error) {
 517                 SETTING_TRACE("Unable to parse `%s': %s", SETTING_CFG_JSON_FILE_PATH, error->message);
 518                 g_error_free(error);
 519                 g_object_unref(parser);
 520                 return;
 521         }
 522
 523         root = json_parser_get_root(parser);
 524         /* manipulate the object tree and then exit */
 525
 526         JsonObject *obj1 = json_node_get_object(root);
 527         if (json_object_has_member(obj1, "value")) {
 528                 JsonNode *node = json_object_get_member(obj1, "value");
 529                 JsonObject *object2 = json_node_get_object(node);
 530                 json_object_foreach_member(object2, __func_cb, NULL);   /* with g_sortedarr */
 531         }
 532         g_object_unref(parser);
 533
 534         FREE(arr3);
 535         g_sortedarr = NULL;
 536 }
 537
 538 /**
 539  * setting --> cloud : JSON
 540  *
 541  * int status_handler(int total, int current,  void* data);
 542  */
 543 EXPORT_PUBLIC
 544 char *setting_export_json(status_handler_fp fp, void *data)
 545 {
 546         JsonNode *root = NULL;
 547
 548         root = json_node_new(JSON_NODE_OBJECT);
 549         JsonObject *top = json_object_new();
 550         json_node_take_object(root, top);
 551
 552         json_object_set_string_member(top, "key", "SETTINGS_359617040746834_8592d887-8b97-406e-9cf9-03aebc045f81");
 553
 554         int bcount = sizeof(g_btable) / sizeof(g_btable[0]) - 1;
 555         int icount = sizeof(g_itable) / sizeof(g_itable[0]) - 1;
 556         int scount = sizeof(g_stable) / sizeof(g_stable[0]) - 1; /* why?? buggy */
 557
 558         int total = bcount + icount + scount;
 559
 560         JsonNode *topnode = json_node_new(JSON_NODE_OBJECT);
 561         JsonObject *topobj = json_object_new();
 562         json_node_take_object(topnode, topobj);
 563
 564         json_object_set_member(top, "value", topnode);
 565
 566         VconfNode *arr3 = (VconfNode *)malloc(sizeof(VconfNode) * total);
 567         if (!arr3) return NULL;
 568         memcpy(arr3, g_btable, sizeof(VconfNode) * (bcount));
 569         memcpy(&arr3[bcount - 1], g_itable, sizeof(g_itable));
 570         memcpy(&arr3[bcount - 1 + icount - 1], g_stable, sizeof(g_stable));
 571         qsort(arr3, total, sizeof(VconfNode), __compareByCategory);
 572
 573         char *public_groupkey = "";
 574
 575         /*JsonArray* array = NULL; */
 576         JsonObject *obj = NULL;
 577         JsonNode *node = NULL;
 578
 579         int i;
 580         for (i = 0; i < total; i++) {
 581                 if (arr3[i].public_key) {
 582                         if (public_groupkey && safeStrCmp(public_groupkey, arr3[i].public_groupkey) != 0) {
 583                                 public_groupkey = (char *)(arr3[i].public_groupkey);
 584                                 /*array = json_array_new(); */
 585                                 obj = json_object_new();
 586                                 node = json_node_new(JSON_NODE_OBJECT);
 587                                 json_node_take_object(node, obj);
 588                                 json_object_set_member(topobj, public_groupkey, node);
 589                                 /*json_array_add_element(array, node); */
 590                         }
 591
 592                         /* get data from vconf */
 593                         /* get vconf_get */
 594                         char *val = NULL;
 595                         char arr[1024];
 596                         VconfNode result;
 597                         switch (arr3[i].type) {
 598                                 case eBOOL:
 599                                         get_vconf(arr3[i], &result);
 600                                         if (result.value.b)
 601                                                 val = "true";
 602                                         else
 603                                                 val = "false";
 604                                         break;
 605                                 case eINT:
 606                                         get_vconf(arr3[i], &result);
 607                                         sprintf(arr, "%d", result.value.i);
 608                                         val = arr;
 609                                         /*if (val == NULL) val = "-100"; */
 610                                         break;
 611                                 case eSTRING:
 612                                         get_vconf(arr3[i], &result);
 613                                         val = result.value.c;
 614                                         if (val == NULL) val = "";
 615                                         break;
 616                                 default:
 617                                         val = "error";
 618                         }
 619
 620                         json_object_set_string_member(obj, arr3[i].public_key, val);
 621                 }
 622         }
 623
 624         /* save data to a file */
 625         GError *error = NULL;
 626         JsonGenerator *generator = json_generator_new();
 627         json_generator_set_root(generator, root/*node*/);
 628
 629         gsize len;
 630         char *buf = (char *)json_generator_to_data(generator, &len);
 631
 632         g_object_set(generator, "pretty", TRUE, NULL);   /*write file in indent format */
 633         gboolean ret = json_generator_to_file(generator, SETTING_CFG_JSON_FILE_PATH, &error);
 634         g_object_unref(generator);
 635
 636         if (FALSE == ret) {
 637                 SETTING_TRACE_ERROR("Error writing file %s!", SETTING_CFG_JSON_FILE_PATH);
 638                 /*return FALSE; */
 639         }
 640
 641         json_node_free(root);
 642         FREE(arr3);
 643
 644         return buf;
 645 }
 646
 647 int set_vconf(VconfNode node, VconfNode *result)
 648 {
 649         /*SETTING_TRACE_BEGIN; */
 650         int ret = -1 ;
 651         /*node.key */
 652         /*node.vconf_key */
 653         *result = node;
 654         switch (node.type) {
 655                 case eBOOL:
 656                         /*SETTING_TRACE("begin case eBOOL[%s=\"%d\"]", node.vconf_key, node.value.b); */
 657                         ret = vconf_set_bool(node.vconf_key, node.value.b);
 658                         result->type = eBOOL;
 659                         result->value.b = node.value.b;
 660                         break;
 661                 case eINT:
 662                         /*SETTING_TRACE("begin case eINT[%s=\"%d\"]", node.vconf_key, node.value.i); */
 663                         ret = vconf_set_int(node.vconf_key, node.value.i);
 664                         result->type = eINT;
 665                         result->value.i = node.value.i;
 666                         break;
 667                 case eSTRING:
 668                         if (node.key == STR_SLP_LIST_PHONE_PASSWORD) {
 669                                 ret = setting_store_init_password(node.value.c);
 670                         } else {
 671                                 /*SETTING_TRACE("begin case eSTRING[%s=\"%s\"]", node.vconf_key, node.value.c); */
 672                                 ret = vconf_set_str(node.vconf_key, node.value.c);
 673                         }
 674                         result->type = eSTRING;
 675                         result->value.c = node.value.c;
 676                         break;
 677                 default:
 678                         SETTING_TRACE_ERROR(">>>>>>>>>> node.type is NOT DEFINED");
 679                         break;
 680         }
 681
 682         if (0 != ret) {
 683                 SETTING_TRACE_ERROR(">>>>>>>>>> Failed to set vconf[%s]", node.vconf_key);
 684         }
 685         /*SETTING_TRACE("KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result->key, result->vconf_key, result->type, result->value.i); */
 686         return ret;
 687 }
 688
 689
 690 int get_vconf(VconfNode node, VconfNode *result)
 691 {
 692         int ret = -1 ;
 693
 694         char md_result[SHA256_DIGEST_LENGTH];
 695         memset(md_result, 0x0, SHA256_DIGEST_LENGTH);
 696
 697
 698         *result = node;
 699
 700         switch (node.type) {
 701                 case eBOOL:
 702                         ret = vconf_get_bool(node.vconf_key, (int *)(&(node.value.b)));
 703                         result->type = eBOOL;
 704                         result->value.b = node.value.b;
 705                         break;
 706                 case eINT:
 707                         ret = vconf_get_int(node.vconf_key, &(node.value.i));
 708                         result->type = eINT;
 709                         result->value.i = node.value.i;
 710                         break;
 711                 case eSTRING:
 712                         if (node.key == STR_SLP_LIST_PHONE_PASSWORD) {
 713                                 node.value.c = (char *)malloc(sizeof(char) * SHA256_DIGEST_LENGTH);
 714                                 if (node.value.c) {
 715                                         memset(node.value.c, 0x0, SHA256_DIGEST_LENGTH);
 716                                 } else {
 717                                         SETTING_TRACE_ERROR(" malloc filed : eSTRING, node.value.c ");
 718                                         ret = SETTING_RETURN_FAIL;
 719                                         goto endtag;
 720                                 }
 721
 722                                 if (setting_read_password(md_result) == 0) {
 723                                         safeCopyStr(node.value.c, md_result, SHA256_DIGEST_LENGTH); /*  un-safe */
 724
 725                                         result->type = eSTRING;
 726                                         result->value.c = node.value.c;
 727                                         ret = SETTING_RETURN_SUCCESS;
 728                                 } else {
 729                                         /*do nothing */
 730                                         ret = SETTING_RETURN_FAIL;
 731                                         goto endtag;
 732                                 }
 733                         } else {
 734                                 node.value.c = vconf_get_str(node.vconf_key);
 735                                 SETTING_TRACE("string type ---> %s ", node.value.c);
 736                                 result->type = eSTRING;
 737                                 result->value.c = node.value.c;
 738                                 ret = SETTING_RETURN_SUCCESS;
 739                         }
 740                         break;
 741                 default:
 742                         SETTING_TRACE_ERROR(">>>>>>>>>>>>>>>>>>>>>>> get vconf ERROR : %s ", node.vconf_key);
 743         }
 744 endtag:
 745         return ret;
 746 }
 747
 748 EXPORT_PUBLIC
 749 int setting_set_bool_slp_key(setting_bool_slp_list key, int value, int *err)
 750 {
 751         /*SETTING_TRACE_BEGIN; */
 752         int ret = SETTING_RETURN_FAIL;
 753
 754         /* error check */
 755         if (key < 0 || key >= SETTING_BOOL_SLP_LIST_MAX) {
 756                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 757                 return ret;
 758         }
 759
 760         VconfNode result;
 761         g_btable[key].value.b = value;
 762         ret = set_vconf(g_btable[key], &result);
 763
 764         SETTING_TRACE("setting_set_bool ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.b);
 765         return ret;
 766 }
 767
 768 EXPORT_PUBLIC
 769 int setting_get_bool_slp_key(setting_bool_slp_list key, int *value, int *err)
 770 {
 771         /*SETTING_TRACE_BEGIN; */
 772         int ret = SETTING_RETURN_FAIL;
 773
 774         /* error check */
 775         if (key < 0 || key >= SETTING_BOOL_SLP_LIST_MAX) {
 776                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 777                 SETTING_TRACE_ERROR(" <<<<<<<< key is invalid >>>>>>>>>>>>> ");
 778                 return ret;
 779         }
 780         VconfNode result;
 781         ret = get_vconf(g_btable[key], &result);
 782         /**value = g_btable[key].value.b; */
 783         *value = result.value.b;
 784         return ret;
 785 }
 786
 787 EXPORT_PUBLIC
 788 int setting_set_int_slp_key(setting_int_slp_list key, int value, int *err)
 789 {
 790         /*SETTING_TRACE_BEGIN; */
 791         int ret = SETTING_RETURN_FAIL;
 792
 793         /* error check */
 794         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 795                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 796                 SETTING_TRACE(">>> key is invalid ");
 797                 return ret;
 798         }
 799
 800         VconfNode result;
 801         g_itable[key].value.i = value;
 802         ret = set_vconf(g_itable[key], &result);
 803         *err = ret;
 804         SETTING_TRACE_DEBUG("setting_set_int ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.i);
 805         return ret;
 806 }
 807
 808 /* return -1: fail  cannot use err to check the result, return value instead*/
 809 EXPORT_PUBLIC
 810 int setting_get_int_slp_key(setting_int_slp_list key, int *value, int *err)
 811 {
 812         /*SETTING_TRACE_BEGIN; */
 813         int ret = SETTING_RETURN_FAIL;
 814
 815         /* error check */
 816         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 817                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 818                 return ret;
 819         }
 820
 821         VconfNode result;
 822         ret = get_vconf(g_itable[key], &result);
 823         /**value = g_itable[key].value.i; */
 824         *value = result.value.i;
 825
 826         *err = ret;
 827         return ret;
 828 }
 829
 830 EXPORT_PUBLIC
 831 int setting_get_string_slp_key(setting_str_slp_list key, char *value, int *err)
 832 {
 833         /*SETTING_TRACE_BEGIN; */
 834         int ret = SETTING_RETURN_FAIL;
 835
 836         /* error check */
 837         if (key < 0 || key >= STR_SLP_LIST_MAX || NULL == value) {
 838                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 839                 return ret;
 840         }
 841
 842         /** @todo check memory leack when passwork checking */
 843         VconfNode result;
 844         ret = get_vconf(g_stable[key], &result);
 845
 846         if (ret >= 0) {
 847                 safeCopyStr(value, result.value.c, strlen(result.value.c));
 848                 SETTING_TRACE(">>>>>>>> %s <<<<<<<<", value);
 849                 FREE(result.value.c);
 850         } else {
 851                 SETTING_TRACE("get_vconf is failed");
 852         }
 853         *err = ret;
 854         return ret;
 855 }
 856
 857 EXPORT_PUBLIC
 858 int setting_set_string_slp_key(setting_str_slp_list key, char *value, int *err)
 859 {
 860         int ret = SETTING_RETURN_FAIL;
 861
 862         /* error check */
 863         if (key < 0 || key >= STR_SLP_LIST_MAX) {
 864                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 865                 return ret;
 866         }
 867
 868         VconfNode result;
 869         g_stable[key].value.c = value;
 870         ret = set_vconf(g_stable[key], &result);
 871         g_stable[key].value.c = "";
 872
 873         SETTING_TRACE("setting_set_str ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.c);
 874         *err = ret;
 875         return ret;
 876 }
 877
 878 /** @todo don't use i18n string directly. */
 879 static const setting_lang_entry lang_table[] = {
 880         {       "auto",                 "Automatic"},
 881         {       "ko_KR.UTF-8",  "한국어"},
 882         {       "en_US.UTF-8",  "English"},
 883         {       "zh_CN.UTF-8",  "简体中文"},
 884         {       "zh_HK.UTF-8",  "繁體中文(香港)"},
 885         {       "zh_TW.UTF-8",  "繁體中文(台灣)"},
 886         {       "de_DE.UTF-8",  "Deutsch"},
 887         {       "nl_NL.UTF-8",  "Nederlands"},
 888         {       "es_ES.UTF-8",  "Español"},
 889         {       "pt_PT.UTF-8",  "Português"},
 890         {       "el_GR.UTF-8",  "Eλληνικά"},
 891         {       "it_IT.UTF-8",  "Italiano"},
 892         {       "fr_FR.UTF-8",  "Français"},
 893         {       "tr_TR.UTF-8",  "Türkçe"},
 894         {       "ja_JP.UTF-8",  "にほんご"},
 895         {       "ru_RU.UTF-8",  "Россию"},
 896 };
 897
 898 setting_lang_entry *setting_get_language_table()
 899 {
 900         return (setting_lang_entry *)lang_table;
 901 }
 902
 903
 904 static void _parseLangListXML(char *docname);   /* internal */
 905 static void __tree_walk_langlist(xmlNodePtr cur); /* internal */
 906
 907 static Eina_List *s_langlist;                                   /* internal */
 908
 909 /* do it once */
 910 int _langlist_load(char *path)
 911 {
 912         SETTING_TRACE_BEGIN;
 913         SETTING_TRACE("language list path: %s ", path);
 914
 915         if (!s_langlist) {
 916                 _parseLangListXML(path);
 917         }
 918
 919         return 0;
 920 }
 921
 922 /* singleton */
 923 EXPORT_PUBLIC
 924 Eina_List *setting_get_language_list()
 925 {
 926         if (NULL == s_langlist) {
 927                 _langlist_load(LANGLIST_FILE_PATH);
 928         }
 929
 930         return s_langlist;
 931 }
 932
 933 /* singleton */
 934 EXPORT_PUBLIC
 935 Eina_List *setting_get_language_list2(char *path)
 936 {
 937         if (NULL == s_langlist) {
 938                 _langlist_load(path);
 939         }
 940
 941         return s_langlist;
 942 }
 943
 944
 945 int _langlist_destroy()
 946 {
 947         SETTING_TRACE_BEGIN;
 948         Eina_List *li = s_langlist;
 949         setting_lang_entry *node;
 950         while (li) {
 951                 node = (setting_lang_entry *) eina_list_data_get(li);
 952                 if (node) {
 953                         /*SETTING_TRACE("destroy nodes : locale : %s title : %s", node->locale, node->title); */
 954                         G_FREE(node->locale);
 955                         G_FREE(node->title);
 956                         G_FREE(node->mcc);
 957                         FREE(node);
 958                 }
 959                 li = eina_list_next(li);
 960         }
 961         s_langlist = eina_list_free(s_langlist);                /* returns NULL */
 962
 963         return 0;
 964 }
 965
 966 EXPORT_PUBLIC
 967 void  setting_get_language_list_destroy()
 968 {
 969         _langlist_destroy();
 970 }
 971
 972 static void _parseLangListXML(char *docname)
 973 {
 974         SETTING_TRACE_BEGIN;
 975         xmlDocPtr doc;
 976         xmlNodePtr cur;
 977
 978         doc = xmlParseFile(docname);
 979
 980         if (doc == NULL) {
 981                 fprintf(stderr, "Document not parsed successfully. \n");
 982                 return;
 983         }
 984
 985         cur = xmlDocGetRootElement(doc);
 986         if (cur == NULL) {
 987                 fprintf(stderr, "empty document\n");
 988                 xmlFreeDoc(doc);
 989                 return;
 990         }
 991
 992         /*SETTING_TRACE("ROOT NODE : %s ", cur->name); */
 993         /* make sure root node is "settings" */
 994         if (xmlStrcmp(cur->name, (const xmlChar *) "langlist")) {
 995                 SETTING_TRACE("document of the wrong type, root node != settings");
 996                 xmlFreeDoc(doc);
 997                 return;
 998         }
 999
1000         cur = cur->xmlChildrenNode;
1001         __tree_walk_langlist(cur);
1002
1003         /* save tree to file */
1004         if (doc != NULL) {
1005                 /*xmlSaveFormatFile (docname, doc, 1); */
1006                 xmlFreeDoc(doc);
1007         }
1008         /*xmlFreeDoc(doc); */
1009         return;
1010 }
1011
1012 static void __tree_walk_langlist(xmlNodePtr cur)
1013 {
1014         SETTING_TRACE_BEGIN;
1015         xmlNode *cur_node = NULL;
1016         char *id;
1017         char *string;
1018         char *mcc = NULL;
1019         /*int number = 1; */
1020
1021         for (cur_node = cur; cur_node; cur_node = cur_node->next) {
1022                 if (cur_node->type == XML_ELEMENT_NODE) {
1023
1024                         /*SETTING_TRACE(" name=%s title=%s \n", xmlGetProp(cur_node, (const xmlChar *)"id"), xmlGetProp(cur_node, (const xmlChar *)"string")); */
1025                         id = (char *)g_strdup((char *)xmlGetProp(cur_node, (const xmlChar *)"id"));
1026                         string = (char *)g_strdup((char *) xmlGetProp(cur_node, (const xmlChar *)"string"));
1027                         /*SETTING_TRACE_DEBUG("lang: %s", xmlGetProp(cur_node, (const xmlChar *)"lang")); */
1028                         mcc = (char *)g_strdup((char *) xmlGetProp(cur_node, (const xmlChar *)"mcc"));
1029                         /*number = atoi((char*) xmlGetProp(cur_node, (const xmlChar *)"no")); */
1030
1031                         setting_lang_entry *pitem = (setting_lang_entry *)calloc(1, sizeof(setting_lang_entry));
1032                         setting_retm_if(NULL == pitem, "ptiem is NULL");
1033                         pitem->locale = id;
1034                         pitem->title = string;
1035                         pitem->mcc = mcc;
1036                         /*pitem->number = number++; */
1037                         /*SETTING_TRACE_DEBUG("no=%d", pitem->number); */
1038                         /*SETTING_TRACE_DEBUG(">>>> locale: %s title: %s mcc: %s", pitem->locale, pitem->title, pitem->mcc); */
1039                         s_langlist = eina_list_append(s_langlist, pitem);
1040                 }
1041         }
1042 }
1043 /*----------------------------------------------------------------------------------------------- */
1044 /*----------------------------------------------------------------------------------------------- */
1045
1046 /*setting_lang_entry* */
1047
1048 /*//////////////////////////////////////////////////////////////////////////////////////// */
1049 int setting_store_init_password(char *in)
1050 {
1051
1052         SHA256_CTX context;
1053         char md[SHA256_DIGEST_LENGTH] = {0,};
1054         /* int i = 0; */
1055         int ret = SETTING_RETURN_FAIL;
1056
1057         SHA256_Init(&context);
1058         SHA256_Update(&context, (char *)in, strlen(in));
1059         SHA256_Final((unsigned char *)md, &context);
1060
1061 #ifdef DEBUG
1062         SETTING_TRACE("input: [%s]\n", in);
1063         SETTING_TRACE("output: [");
1064         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
1065                 SETTING_TRACE("%02x", md[i]);
1066         SETTING_TRACE("]\n");
1067 #endif
1068
1069         /*  create a file or store a data */
1070         /*  store_password */
1071         FILE *fp = NULL;
1072         int ret_fw = 0;
1073         fp = fopen(PWD_FILE, "w+");
1074         if (fp) {
1075                 ret_fw = fwrite(md, 1, SHA256_DIGEST_LENGTH, fp);
1076                 SETTING_TRACE_DEBUG("fwrite() wrote %d chars.", ret_fw);
1077                 if (ret_fw == SHA256_DIGEST_LENGTH) {
1078                         fflush(fp);
1079                         fsync(fp->_fileno);
1080                         ret = SETTING_RETURN_SUCCESS;
1081                 }
1082                 fclose(fp);
1083         } else {
1084                 SETTING_TRACE("ERR: pwd file is not exist \n");
1085         }
1086
1087         return ret;
1088 }
1089
1090 int setting_read_password(char *md_result)
1091 {
1092         SETTING_TRACE_BEGIN;
1093         /* int i; */
1094         FILE *fp = NULL;
1095         fp = fopen(PWD_FILE, "r");
1096         if (fp) {
1097                 int size = fread(md_result, sizeof(char), SHA256_DIGEST_LENGTH, fp);
1098                 if (size != SHA256_DIGEST_LENGTH) {
1099                         SETTING_TRACE_ERROR("fread failed");
1100                 }
1101                 fclose(fp);
1102         } else {
1103                 SETTING_TRACE("ERR: pwd file is not exist \n");
1104                 return SETTING_RETURN_FAIL;
1105         }
1106
1107 #ifdef DEBUG
1108         SETTING_TRACE("output from file: [");
1109         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
1110                 SETTING_TRACE("%02x", md_result[i]);
1111         SETTING_TRACE("]\n");
1112 #endif
1113         SETTING_TRACE_END;
1114         return 0;
1115 }
1116
1117 int setting_compare_password(char *md_result, const char *in_later)
1118 {
1119         SETTING_TRACE_BEGIN;
1120         SHA256_CTX context_later;
1121         char md_later[SHA256_DIGEST_LENGTH];
1122         int ret = SETTING_RETURN_FAIL;
1123
1124         SHA256_Init(&context_later);
1125         SHA256_Update(&context_later, (char *)in_later, strlen(in_later));
1126         SHA256_Final((unsigned char *)md_later, &context_later);
1127
1128         SETTING_TRACE(" :[ %25s ]", in_later);
1129
1130         if (0 == memcmp(md_later, md_result, SHA256_DIGEST_LENGTH)) {
1131                 SETTING_TRACE("two passwords are same \n");
1132                 ret = 0;
1133         } else {
1134                 SETTING_TRACE("two passwords are different \n");
1135         }
1136         return ret;
1137 }
1138
1139 EXPORT_PUBLIC
1140 void setting_destory_listen_list(Eina_List **listened_list)
1141 {
1142         if (listened_list && *listened_list) {
1143                 Vconf_Change_Node *node = NULL;
1144                 Eina_List *li = *listened_list;
1145                 while (li) {
1146                         node = (Vconf_Change_Node *) eina_list_data_get(li);
1147                         if (node) {
1148                                 /*SETTING_TRACE("Deregister callback[%p] of %s", node->cb, node->in_key); */
1149                                 if (node->in_key && node->cb) {
1150                                         (void)vconf_ignore_key_changed(node->in_key, node->cb);
1151                                         FREE(node);
1152                                 }
1153                         }
1154                         li = eina_list_next(li);
1155                 }
1156                 *listened_list = eina_list_free(*listened_list);
1157         }
1158 }
1159
1160 EXPORT_PUBLIC
1161 bool setting_add_listen_node(Eina_List **listened_list, const char *vconf, vconf_callback_fn cb, void *data)
1162 {
1163         Vconf_Change_Node *node = calloc(1, sizeof(Vconf_Change_Node));
1164         bool ret = TRUE;
1165         if (node && vconf && cb) {
1166                 node->in_key = vconf;
1167                 node->cb = cb;
1168                 node->cb_data = data;
1169
1170                 if (0 == vconf_notify_key_changed(vconf, cb, data)) {
1171                         /*SETTING_TRACE("Register callback[%p] of %s", node->cb, node->in_key); */
1172                         *listened_list = eina_list_append(*listened_list, node);
1173                 } else {
1174                         SETTING_TRACE_ERROR("Failed to register callback[%p] of %s", node->cb, node->in_key);
1175                         ret = FALSE;
1176                 }
1177         }
1178         FREE(node);
1179         return ret;
1180 }
1181