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

   1 /*
   2  * setting
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Flora License, Version 1.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://floralicense.org/license/
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an AS IS BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include <setting-common-data-slp-setting.h>
  18 #include <Elementary.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <openssl/sha.h>
  22
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26
  27 #include <stdlib.h>
  28 #include <libxml/xmlmemory.h>
  29 #include <libxml/parser.h>
  30 #include <libxml/tree.h>
  31 #include <glib.h>
  32
  33 #define EXPORT_FILE "/opt/data/setting/setting_export.xml"
  34
  35
  36 //#include <setting-backup-restore.h>
  37
  38 typedef enum
  39 {
  40         eBOOL,
  41         eINT,
  42         eSTRING,
  43 }vconftype;
  44
  45 typedef union {
  46         int i;
  47         bool b;
  48         char* c;
  49 } vconfval;
  50
  51
  52 typedef struct VconfNode VconfNode;
  53 struct VconfNode
  54 {
  55         int key;                                                                /** vconf id definded in Setting app */
  56         const char* vconf_key;                                  /** vconf string defined in libslp-setting */
  57         vconftype type;                                                 /** BOOL, INT, STRING */
  58         vconfval value;                                                 /** variable by union */
  59         void (*export)(VconfNode* pnode, xmlNodePtr* root_node);                /** method for exporting current state */
  60         void (*import)(VconfNode* pnode, xmlNodePtr* root_node);                /** method for importing state from cloud */
  61 };
  62
  63 int get_vconf(VconfNode node, VconfNode* result);
  64
  65 // export function for each vconf key
  66 void export_default(VconfNode* node, xmlNodePtr* root_node)
  67 {
  68         if (node)
  69         {
  70                 char *val = NULL;
  71                 char *type = NULL;
  72
  73                 char arr[1024];
  74                 if(node->vconf_key == NULL) return; /* NO DOTHING IF null */
  75                 VconfNode result;
  76                 switch(node->type)
  77                 {
  78                 case eBOOL:
  79                         SETTING_TRACE("EXPORTING key : %s : %d : %d",node->vconf_key, node->type, node->value.b);
  80                         // call vconf_get
  81
  82                         get_vconf(*node, &result);
  83
  84                         val = "boolval";
  85                         type = "bool";
  86                         if (result.value.b)
  87                                 val = "true";
  88                         else
  89                                 val = "false";
  90
  91                         break;
  92                 case eINT:
  93                         SETTING_TRACE("EXPORTING key : %s : %d : %d",node->vconf_key, node->type, node->value.i);
  94                         // call vconf_get
  95                         get_vconf(*node, &result);
  96                         type = "int";
  97
  98                         SETTING_TRACE(">>(%d)<<",result.value.i);
  99                         sprintf(arr, "%d", result.value.i);
 100                         //node->value.i
 101                         val = arr;
 102                         break;
 103                 case eSTRING:
 104                         SETTING_TRACE("EXPORTING key : %s : %d : %s",node->vconf_key, node->type, node->value.c);
 105                         // call vconf_get
 106                         get_vconf(*node, &result);
 107                         val = result.value.c;
 108                         type = "string";
 109                         break;
 110                 }
 111
 112                 xmlNodePtr xmlnode = xmlNewChild(*root_node, NULL, BAD_CAST "config", BAD_CAST val);
 113                 xmlNewProp(xmlnode, BAD_CAST "key", BAD_CAST node->vconf_key);
 114                 xmlNewProp(xmlnode, BAD_CAST "type", BAD_CAST type);
 115                 xmlAddChild(*root_node, xmlnode);
 116         }
 117 }
 118
 119 static void __tree_walk_exported_file(xmlNodePtr cur,
 120                                 status_handler_fp fp, void* data)
 121 {
 122         SETTING_TRACE_BEGIN;
 123         xmlNode *cur_node = NULL;
 124         char* key;
 125         char* type;
 126
 127         // how to get the all size of elements
 128         int total = 0;
 129         for (cur_node = cur; cur_node;cur_node = cur_node->next) {
 130                 char* temp = xmlGetProp(cur_node, (const xmlChar *)"key");
 131                 // count only if key is not NULL
 132                 if (temp)
 133                         total += 1;
 134         }
 135
 136         int count;
 137         for (count=0, cur_node = cur; cur_node;cur_node = cur_node->next) {
 138                 if (cur_node->type == XML_ELEMENT_NODE) {
 139
 140                         char* temp = xmlGetProp(cur_node, (const xmlChar *)"key");
 141                         if (temp)
 142                         {
 143                                 key = (char *)g_strdup((char*)xmlGetProp(cur_node, (const xmlChar *)"key"));
 144                                 type = (char *)g_strdup((char*) xmlGetProp(cur_node, (const xmlChar *)"type"));
 145
 146                                 SETTING_TRACE(" key=%s type=%s value=%s \n", xmlGetProp(cur_node, (const xmlChar *)"key"),
 147                                                         xmlGetProp(cur_node, (const xmlChar *)"type"),
 148                                                         xmlNodeGetContent(cur_node));
 149
 150                                 count += 1;
 151                                 if (fp)
 152                                 {
 153                                         fp(total, count, data);
 154                                 }
 155
 156                         }
 157                 }
 158         }
 159 }
 160
 161 // /opt/data/setting/aaa.xml
 162 // import function for each vconf key
 163 void import_default(VconfNode* node, xmlNodePtr* root_node)
 164 {
 165         switch(node->type)
 166         {
 167         case eBOOL:
 168                 SETTING_TRACE("IMPORTING key : %s : %d : %d",node->vconf_key, node->type, node->value);
 169                 break;
 170         case eINT:
 171                 SETTING_TRACE("IMPORTING key : %s : %d : %d",node->vconf_key, node->type, node->value);
 172                 break;
 173         case eSTRING:
 174                 SETTING_TRACE("IMPORTING key : %s : %d : %s",node->vconf_key, node->type, node->value);
 175                 break;
 176         }
 177 }
 178
 179 /** bool vconf table */
 180 static VconfNode g_btable[] = {
 181
 182                 {BOOL_SLP_SETTING_POWER_ON_LOCK, VCONFKEY_SETAPPL_STATE_POWER_ON_LOCK_BOOL, eBOOL, {0}, export_default, import_default}, // node[0]
 183                 {BOOL_SLP_SETTING_SIMPLE_PASSWORD, VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, eBOOL, {0}, export_default, import_default}, // node[0]
 184
 185                 {BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, eBOOL,{0}, export_default, import_default},
 186
 187
 188                 {BOOL_SLP_SETTING_TRANSACTION_TRACKING, VCONFKEY_SETAPPL_STATE_TRANSACTION_TRACKING_BOOL, eBOOL,{0}, export_default, import_default},
 189
 190
 191                 {BOOL_SLP_SETTING_EXPIRY_REMINDER, VCONFKEY_SETAPPL_STATE_EXPIRY_REMINDER_BOOL, eBOOL,{0}, export_default, import_default},
 192
 193                 //{BOOL_SLP_SETTING_FLIGHT_MODE, VCONFKEY_SETAPPL_FLIGHT_MODE_BOOL, eBOOL,{0}, export_default, import_default},
 194                 {BOOL_SLP_SETTING_FLIGHT_MODE, VCONFKEY_TELEPHONY_FLIGHT_MODE, eBOOL,{0}, export_default, import_default},
 195                 {BOOL_SLP_SETTING_DATA_ROAMING, VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, eBOOL,{0}, export_default, import_default},
 196                 {BOOL_SLP_SETTING_NFC_STATUS,VCONFKEY_NFC_STATE, eBOOL, {0}, export_default, import_default},
 197
 198                 {BOOL_SLP_SETTING_USE_PACKET_DATA, VCONFKEY_3G_ENABLE, eBOOL,{0}, export_default, import_default},
 199                 {BOOL_SLP_SETTING_ACCESSIBILITY_HIGH_CONTRAST, VCONFKEY_SETAPPL_ACCESSIBILITY_HIGH_CONTRAST, eBOOL,{0}, export_default, import_default},
 200                 {BOOL_SLP_SETTING_ACCESSIBILITY_SCREEN_ZOOM, VCONFKEY_SETAPPL_ACCESSIBILITY_SCREEN_ZOOM, eBOOL,{0}, export_default, import_default},
 201                 {BOOL_SLP_SETTING_ACCESSIBILITY_ASSISTIVE_LIGHT, VCONFKEY_SETAPPL_ACCESSIBILITY_TORCH_LIGHT, eBOOL,{0}, export_default, import_default},
 202                 {BOOL_SLP_SETTING_ACCESSIBILITY_MONO_AUDIO, VCONFKEY_SETAPPL_ACCESSIBILITY_MONO_AUDIO, eBOOL,{0}, export_default, import_default},
 203                 //{BOOL_SLP_SETTING_ACCESSIBILITY_TURN_OFF_ALL_SOUNDS, VCONFKEY_SETAPPL_TURN_OFF_ALL_SOUNDS_BOOL, eBOOL,{0}, export_default, import_default},
 204                 {BOOL_SLP_SETTING_ACCESSIBILITY_LED_NOTIFY, VCONFKEY_SETAPPL_ACCESSIBILITY_LED_NOTIFY, eBOOL,{0}, export_default, import_default},
 205                 {BOOL_SLP_SETTING_ACCESSIBILITY_ACCEPT_CALL, VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL, eBOOL,{0}, export_default, import_default},
 206                 {BOOL_SLP_SETTING_ACCESSIBILITY_POWERKEY_END_CALLS, VCONFKEY_CISSAPPL_POWER_KEY_ENDS_CALL_BOOL, eBOOL,{0}, export_default, import_default},
 207
 208                 //------------------------------------------------------------------------------------------------
 209                 {SETTING_BOOL_SLP_LIST_MAX, NULL, eBOOL, {0}, export_default, import_default},
 210 };
 211
 212
 213 /** int vconf table */
 214 static VconfNode g_itable[] = {
 215                 {INT_SLP_SETTING_LCD_BRIGHTNESS, VCONFKEY_SETAPPL_LCD_BRIGHTNESS, eINT, {0}, export_default, import_default},
 216                 {INT_SLP_SETTING_LCD_TIMEOUT_NORMAL,VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, eINT, {0}, export_default, import_default},
 217                 {INT_SLP_SETTING_LCD_TIMEOUT_NORMAL_BACKUP,VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, eINT, {0}, export_default, import_default},
 218
 219                 {INT_SLP_SETTING_AUTOMATIC_BRIGHTNESS, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, eINT,{0}, export_default, import_default},
 220
 221                 {INT_SLP_SETTING_SELECT_NETWORK,VCONFKEY_SETAPPL_SELECT_NETWORK_INT, eINT, {0}, export_default, import_default},
 222                 {INT_SLP_SETTING_NETWORK_MODE,VCONFKEY_SETAPPL_NETWORK_MODE_INT, eINT, {0}, export_default, import_default},
 223                 {INT_SLP_SETTING_REGIONFORMAT_TIME1224,VCONFKEY_REGIONFORMAT_TIME1224, eINT, {0}, export_default, import_default},
 224                 {INT_SLP_SETTING_DATE_FORMAT,VCONFKEY_SETAPPL_DATE_FORMAT_INT, eINT, {0}, export_default, import_default},
 225                 {INT_SLP_SETTING_WEEK_FORMAT,VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, eINT, {0}, export_default, import_default},
 226                 /* CALL_ALERT_TYPE */
 227 //              {INT_SLP_SETTING_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 228 //              {INT_SLP_SETTING_NORMAL_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 229 //              {INT_SLP_SETTING_SILENT_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 230 //              {INT_SLP_SETTING_DRIVING_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 231 //              {INT_SLP_SETTING_MEETING_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 232 //              {INT_SLP_SETTING_OUTDOOR_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 233                 /* CALL_ALERT_VIB */
 234                 {INT_SLP_SETTING_CALL_ALERT_VIB, VCONFKEY_SETAPPL_CALL_VIBRATION_PATTERN_INT, eINT, {0}, export_default, import_default},
 235 //              {INT_SLP_SETTING_NORMAL_CALL_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 236 //              {INT_SLP_SETTING_SILENT_CALL_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 237 //              {INT_SLP_SETTING_DRIVING_CALL_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 238 //              {INT_SLP_SETTING_MEETING_CALL_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 239 //              {INT_SLP_SETTING_OUTDOOR_CALL_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 240
 241                 /*****/
 242 //              {INT_SLP_SETTING_CALL_ALERT_VOLUME, NULL, eINT, {0}, export_default, import_default},
 243                 /* MSG_ALERT_TYPE */
 244 //              {INT_SLP_SETTING_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 245 //              {INT_SLP_SETTING_NORMAL_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 246 //              {INT_SLP_SETTING_SILENT_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 247 //              {INT_SLP_SETTING_DRIVING_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 248 //              {INT_SLP_SETTING_MEETING_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 249 //              {INT_SLP_SETTING_OUTDOOR_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default, import_default},
 250 //              /* MSG_ALERT_VIB */
 251 //              {INT_SLP_SETTING_MSG_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 252 //              {INT_SLP_SETTING_NORMAL_MSG_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 253 //              {INT_SLP_SETTING_SILENT_MSG_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 254 //              {INT_SLP_SETTING_DRIVING_MSG_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 255 //              {INT_SLP_SETTING_MEETING_MSG_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 256 //              {INT_SLP_SETTING_OUTDOOR_MSG_ALERT_VIB, NULL, eINT, {0}, export_default, import_default},
 257
 258                 /*****/
 259                 {INT_SLP_SETTING_MSG_ALERT_REPEAT,VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, eINT, {0}, export_default, import_default},
 260                 {INT_SLP_SETTING_EMAIL_ALERT_REPEAT,VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT, eINT, {0}, export_default, import_default},
 261
 262                 /*****/
 263 //              {INT_SLP_SETTING_MSG_ALERT_VOLUME, NULL, eINT, {0}, export_default, import_default},
 264 //              {INT_SLP_SETTING_SYS_TOUCH_SOUND, NULL, eINT, {0}, export_default, import_default},
 265 //              {INT_SLP_SETTING_SYS_TOUCH_SOUND_VOLUME, NULL, eINT, {0}, export_default, import_default},
 266                 {INT_SLP_SETTING_FONT_SIZE,VCONFKEY_SETAPPL_FONT_SIZE_INT, eINT, {0}, export_default, import_default},
 267                 {INT_SLP_SETTING_FONT_TYPE,VCONFKEY_SETAPPL_FONT_TYPE_INT, eINT, {0}, export_default, import_default},
 268                 {INT_SLP_SETTING_LANG,VCONFKEY_SETAPPL_LANG_INT, eINT, {0}, export_default, import_default},
 269                 {INT_SLP_SETTING_BT_STATUS,VCONFKEY_BT_STATUS, eINT, {0}, export_default, import_default},
 270                 {INT_SLP_SETTING_WIFI_STATUS,VCONFKEY_WIFI_STATE, eINT, {0}, export_default, import_default},
 271                 //{INT_SLP_SETTING_MOBILE_AP_STATUS,VCONFKEY_MOBILE_HOTSPOT_MODE, eINT, {0}, export_default, import_default},
 272                 {INT_SLP_SETTING_ROAMING_NETWORK,VCONFKEY_SETAPPL_ROAMING_NETWORK_INT, eINT, {0}, export_default, import_default},
 273                 {INT_SLP_SETTING_USB_MODE,VCONFKEY_SETAPPL_USB_MODE_INT, eINT, {0}, export_default, import_default},
 274 #ifdef UNUSED_VCONFKEY
 275                 {INT_SLP_SETTING_TASKSWITCHER_VIEWTYPE,VCONFKEY_TASKSWITCHER_VIEWTYPE, eINT, {0}, export_default, import_default},
 276 #endif
 277                 /* memory */
 278                 {INT_SLP_SETTING_DEFAULT_MEM_WAP,VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, eINT, {0}, export_default, import_default},
 279                 {INT_SLP_SETTING_DEFAULT_MEM_BLUETOOTH,VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, eINT, {0}, export_default, import_default},
 280                 {INT_SLP_SETTING_DEFAULT_MEM_CAMERA,VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, eINT, {0}, export_default, import_default},
 281                 {INT_SLP_SETTING_DEFAULT_MEM_VOICE_RECORDER,VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, eINT, {0}, export_default, import_default},
 282                 {INT_SLP_SETTING_DEFAULT_MEM_FM_RADIO,VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, eINT, {0}, export_default, import_default},
 283                 {INT_SLP_SETTING_DEFAULT_MEM_ALL_SHARE,VCONFKEY_SETAPPL_DEFAULT_MEM_ALL_SHARE_INT, eINT, {0}, export_default, import_default},
 284                 {INT_SLP_SETTING_DEFAULT_MEM_ADOBE_AIR,VCONFKEY_SETAPPL_DEFAULT_MEM_ADOBE_AIR_INT, eINT, {0}, export_default, import_default},
 285                 {INT_SLP_SETTING_DEFAULT_MEM_DVB_H,VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, eINT, {0}, export_default, import_default},
 286
 287                 /* other module */
 288                 {INT_SLP_SETTING_SIM_SLOT,VCONFKEY_TELEPHONY_SIM_SLOT, eINT, {0}, export_default, import_default},
 289                 {INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT,VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT, eINT, {0}, export_default, import_default},
 290                 {INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT,VCONFKEY_SETAPPL_SIM_LOCK_ATTEMPTS_LEFT_INT, eINT, {0}, export_default, import_default},
 291
 292                 // accessibility setting
 293                 {INT_SLP_SETTING_ACCESSIBILITY_ENABLE_AUTO_ANSWER, VCONFKEY_CISSAPPL_ANSWERING_MODE_INT, eINT,{0}, export_default, import_default},
 294                 {INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, eINT, {0}, export_default, import_default},
 295 #if SUPPORT_FONT_STYLE
 296                 {INT_SLP_SETTING_ACCESSIBILITY_FONT_STYLE,VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_STYLE, eINT, {0}, export_default, import_default},
 297 #endif
 298                 {INT_SLP_SETTING_ACCESSIBILITY_AUTO_ANSWER,     VCONFKEY_CISSAPPL_ANSWERING_MODE_TIME_INT, eINT, {0}, export_default, import_default},
 299                 {INT_SLP_SETTING_ACCESSIBILITY_POWER_KEY_HOLD, VCONFKEY_SETAPPL_ACCESSIBILITY_POWER_KEY_HOLD, eINT, {0}, export_default, import_default},
 300
 301                 //powersaving
 302                 {INT_SLP_SETTING_POWERSAVING_AT, VCONFKEY_SETAPPL_PWRSV_CUSTMODE_AT, eINT, {0}, export_default, import_default},
 303                 {INT_SLP_SETTING_POWERSAVING_SCREEN_TIMEOUT, VCONFKEY_SETAPPL_PWRSV_CUSTMODE_BLTIME, eINT, {0}, export_default, import_default},
 304                 {INT_SLP_SETTING_DEVOPTION_BGPROCESS, VCONFKEY_SETAPPL_DEVOPTION_BGPROCESS, eINT, {0}, export_default, import_default},
 305
 306                 // data usage
 307                 {INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, VCONFKEY_SETAPPL_DATA_EACH_MONTH_INT, eINT, {0}, export_default, import_default},
 308                 {SETTING_INT_SLP_LIST_MAX, NULL, eINT, {0}, export_default, import_default},
 309 };
 310
 311
 312 /** string vconf table */
 313 static VconfNode g_stable[] = {
 314                     /* password code - special processing */
 315                 {       STR_SLP_LIST_PHONE_PASSWORD, NULL, eSTRING,{0}, export_default, import_default },
 316                 {       STR_SLP_SETTING_PHONE_LOCK_TIMESTAMP,VCONFKEY_SETAPPL_PHONE_LOCK_TIMESTAMP_STR, eSTRING,{0}, export_default, import_default },
 317                 {       STR_SLP_SETTING_SIM_LOCK_TIMESTAMP,VCONFKEY_SETAPPL_SIM_LOCK_TIMESTAMP_STR, eSTRING,{0}, export_default, import_default },
 318                 {       STR_SLP_SETTING_SELECT_NUM,VCONFKEY_SETAPPL_SELECTED_NUM, eSTRING,{0}, export_default, import_default },
 319                 {       STR_SLP_LIST_MAX, NULL, eSTRING, {0}, export_default, import_default},
 320 };
 321
 322
 323 /**
 324  * export
 325  */
 326 int sync_adapter_backup_get_data(void **data, unsigned long long *size)
 327 {
 328         char *hello_string = "Hello World";
 329
 330         *data = strdup(hello_string);
 331         *size = strlen(hello_string);
 332
 333         return 0;
 334 }
 335
 336 /**
 337  * import
 338  */
 339 int sync_adapter_restore_set_data(void *data, unsigned long long size)
 340 {
 341
 342         if(size <=  0)
 343                 printf("error\n");
 344
 345         printf("%s: data is %s\n", __func__, (char *)data);
 346         printf("%s: size is %lld\n", __func__, size);
 347         return 0;
 348 }
 349
 350
 351 /**
 352  * cloud --> setting
 353  */
 354 void setting_import(status_handler_fp fp, void* data)
 355 {
 356     xmlDocPtr doc;
 357     xmlNodePtr cur;
 358     doc = xmlParseFile(EXPORT_FILE);
 359
 360     if (doc == NULL ) {
 361         fprintf(stderr,"Document not parsed successfully. \n");
 362         return;
 363     }
 364
 365     cur = xmlDocGetRootElement(doc);
 366     if (cur == NULL) {
 367         fprintf(stderr,"empty document\n");
 368         xmlFreeDoc(doc);
 369         return;
 370     }
 371
 372     printf("ROOT NODE : %s \n", cur->name);
 373     // make sure root node is "settings"
 374     if (xmlStrcmp(cur->name, (const xmlChar *) "settingconf")) {
 375         SETTING_TRACE("document of the wrong type, root node != settings");
 376         xmlFreeDoc(doc);
 377         return;
 378     }
 379
 380     cur = cur->xmlChildrenNode;
 381
 382     __tree_walk_exported_file(cur, fp, data);
 383
 384     /* save tree to file */
 385     if (doc != NULL) {
 386         //xmlSaveFormatFile (docname, doc, 1);
 387         xmlFreeDoc(doc);
 388     }
 389 }
 390
 391
 392
 393
 394 /**
 395  * setting --> cloud
 396  *
 397  * int status_handler(int total, int current,  void* data);
 398  */
 399 void setting_export(status_handler_fp fp, void* data)
 400 {
 401         // int sync_adapter_backup_get_data(void **data, unsigned long long *size)
 402         xmlDocPtr doc = NULL;       /* document pointer */
 403         xmlNodePtr root_node = NULL;/* node pointers */
 404         //xmlDtdPtr dtd = NULL;       /* DTD pointer */
 405
 406         LIBXML_TEST_VERSION;
 407
 408         doc = xmlNewDoc(BAD_CAST "1.0");
 409         root_node = xmlNewNode(NULL, BAD_CAST "settingconf");
 410         //assert(doc == NULL);
 411         xmlDocSetRootElement(doc, root_node);
 412
 413         int icount = sizeof(g_itable)/ sizeof(g_itable[0]);
 414         int bcount = sizeof(g_btable)/ sizeof(g_btable[0]);
 415         int scount = sizeof(g_stable)/ sizeof(g_stable[0]);
 416
 417         int total = icount + bcount + scount;
 418
 419 #if 1
 420         int i = 0;
 421         for (i=0;i<SETTING_BOOL_SLP_LIST_MAX;i++) {
 422                 if (g_btable[i].vconf_key)
 423                 {
 424                         SETTING_TRACE("exporting bool keys : %s ", g_btable[i].vconf_key );
 425                         // run export function --> store data into XML
 426                         g_btable[i].export(&g_btable[i], &root_node);
 427                         if (fp)
 428                         {
 429                                 fp(total, i, NULL);
 430                         }
 431                 }
 432                 else {
 433                         total -= 1;
 434                 }
 435         }
 436
 437         int j=0;
 438         for (j=0;j<STR_SLP_LIST_MAX;j++) {
 439                 if (g_stable[j].vconf_key)
 440                 {
 441                         SETTING_TRACE("exporting string keys : %s ", g_stable[j].vconf_key );
 442                         // run export function --> store data into XML
 443                         g_stable[j].export(&g_stable[j], &root_node);
 444                         if (fp)
 445                         {
 446                                 fp(total, i+j, NULL);
 447                         }
 448                 }
 449                 else {
 450                         total -= 1;
 451                 }
 452         }
 453
 454         int k=0;
 455         for (k=0;k<SETTING_INT_SLP_LIST_MAX;k++) {
 456                 if (g_itable[k].vconf_key)
 457                 {
 458                         SETTING_TRACE("exporting int keys : %s ", g_itable[k].vconf_key );
 459                         // run export function --> store data into XML
 460                         g_itable[k].export(&g_itable[k], &root_node);
 461                         if (fp)
 462                         {
 463                                 fp(total, i+j+k, NULL);
 464                         }
 465                 }
 466                 else {
 467                         total -= 1;
 468                 }
 469         }
 470
 471 #endif
 472
 473         // Dumping document to stdio or file
 474         // ./new_tree aaa.xml
 475         //xmlSaveFormatFileEnc(argc > 1 ? argv[1] : "-", doc, "UTF-8", 1);
 476         if (doc == NULL)
 477         {
 478                 SETTING_TRACE("doc is NULL ");
 479         }
 480         xmlSaveFormatFileEnc(EXPORT_FILE, doc, "UTF-8", 1);
 481
 482         // free the document
 483         xmlFreeDoc(doc);
 484
 485         // Free the global variables that may
 486         // have been allocated by the parser.
 487         xmlCleanupParser();
 488
 489         // this is to debug memory for regression tests
 490         xmlMemoryDump();
 491
 492         // idea
 493         // create xml file buffer
 494         // data <- the xml buffer
 495         // int sync_adapter_backup_get_data(void **data, unsigned long long *size)
 496 }
 497
 498
 499 int set_vconf(VconfNode node,VconfNode *result)
 500 {
 501         SETTING_TRACE_BEGIN;
 502         int ret = -1 ;
 503         //node.key
 504         //node.vconf_key
 505         *result = node;
 506         switch(node.type)
 507         {
 508         case eBOOL:
 509                 SETTING_TRACE("begin case eBOOL[%s=\"%d\"]", node.vconf_key, node.value.b);
 510                 ret = vconf_set_bool(node.vconf_key, node.value.b);
 511                 result->type = eBOOL;
 512                 result->value.b = node.value.b;
 513                 break;
 514         case eINT:
 515                 SETTING_TRACE("begin case eINT[%s=\"%d\"]", node.vconf_key, node.value.i);
 516                 ret = vconf_set_int(node.vconf_key, node.value.i);
 517                 result->type = eINT;
 518                 result->value.i = node.value.i;
 519                 break;
 520         case eSTRING:
 521                 if (node.key == STR_SLP_LIST_PHONE_PASSWORD) {
 522                         ret = setting_store_init_password(node.value.c);
 523                 } else {
 524                         SETTING_TRACE("begin case eSTRING[%s=\"%s\"]", node.vconf_key, node.value.c);
 525                         ret = vconf_set_str(node.vconf_key, node.value.c);
 526                 }
 527                 result->type = eSTRING;
 528                 result->value.c = node.value.c;
 529                 break;
 530         default:
 531                 SETTING_TRACE_ERROR(">>>>>>>>>> node.type is NOT DEFINED");
 532                 break;
 533         }
 534
 535         if (0 != ret)
 536         {
 537                 SETTING_TRACE_ERROR(">>>>>>>>>> Failed to set vconf[%s]", node.vconf_key);
 538         }
 539         //SETTING_TRACE("KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result->key, result->vconf_key, result->type, result->value.i);
 540         return ret;
 541 }
 542
 543
 544 int get_vconf(VconfNode node, VconfNode* result)
 545 {
 546         int ret = -1 ;
 547
 548         char md_result[SHA256_DIGEST_LENGTH];
 549         memset(md_result, 0x0, SHA256_DIGEST_LENGTH);
 550
 551
 552         *result = node;
 553
 554         switch(node.type)
 555         {
 556         case eBOOL:
 557                 ret = vconf_get_bool(node.vconf_key, (int *)(&(node.value.b)));
 558                 result->type = eBOOL;
 559                 result->value.b = node.value.b;
 560                 break;
 561         case eINT:
 562                 ret = vconf_get_int(node.vconf_key, &(node.value.i));
 563                 result->type = eINT;
 564                 result->value.i = node.value.i;
 565                 break;
 566         case eSTRING:
 567                 if (node.key == STR_SLP_LIST_PHONE_PASSWORD)
 568                 {
 569                         node.value.c = (char*)malloc(sizeof(char) * SHA256_DIGEST_LENGTH);
 570                         if (node.value.c) {
 571                                 memset(node.value.c, 0x0, SHA256_DIGEST_LENGTH);
 572                         } else {
 573                                 SETTING_TRACE_ERROR(" malloc filed : eSTRING, node.value.c ");
 574                                 ret = SETTING_RETURN_FAIL;
 575                                 goto endtag;
 576                         }
 577
 578                         if (setting_read_password(md_result) == 0) {
 579                                 memcpy(node.value.c, md_result, SHA256_DIGEST_LENGTH); /*  un-safe */
 580
 581                                 result->type = eSTRING;
 582                                 result->value.c = node.value.c;
 583                                 ret = SETTING_RETURN_SUCCESS;
 584                         } else {
 585                                 /*do nothing */
 586                                 ret = SETTING_RETURN_FAIL;
 587                                 goto endtag;
 588                         }
 589                 } else {
 590                         node.value.c = vconf_get_str(node.vconf_key);
 591                         SETTING_TRACE("string type ---> %s ", node.value.c);
 592                         result->type = eSTRING;
 593                         result->value.c = node.value.c;
 594                         ret = SETTING_RETURN_SUCCESS;
 595                 }
 596                 break;
 597         default:
 598                 SETTING_TRACE_ERROR(">>>>>>>>>>>>>>>>>>>>>>> get vconf ERROR : %s ", node.vconf_key );
 599         }
 600 endtag:
 601         return ret;
 602 }
 603
 604 int setting_set_bool_slp_key(setting_bool_slp_list key, int value, int *err)
 605 {
 606         //SETTING_TRACE_BEGIN;
 607         int ret = SETTING_RETURN_FAIL;
 608
 609         /* error check */
 610         if (key < 0 || key >= SETTING_BOOL_SLP_LIST_MAX) {
 611                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 612                 return ret;
 613         }
 614
 615         VconfNode result;
 616         g_btable[key].value.b = value;
 617         ret = set_vconf(g_btable[key],&result);
 618
 619         SETTING_TRACE("setting_set_bool ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.b);
 620         return ret;
 621 }
 622
 623 int setting_get_bool_slp_key(setting_bool_slp_list key, int *value, int *err)
 624 {
 625         //SETTING_TRACE_BEGIN;
 626         int ret = SETTING_RETURN_FAIL;
 627
 628         /* error check */
 629         if (key < 0 || key >= SETTING_BOOL_SLP_LIST_MAX) {
 630                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 631                 SETTING_TRACE_ERROR(" <<<<<<<< key is invalid >>>>>>>>>>>>> ");
 632                 return ret;
 633         }
 634         VconfNode result;
 635         ret = get_vconf(g_btable[key], &result);
 636         //*value = g_btable[key].value.b;
 637         *value = result.value.b;
 638         return ret;
 639 }
 640
 641 int setting_set_int_slp_key(setting_int_slp_list key, int value, int *err)
 642 {
 643         //SETTING_TRACE_BEGIN;
 644         int ret = SETTING_RETURN_FAIL;
 645
 646         /* error check */
 647         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 648                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 649                 SETTING_TRACE(">>> key is invalid ");
 650                 return ret;
 651         }
 652
 653         VconfNode result;
 654         g_itable[key].value.i = value;
 655         ret = set_vconf(g_itable[key],&result);
 656         *err = ret;
 657         SETTING_TRACE("setting_set_int ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.i);
 658         return ret;
 659 }
 660
 661 /* return -1: fail  cannot use err to check the result, return value instead*/
 662 int setting_get_int_slp_key(setting_int_slp_list key, int *value, int *err)
 663 {
 664         //SETTING_TRACE_BEGIN;
 665         int ret = SETTING_RETURN_FAIL;
 666
 667         /* error check */
 668         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 669                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 670                 return ret;
 671         }
 672
 673         VconfNode result;
 674         ret = get_vconf(g_itable[key], &result);
 675         //*value = g_itable[key].value.i;
 676         *value = result.value.i;
 677
 678         *err = ret;
 679         return ret;
 680 }
 681
 682 int setting_get_string_slp_key(setting_str_slp_list key, char *value, int *err)
 683 {
 684         //SETTING_TRACE_BEGIN;
 685         int ret = SETTING_RETURN_FAIL;
 686
 687         /* error check */
 688         if (key < 0 || key >= STR_SLP_LIST_MAX || NULL == value) {
 689                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 690                 return ret;
 691         }
 692
 693         /** @todo check memory leack when passwork checking */
 694         VconfNode result;
 695         ret = get_vconf(g_stable[key], &result);
 696
 697         if (ret >= 0)
 698         {
 699                 safeCopyStr(value, result.value.c, strlen(result.value.c));
 700                 SETTING_TRACE(">>>>>>>> %s <<<<<<<<", value);
 701                 FREE(result.value.c);
 702         } else {
 703                 SETTING_TRACE("get_vconf is failed");
 704         }
 705         *err = ret;
 706         return ret;
 707 }
 708
 709 int setting_set_string_slp_key(setting_str_slp_list key, char *value, int *err)
 710 {
 711         int ret = SETTING_RETURN_FAIL;
 712
 713         /* error check */
 714         if (key < 0 || key >= STR_SLP_LIST_MAX) {
 715                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 716                 return ret;
 717         }
 718
 719         VconfNode result;
 720         g_stable[key].value.c = value;
 721         ret = set_vconf(g_stable[key], &result);
 722         g_stable[key].value.c = "";
 723
 724         SETTING_TRACE("setting_set_str ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.c);
 725         *err = ret;
 726         return ret;
 727 }
 728
 729 /** @todo don't use i18n string directly. */
 730 static const setting_lang_entry lang_table[] = {
 731         {       "auto",                 "Automatic"},
 732         {       "ko_KR.UTF-8",  "한국어"},
 733         {       "en_US.UTF-8",  "English"},
 734         {       "zh_CN.UTF-8",  "简体中文"},
 735         {       "zh_HK.UTF-8",  "繁體中文(香港)"},
 736         {       "zh_TW.UTF-8",  "繁體中文(台灣)"},
 737         {       "de_DE.UTF-8",  "Deutsch"},
 738         {       "nl_NL.UTF-8",  "Nederlands"},
 739         {       "es_ES.UTF-8",  "Español"},
 740         {       "pt_PT.UTF-8",  "Português"},
 741         {       "el_GR.UTF-8",  "Eλληνικά"},
 742         {       "it_IT.UTF-8",  "Italiano"},
 743         {       "fr_FR.UTF-8",  "Français"},
 744         {       "tr_TR.UTF-8",  "Türkçe"},
 745         {       "ja_JP.UTF-8",  "にほんご"},
 746         {       "ru_RU.UTF-8",  "Россию"},
 747 };
 748
 749 setting_lang_entry* setting_get_language_table()
 750 {
 751         return (setting_lang_entry*)lang_table;
 752 }
 753
 754
 755 #define LANGLIST_FILE_DIR_PATH  "/opt/data/setting/"
 756 #define LANGLIST_FILE_PATH              LANGLIST_FILE_DIR_PATH"langlist.xml"
 757
 758 static void _parseLangListXML(char* docname);   // internal
 759 static void __tree_walk_langlist(xmlNodePtr cur); // internal
 760
 761 static Eina_List* s_langlist;                                   // internal
 762
 763 // do it once
 764 int _langlist_load()
 765 {
 766         SETTING_TRACE_BEGIN;
 767
 768         if (!s_langlist)
 769         {
 770                 _parseLangListXML(LANGLIST_FILE_PATH);
 771         }
 772
 773         return 0;
 774 }
 775
 776 // singleton
 777 Eina_List* setting_get_language_list()
 778 {
 779         if (NULL == s_langlist)
 780         {
 781                 _langlist_load();
 782         }
 783
 784         return s_langlist;
 785 }
 786
 787 int _langlist_destroy()
 788 {
 789         SETTING_TRACE_BEGIN;
 790     Eina_List *li = s_langlist;
 791         setting_lang_entry* node;
 792     while (li) {
 793         node = (setting_lang_entry*) eina_list_data_get(li);
 794         if (node)
 795         {
 796                                 SETTING_TRACE("destroy nodes : locale : %s title : %s", node->locale, node->title);
 797                                 G_FREE(node->locale);
 798                                 G_FREE(node->title);
 799                                 FREE(node);
 800         }
 801         li = eina_list_next(li);
 802     }
 803         s_langlist = eina_list_free(s_langlist);                // returns NULL
 804
 805         return 0;
 806 }
 807
 808 void  setting_get_language_list_destroy()
 809 {
 810         _langlist_destroy();
 811 }
 812
 813 static void _parseLangListXML(char* docname)
 814 {
 815         SETTING_TRACE_BEGIN;
 816     xmlDocPtr doc;
 817     xmlNodePtr cur;
 818
 819     doc = xmlParseFile(docname);
 820
 821     if (doc == NULL ) {
 822         fprintf(stderr,"Document not parsed successfully. \n");
 823         return;
 824     }
 825
 826     cur = xmlDocGetRootElement(doc);
 827     if (cur == NULL) {
 828         fprintf(stderr,"empty document\n");
 829         xmlFreeDoc(doc);
 830         return;
 831     }
 832
 833     printf("ROOT NODE : %s \n", cur->name);
 834     // make sure root node is "settings"
 835     if (xmlStrcmp(cur->name, (const xmlChar *) "langlist")) {
 836         SETTING_TRACE("document of the wrong type, root node != settings");
 837         xmlFreeDoc(doc);
 838         return;
 839     }
 840
 841     cur = cur->xmlChildrenNode;
 842     __tree_walk_langlist(cur);
 843
 844     /* save tree to file */
 845     if (doc != NULL) {
 846         //xmlSaveFormatFile (docname, doc, 1);
 847         xmlFreeDoc(doc);
 848     }
 849     //xmlFreeDoc(doc);
 850     return;
 851 }
 852
 853 static void __tree_walk_langlist(xmlNodePtr cur)
 854 {
 855         SETTING_TRACE_BEGIN;
 856     xmlNode *cur_node = NULL;
 857         char* id;
 858         char* string;
 859         int number;
 860
 861     for (cur_node = cur; cur_node;cur_node = cur_node->next) {
 862         if (cur_node->type == XML_ELEMENT_NODE) {
 863
 864             SETTING_TRACE(" name=%s title=%s number=%s \n", xmlGetProp(cur_node, (const xmlChar *)"id"), xmlGetProp(cur_node, (const xmlChar *)"string"), xmlGetProp(cur_node, (const xmlChar *)"no"));
 865                         id = (char *)g_strdup((char*)xmlGetProp(cur_node, (const xmlChar *)"id"));
 866                         string = (char *)g_strdup((char*) xmlGetProp(cur_node, (const xmlChar *)"string"));
 867                         number = atoi((char*) xmlGetProp(cur_node, (const xmlChar *)"no"));
 868                         SETTING_TRACE(">>>> locale: %s title: %s", (char*)id, (char*)string);
 869
 870                         setting_lang_entry* pitem = (setting_lang_entry*)calloc(1, sizeof(setting_lang_entry));
 871                         pitem->locale = id;
 872                         pitem->title = string;
 873                         pitem->number = number;
 874
 875                         s_langlist = eina_list_append(s_langlist, pitem);
 876         }
 877     }
 878 }
 879 //-----------------------------------------------------------------------------------------------
 880 //-----------------------------------------------------------------------------------------------
 881
 882 //setting_lang_entry*
 883
 884 //////////////////////////////////////////////////////////////////////////////////////////
 885 int setting_store_init_password(char *in)
 886 {
 887
 888         SHA256_CTX context;
 889         char md[SHA256_DIGEST_LENGTH] = {0,};
 890         /* int i = 0; */
 891         int ret = SETTING_RETURN_FAIL;
 892
 893         SHA256_Init(&context);
 894         SHA256_Update(&context, (char *)in, strlen(in));
 895         SHA256_Final((unsigned char *)md, &context);
 896
 897 #ifdef DEBUG
 898         SETTING_TRACE("input: [%s]\n", in);
 899         SETTING_TRACE("output: [");
 900         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
 901                 SETTING_TRACE("%02x", md[i]);
 902         SETTING_TRACE("]\n");
 903 #endif
 904
 905         /*  create a file or store a data */
 906         /*  store_password */
 907         FILE *fp = NULL;
 908         int ret_fw = 0;
 909         fp = fopen(PWD_FILE, "w+");
 910         if (fp) {
 911                 ret_fw = fwrite(md, 1, SHA256_DIGEST_LENGTH, fp);
 912                 SETTING_TRACE_DEBUG("fwrite() wrote %d chars.", ret_fw);
 913                 if(ret_fw == SHA256_DIGEST_LENGTH)
 914                 {
 915                         fflush(fp);
 916                         fsync(fp->_fileno);
 917                         ret = SETTING_RETURN_SUCCESS;
 918                 }
 919                 fclose(fp);
 920         } else {
 921                 SETTING_TRACE("ERR: pwd file is not exist \n");
 922         }
 923
 924         return ret;
 925 }
 926
 927 int setting_read_password(char *md_result)
 928 {
 929         SETTING_TRACE_BEGIN;
 930         /* int i; */
 931         FILE *fp = NULL;
 932         fp = fopen(PWD_FILE, "r");
 933         if (fp) {
 934                 int size = fread(md_result, sizeof(char), SHA256_DIGEST_LENGTH, fp);
 935                 if (size != SHA256_DIGEST_LENGTH) {
 936                         SETTING_TRACE_ERROR("fread failed");
 937                 }
 938                 fclose(fp);
 939         } else {
 940                 SETTING_TRACE("ERR: pwd file is not exist \n");
 941                 return SETTING_RETURN_FAIL;
 942         }
 943
 944 #ifdef DEBUG
 945         SETTING_TRACE("output from file: [");
 946         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
 947                 SETTING_TRACE("%02x", md_result[i]);
 948         SETTING_TRACE("]\n");
 949 #endif
 950         SETTING_TRACE_END;
 951         return 0;
 952 }
 953
 954 int setting_compare_password(char *md_result, const char *in_later)
 955 {
 956         SETTING_TRACE_BEGIN;
 957         SHA256_CTX context_later;
 958         char md_later[SHA256_DIGEST_LENGTH];
 959         int ret = SETTING_RETURN_FAIL;
 960
 961         SHA256_Init(&context_later);
 962         SHA256_Update(&context_later, (char *)in_later, strlen(in_later));
 963         SHA256_Final((unsigned char *)md_later, &context_later);
 964
 965         SETTING_TRACE(" :[ %25s ]", in_later);
 966
 967         if (0 == memcmp(md_later, md_result, SHA256_DIGEST_LENGTH)) {
 968                 SETTING_TRACE("two passwords are same \n");
 969                 ret = 0;
 970         } else {
 971                 SETTING_TRACE("two passwords are different \n");
 972         }
 973         return ret;
 974 }
 975
 976 void setting_destory_listen_list(Eina_List **listened_list)
 977 {
 978         if (listened_list && *listened_list)
 979         {
 980                 Vconf_Change_Node *node = NULL;
 981                 Eina_List *li = *listened_list;
 982                 while (li) {
 983                         node = (Vconf_Change_Node *) eina_list_data_get(li);
 984                         if (node)
 985                         {
 986                                 //SETTING_TRACE("Deregister callback[%p] of %s", node->cb, node->in_key);
 987                                 if (node->in_key && node->cb) {
 988                                         (void)vconf_ignore_key_changed(node->in_key, node->cb);
 989                                         FREE(node);
 990                                 }
 991                         }
 992                         li = eina_list_next(li);
 993                 }
 994                 *listened_list = eina_list_free(*listened_list);
 995         }
 996 }
 997
 998 bool setting_add_listen_node(Eina_List **listened_list,const char *vconf, vconf_callback_fn cb, void *data)
 999 {
1000         Vconf_Change_Node *node = calloc(1, sizeof(Vconf_Change_Node));
1001         bool ret = TRUE;
1002         if (node && vconf && cb)
1003         {
1004                 node->in_key = vconf;
1005                 node->cb = cb;
1006                 node->cb_data = data;
1007
1008                 if(0 == vconf_notify_key_changed(vconf, cb, data))
1009                 {
1010                         //SETTING_TRACE("Register callback[%p] of %s", node->cb, node->in_key);
1011                         *listened_list = eina_list_append(*listened_list, node);
1012                 }
1013                 else
1014                 {
1015                         SETTING_TRACE_ERROR("Failed to register callback[%p] of %s", node->cb, node->in_key);
1016                         ret = FALSE;
1017                 }
1018         }
1019         // FREE(node);          /* list node will be freed at the destory function */
1020         return ret;
1021 }
1022
1023