setting-common/src/setting-cfg.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
  22 #include <setting-cfg.h>
  23 #include <setting-debug.h>
  24 #include <stdio.h>
  25 #include <Elementary.h>
  26 #include <setting-common-general-func.h>
  27 #include <unistd.h>
  28
  29 #define CFG_FILE_DIR_PATH       "/opt/data/setting/"
  30 #define CFG_FILE_PATH           CFG_FILE_DIR_PATH"setting.cfg"
  31
  32 JsonParser* parser;
  33 JsonNode*   root; /* category_list */
  34
  35 char* setting_cfg_get_path()
  36 {
  37         return CFG_FILE_PATH;
  38 }
  39
  40 int setting_cfg_file_write( JsonNode * node );
  41
  42 #define __create_an_item(item_name, icon_path, ug_args, defaultPos, is_resetable) do\
  43 {\
  44         if (!is_ug_installed_by_ug_args(ug_args)) break;\
  45         menu_item = json_node_new(JSON_NODE_OBJECT); \
  46         object = json_object_new(); \
  47         json_node_take_object(menu_item, object); \
  48         json_object_set_string_member(object, "key_name", item_name); \
  49         json_object_set_string_member(object, "icon_path", icon_path); \
  50         json_object_set_string_member(object, "ug_args", ug_args); \
  51         json_object_set_int_member(object, "pos", defaultPos); \
  52         json_object_set_int_member(object, "click_times", 0); \
  53         json_object_set_int_member(object, "is_resetable", is_resetable); \
  54         json_array_add_element(menu, menu_item); \
  55 } while(0);\
  56
  57 #define __create_an_item_by_pkg(item_name, pkg_name, ug_args, defaultPos, is_resetable) do\
  58 {\
  59         if (!is_ug_installed_by_ug_args(ug_args)) break;\
  60         menu_item = json_node_new(JSON_NODE_OBJECT); \
  61         object = json_object_new(); \
  62         char* __temp_##item_name = get_icon_path(pkg_name); \
  63         json_node_take_object(menu_item, object); \
  64         json_object_set_string_member(object, "key_name", item_name); \
  65         json_object_set_string_member(object, "icon_path", __temp_##item_name); \
  66         json_object_set_string_member(object, "ug_args", ug_args); \
  67         json_object_set_int_member(object, "pos", defaultPos); \
  68         json_object_set_int_member(object, "click_times", 0); \
  69         json_object_set_int_member(object, "is_resetable", is_resetable); \
  70         json_array_add_element(menu, menu_item); \
  71         free(__temp_##item_name); __temp_##item_name = NULL; \
  72 } while(0);\
  73
  74
  75 #define __create_a_menu(menu_name)\
  76 {\
  77         category = json_node_new( JSON_NODE_OBJECT );\
  78         object = json_object_new();\
  79         json_node_take_object ( category, object );\
  80         json_object_set_string_member( object, "name", menu_name );\
  81         menu = json_array_new();\
  82         json_object_set_array_member( object, "menu", menu );\
  83         json_array_add_element( json_node_get_array( category_list ), category );\
  84 }
  85
  86 void setting_cfg_print( void )
  87 {
  88         JsonNode * node = root;
  89
  90         JsonGenerator *generator = json_generator_new ();
  91         g_object_set( generator, "pretty", TRUE, NULL );
  92         json_generator_set_root ( generator, node );
  93         gchar *data = json_generator_to_data ( generator, NULL );
  94         SETTING_TRACE( "%s", (char *)data );
  95
  96         g_free(data);
  97         g_object_unref(generator);
  98 }
  99
 100 /* create config file from scratch */
 101 int setting_cfg_create(void)
 102 {
 103         JsonNode *category_list, *category, *menu_item;
 104         JsonArray *menu;
 105         JsonObject *object;
 106
 107         /* Category list */
 108         category_list = json_node_new (JSON_NODE_ARRAY);
 109         json_node_take_array ( category_list, json_array_new () );
 110
 111         /* Connectivity */
 112         __create_a_menu(KeyStr_Connectivity);
 113
 114         __create_an_item(KeyStr_FlightMode, IMG_FlightMode, NULL, Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 115         __create_an_item(KeyStr_WiFi, IMG_WiFi, "wifi-efl-UG", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 116         __create_an_item(KeyStr_MobileAP, IMG_MobileAP, "setting-mobile-ap-ug", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 117         __create_an_item(KeyStr_Location, IMG_Location, "setting-location-efl", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 118         __create_an_item(KeyStr_Network, IMG_Network, "setting-network-efl", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 119         __create_an_item(KeyStr_Bluetooth, IMG_Bluetooth, "setting-bluetooth-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 120         __create_an_item(KeyStr_NFC, IMG_NFC, "setting-nfc-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 121
 122 #if SUPPORT_DATA_USAGE
 123         __create_an_item(KeyStr_DataUsage, IMG_DataUsage, "setting-datausage-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 124 #endif
 125
 126 #if SUPPORT_WIFI_DIRECT
 127         __create_an_item(KeyStr_WiFiDirect, IMG_WiFiDirect, "setting-wifidirect-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 128 #endif
 129
 130 #if SUPPORT_ALLSHARECAST
 131         // Allshare Cast -- Here
 132         __create_an_item(KeyStr_AllShareCast, IMG_AllShareCast, "setting-allshare-cast-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 133 #endif
 134
 135 #if SUPPORT_AllShare
 136         // allshare setting
 137         __create_an_item(KeyStr_NearbyDevices, IMG_AllShare, "setting-allshare-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 138 #endif
 139
 140         if ( ! is_slp_binary()) {
 141                 __create_an_item(KeyStr_KeisOverWifi, IMG_KeisOverWifi, "kies-via-wifi", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 142         }
 143
 144         if ( ! is_slp_binary()) {
 145                 __create_an_item(KeyStr_Synchronise, IMG_Synchronise, "setting-synchronise-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 146         }
 147
 148         /* System */
 149         __create_a_menu(KeyStr_System);
 150         /* a new group..        */
 151 #if SUPPORT_EVENTNOTI
 152         __create_an_item(KeyStr_EventsNotifications, IMG_EventsNotifications, "setting-phone-efl|viewtype:notification", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 153 #endif
 154         // Wallpaper -- here
 155 #if SUPPORT_WALLPAPER
 156         /* kinds of wallpaper version.. */
 157         __create_an_item(KeyStr_Wallpaper, IMG_Wallpaper, "setting-display-efl|viewtype:wallpaper", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 158 #endif
 159
 160         __create_an_item(KeyStr_Sounds, IMG_Sounds, "setting-profile-efl", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 161
 162 #if SUPPOR_SEPARATE_BRIGHTNESS
 163         __create_an_item(KeyStr_Brightness, IMG_Brightness, "setting-display-efl|viewtype:brightness", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 164 #endif
 165
 166 #if SUPPORT_SECURITY
 167         __create_an_item(KeyStr_Security, IMG_Security, "setting-security-efl", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 168 #endif
 169
 170 #if SUPPORT_POWERSAVING
 171         __create_an_item(KeyStr_Powersaving, IMG_Powersaving, "setting-powersaving-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 172 #endif
 173
 174 #if SUPPORT_MOTIONS
 175         __create_an_item(KeyStr_Motions, IMG_Motion, "setting-motion-efl|viewtype:motions", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 176 #endif
 177
 178 #if SUPPORT_ACCESSIBILITY
 179         __create_an_item(KeyStr_Accessibility, IMG_Accessibility, "setting-accessibility-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 180 #endif
 181
 182 #if SUPPORT_FONT
 183         __create_an_item(KeyStr_Font, IMG_Font, "setting-font-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 184 #endif
 185
 186         __create_an_item(KeyStr_Display, IMG_Dispaly, "setting-display-efl|viewtype:main", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 187 #if SUPPORT_MENUSCREEN
 188         __create_an_item(KeyStr_Menuscreen, IMG_Menuscreen, "setting-homescreen-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 189 #endif
 190         __create_an_item(KeyStr_Landscape, IMG_Landscape, NULL, Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 191         __create_an_item(KeyStr_DateTime, IMG_DateTime, "setting-time-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 192         __create_an_item(KeyStr_LanguageRegion, IMG_DisplayLanguage, "setting-phone-efl|viewtype:language", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 193         __create_an_item(KeyStr_KeyboradLanguage, IMG_KeyboradLanguage, "isfsetting-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 194
 195 #if SUPPORT_VOICEINOUT
 196         __create_an_item(KeyStr_VoiceInOut, IMG_VoiceInOut, "setting-voice-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 197 #endif
 198         __create_an_item(keystr_Drivingmode, IMG_DrivingMode, "setting-drivingmode-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 199 #if SUPPORT_STORAGE
 200         __create_an_item(KeyStr_Storage, IMG_DefaultIcon, "setting-storage-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 201 #endif
 202         __create_an_item(KeyStr_ManageApps, IMG_MANAGE_APPS, "setting-manage-applications-efl|viewtype:manage-applications", Cfg_Item_Pos_Level1,
 203                             Cfg_Item_Resetable);
 204
 205         __create_an_item(KeyStr_WebApps, IMG_Web_Apps, "webapp-common-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 206
 207 #if SUPPORT_CERTIFICATES
 208         __create_an_item(KeyStr_CertUI, IMG_MANAGE_APPS, "setting-manage-certificates-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 209 #endif
 210
 211         __create_an_item(KeyStr_Memory, IMG_Memory, "setting-memory-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 212         __create_an_item(KeyStr_Reset, IMG_Reset, "setting-reset-efl", Cfg_Item_Pos_Level1, Cfg_Item_unResetable);
 213         __create_an_item(KeyStr_DeveloperOption, IMG_USBconnection, "setting-developeroption-efl|viewtype:usb", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 214         __create_an_item(KeyStr_AboutPhone, IMG_AboutPhone, "setting-about-efl", Cfg_Item_Pos_Level1, Cfg_Item_Resetable);
 215
 216         /* Applications */
 217         __create_a_menu(KeyStr_Applications);
 218
 219         __create_an_item(KeyStr_Accounts, IMG_Accounts, "setting-myaccount-efl|mode:account_list", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 220         __create_an_item(KeyStr_Call, IMG_Call, "setting-call-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 221         __create_an_item(KeyStr_Messages, IMG_Messages, "msg-setting-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 222         __create_an_item(KeyStr_Email, IMG_Email, "email-setting-efl|VIEW_TYPE:main-view", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 223         __create_an_item(KeyStr_Contacts, IMG_Contacts, "contacts-settings-efl|request_type:71", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 224
 225         __create_an_item(KeyStr_Calendar, IMG_Calendar, "calendar-settings-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 226
 227         __create_an_item(KeyStr_Gallery, IMG_Gallery, "setting-gallery-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 228         __create_an_item(KeyStr_VoiceRecorder, IMG_VoiceRecorder, "setting-voicerecorder-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 229
 230 #if SUPPORT_FMradio
 231         // FMradio setting
 232         __create_an_item_by_pkg(KeyStr_FMRadio, "com.samsung.fm-radio", "setting-fmradio-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 233         SETTING_TRACE_DEBUG("Added FMRadio");
 234 #endif
 235
 236
 237
 238
 239
 240
 241 #if DISABLED_CODE
 242         __create_an_item_by_pkg(KeyStr_NFC, "com.samsung.nfc-app", "setting-nfc-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 243 #endif
 244
 245         /* Downloaded App */
 246         __create_a_menu(KeyStr_DownloadedAPPs);
 247
 248         /* write to file */
 249         int ret = setting_cfg_file_write( category_list );
 250
 251         json_node_free( category_list );
 252
 253         return ret;
 254 }
 255
 256
 257 /* load file */
 258 int setting_cfg_file_read( void )
 259 {
 260 #if DISABLED_CODE
 261         if (access( CFG_FILE_PATH, R_OK|F_OK ) !=0 )
 262         {
 263                 SETTING_TRACE("file [%s] not legal, need to check your file-system.[%s:%d]\n", CFG_FILE_PATH, __FILE__, __LINE__);
 264                 //return Cfg_Error_Type_FilePermissionDenied;
 265                 return FALSE;
 266         }
 267 #endif
 268         parser = json_parser_new (); /* to be freed on exit */
 269
 270         /* file -> parser */
 271         GError *error = NULL;
 272         gboolean ret = json_parser_load_from_file( parser, CFG_FILE_PATH, &error );
 273
 274         if( FALSE == ret )
 275         {
 276                 return FALSE;
 277 #if DISABLED_CODE
 278                 SETTING_TRACE_ERROR("error->message:%s", (char*)(error->message));
 279
 280         /* The file is existing and can be accessed normally, but it was
 281          * loaded failed as a json script, it means setting.cfg is
 282          * damaged(not the normal formatting ), we need to remove
 283          * the file and recreate in next running time*/
 284                 SETTING_TRACE_ERROR("The file[%s] is existing and can be accessed "\
 285                             "normally, but it was loaded failed as a json "\
 286                             "script, it means setting.cfg is damaged (the "\
 287                             "formatting ia abnormal), we need to remove the"\
 288                             " file and recreate in next running time!",
 289                             CFG_FILE_PATH);
 290
 291         SETTING_TRACE("Trying to removing the damaged file.");
 292         if (remove(CFG_FILE_PATH) != 0)
 293         {
 294             SETTING_TRACE_ERROR("Error to remove the damaged file");
 295             return FALSE;
 296         }
 297
 298         if( FALSE == setting_cfg_create() )
 299         {
 300             SETTING_TRACE_ERROR("Error to create a new config file");
 301             return FALSE;
 302         }
 303         /*if the failed is  caused by reading the file recursively invoking */
 304         return setting_cfg_file_read();
 305 #endif
 306         }
 307
 308         /* parser -> root */
 309         root = json_parser_get_root( parser ); /* to be freed on exit*/
 310         return TRUE;
 311 }
 312
 313 /**
 314 * @brief dump JSON to file
 315 */
 316 int setting_cfg_file_write( JsonNode * node )
 317 {
 318         GError *error = NULL;
 319         JsonGenerator *generator = json_generator_new ();
 320         json_generator_set_root ( generator, node );
 321         g_object_set( generator, "pretty", TRUE, NULL ); //write file in indent format
 322         gboolean ret = json_generator_to_file( generator, CFG_FILE_PATH, &error );
 323         g_object_unref(generator);
 324
 325         /* ***BEGIN***  DAC black screen SAMSUNG 2010/8/9 add
 326          *add read permission
 327          *chown -R inhouse:inhouse /home/inhouse/setting.cfg
 328          */
 329         if( FALSE == ret )
 330         {
 331                 SETTING_TRACE_ERROR("Error writing file %s!", CFG_FILE_PATH );
 332                 return FALSE;
 333         }
 334         return TRUE;
 335 }
 336
 337 /*   public functions  */
 338 #if DISABLED_CODE
 339 int setting_cfg_init( void )
 340 {
 341         g_type_init ();
 342
 343         struct stat st;
 344         //int ret = -1;
 345
 346         if (access( CFG_FILE_DIR_PATH, R_OK|W_OK|F_OK ) !=0 )
 347     {
 348                 SETTING_TRACE_ERROR("dir [%s] not legal, need to check your file-system.[%s:%d]\n", CFG_FILE_DIR_PATH, __FILE__, __LINE__);
 349         return Cfg_Error_Type_DirPermissionDenied;
 350     }
 351         if( stat(CFG_FILE_DIR_PATH, &st) != 0)/* to make more stable */
 352         {
 353                 /* if (0 != system("sudo mkdir /opt/data/setting/")); */
 354                 /* if (EINA_TRUE != ecore_file_mkpath(CFG_FILE_DIR_PATH)); */
 355                 if (EINA_TRUE != ecore_file_mkdir(CFG_FILE_DIR_PATH));
 356                 {
 357                         perror("mkdir");
 358                         return Cfg_Error_Type_Mkdir_Failed;
 359                 }
 360         }
 361
 362         if( stat(CFG_FILE_PATH, &st) != 0)
 363         {
 364                 SETTING_TRACE_ERROR("Config file doesn't exist. Create it!");
 365                 if(     FALSE == setting_cfg_create() )
 366                 {
 367                         /* perror("setting_cfg_create"); */
 368                         return Cfg_Error_Type_CreateCfg_Failed;
 369                 }
 370                 stat(CFG_FILE_PATH, &st);
 371         }
 372         /* ***BEGIN***  error handle(caused by unstable file system) SAMSUNG 2010/9/10 add*/
 373         else if (0 == st.st_size ||
 374              0 != access( CFG_FILE_PATH, R_OK|F_OK ))
 375         {
 376                 SETTING_TRACE("the %s is 0 Byte, we need to recreate it.", CFG_FILE_PATH);
 377                 /* delete the file */
 378                 if (remove(CFG_FILE_PATH) != 0)
 379                 {
 380                         perror("remove");
 381                         return Cfg_Error_Type_RemoveCfg_Failed;
 382                 }
 383                 if(     FALSE == setting_cfg_create() )
 384                 {
 385                         /* perror("setting_cfg_create"); */
 386                         return Cfg_Error_Type_CreateCfg_Failed;
 387                 }
 388
 389         }
 390         /* ****END****  error handle(caused by unstable  file system) SAMSUNG 2010/9/10 add
 391          * cfg file exists but invalid -> re-create
 392          * load file into parser
 393          */
 394         if( FALSE == setting_cfg_file_read() )
 395         {
 396                 /* remove current setting file */
 397                 if (remove(CFG_FILE_PATH) != 0)
 398                 {
 399                         /* perror("remove"); */
 400                         return Cfg_Error_Type_RemoveCfg_Failed;
 401                 }
 402                 return Cfg_Error_Type_ReadCfg_Failed;
 403         }
 404
 405         return Cfg_Error_Type_Sucess;
 406 }
 407 #endif
 408
 409 int setting_cfg_init( void )
 410 {
 411         g_type_init ();
 412
 413         if (!access(CFG_FILE_PATH, R_OK|W_OK|F_OK )) { // succeed to access
 414                 if(!setting_cfg_file_read()) { // return FALSE
 415                         if (remove(CFG_FILE_PATH)) {
 416                                 return Cfg_Error_Type_RemoveCfg_Failed;
 417                         }
 418                         return Cfg_Error_Type_ReadCfg_Failed;
 419                 }
 420
 421                 return Cfg_Error_Type_Sucess;
 422         } else { // fail to access
 423                 switch (errno) {
 424                         // file non-existing case
 425                         case ENOENT:
 426                                 SETTING_TRACE_ERROR("non-existing file/dir");
 427                                 ecore_file_mkdir(CFG_FILE_DIR_PATH);
 428                                 if (!setting_cfg_create()) { // return FALSE
 429                                         SETTING_TRACE_ERROR("Error to create a new config file");
 430                                         return Cfg_Error_Type_CreateCfg_Failed;
 431                                 }
 432                                 if(!setting_cfg_file_read() ) { // return FALSE
 433                                         if (remove(CFG_FILE_PATH)) {
 434                                                 return Cfg_Error_Type_RemoveCfg_Failed;
 435                                         }
 436                                         return Cfg_Error_Type_ReadCfg_Failed;
 437                                 }
 438
 439                                 return Cfg_Error_Type_Sucess;
 440                         // other cases
 441                         case EACCES:
 442                         case EROFS:
 443                         default:
 444                                 return Cfg_Error_Type_DirPermissionDenied;
 445                 }
 446         }
 447 }
 448
 449 void setting_cfg_exit( void )
 450 {
 451         json_node_free(root);
 452         g_object_unref (parser);
 453 }
 454
 455 int setting_cfg_file_update( void )
 456 {
 457         if (access( CFG_FILE_PATH, W_OK|F_OK ) !=0 )
 458         {
 459                 return FALSE;
 460         }
 461         return setting_cfg_file_write( root );
 462 }
 463
 464 int setting_cfg_get_category_length( void )
 465 {
 466         return json_array_get_length( json_node_get_array( root ) );
 467 }
 468
 469 char* setting_cfg_get_category_name( int category_index )
 470 {
 471         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 472         return (char*)json_object_get_string_member( category_obj, "name" );
 473 }
 474
 475 int setting_cfg_get_menu_length( int category_index )
 476 {
 477         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 478         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 479         return json_array_get_length( menu );
 480 }
 481
 482 char * setting_cfg_get_keyname_idx( int category_index, int menu_index )
 483 {
 484         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 485         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 486         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 487         return (char*)json_object_get_string_member( menu_item, "key_name" );
 488 }
 489
 490 char * setting_cfg_get_string_field_idx( int category_index, int menu_index, char *field_name)
 491 {
 492         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 493         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 494         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 495
 496         char *data = (char *)json_object_get_string_member( menu_item, field_name );
 497         if (!safeStrCmp(data, "(null)"))/* pass NULL to ug_args when create setting.cfg. */
 498         {
 499                 return NULL;
 500         }
 501         return data;
 502 }
 503
 504 int setting_cfg_get_int_field_idx( int category_index, int menu_index , char *field_name)
 505 {
 506         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 507         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 508         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 509         return json_object_get_int_member( menu_item, field_name );
 510 }
 511
 512 char * setting_cfg_get_icon_path_idx( int category_index, int menu_index )
 513 {
 514         return setting_cfg_get_string_field_idx(category_index, menu_index, "icon_path");
 515 }
 516
 517 char * setting_cfg_get_ug_args_idx( int category_index, int menu_index )
 518 {
 519         return setting_cfg_get_string_field_idx(category_index, menu_index, "ug_args");
 520 }
 521
 522 char * setting_cfg_get_ugpath_idx( int category_index, int menu_index )
 523 {
 524         return setting_cfg_get_string_field_idx(category_index, menu_index, "ug_path");
 525 }
 526
 527 char * setting_cfg_get_ugpath( char * keyname )
 528 {
 529         int i, j;
 530         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 531         {
 532                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 533                 {
 534                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 535                                 return setting_cfg_get_ugpath_idx( i, j );
 536                 }
 537         }
 538         return NULL;
 539 }
 540
 541 int setting_cfg_get_pos_idx( int category_index, int menu_index )
 542 {
 543         return setting_cfg_get_int_field_idx(category_index, menu_index, "pos");
 544 }
 545
 546 int setting_cfg_get_pos( char * keyname )
 547 {
 548         int i, j;
 549         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 550         {
 551                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 552                 {
 553                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 554                                 return setting_cfg_get_pos_idx( i, j );
 555                 }
 556         }
 557         return 0;
 558 }
 559
 560 void setting_cfg_set_pos_idx( int category_index, int menu_index, int pos )
 561 {
 562         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 563         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 564         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 565         json_object_remove_member( menu_item, "pos" );
 566         json_object_set_int_member( menu_item, "pos", pos );
 567 }
 568
 569 void setting_cfg_set_pos( char * keyname, int pos )
 570 {
 571         int i, j;
 572         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 573         {
 574                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 575                 {
 576                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 577                         {
 578                                 setting_cfg_set_pos_idx( i, j, pos );
 579                                 return ;
 580                         }
 581                 }
 582         }
 583
 584 }
 585
 586 int setting_cfg_get_click_times_idx( int category_index, int menu_index )
 587 {
 588         return setting_cfg_get_int_field_idx(category_index, menu_index, "click_times");
 589 }
 590
 591 int setting_cfg_get_click_times( char * keyname )
 592 {
 593         int i, j;
 594         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 595         {
 596                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 597                 {
 598                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 599                                 return setting_cfg_get_click_times_idx( i, j );
 600                 }
 601         }
 602         return 0;
 603 }
 604
 605 void setting_cfg_set_click_times_idx( int category_index, int menu_index, int click_times )
 606 {
 607         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 608         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 609         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 610         json_object_remove_member( menu_item, "click_times" );
 611         json_object_set_int_member( menu_item, "click_times", click_times );
 612 }
 613
 614 void setting_cfg_set_click_times( char * keyname, int click_times )
 615 {
 616         int i, j;
 617         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 618         {
 619                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 620                 {
 621                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 622                         {
 623                                 setting_cfg_set_click_times_idx( i, j, click_times );
 624                                 return ;
 625                         }
 626                 }
 627         }
 628
 629 }
 630
 631 int setting_cfg_get_resetable_flag_idx(int category_index, int menu_index)
 632 {
 633         return setting_cfg_get_int_field_idx(category_index, menu_index,
 634                                              "is_resetable");
 635 }
 636
 637 void setting_cfg_add_downloaded_app( char *keyname, char *icon_path, char *ug_args, int pos)
 638 {
 639         int i;
 640         JsonNode *menu_item;
 641         JsonObject *object;
 642         JsonArray *menu;
 643
 644         for( i=0; i<setting_cfg_get_category_length(); i++ )
 645         {
 646                 if( safeStrCmp( setting_cfg_get_category_name(i), "Downloaded App" ) == 0 )
 647                 {
 648                         menu_item = json_node_new( JSON_NODE_OBJECT );
 649                         object = json_object_new();
 650                         json_node_take_object ( menu_item, object );
 651                         json_object_set_string_member( object, "key_name", keyname );
 652                         json_object_set_string_member( object, "icon_path", icon_path );
 653                         json_object_set_string_member( object, "ug_args", ug_args );
 654                         json_object_set_int_member( object, "pos", pos );
 655
 656                         object = json_array_get_object_element( json_node_get_array( root ), i );
 657                         menu = json_object_get_array_member( object, "menu" );
 658                         json_array_add_element( menu, menu_item );
 659                 }
 660         }
 661 }
 662
 663 void setting_cfg_remove_downloaded_app( char * keyname )
 664 {
 665         int i, j;
 666         JsonObject *object;
 667         JsonArray *menu;
 668
 669         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 670         {
 671                 if( safeStrCmp( setting_cfg_get_category_name(i), "Downloaded App" ) == 0 )
 672                 {
 673                         for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 674                         {
 675                                 if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 676                                 {
 677                                         object = json_array_get_object_element( json_node_get_array( root ), i );
 678                                         menu = json_object_get_array_member( object, "menu" );
 679                                         json_array_remove_element( menu, j );
 680                                         return ;
 681                                 }
 682                         }
 683                 }
 684         }
 685 }
 686
 687 bool is_ug_installed_by_ug_args(void *data)
 688 {
 689         retv_if(!data, TRUE);//if passing NULL,drawing it
 690         char* ug_args = data;
 691         char *ug_name = get_ug_path_from_ug_args(ug_args);
 692
 693         char ug_file_opt[PATH_MAX];
 694         if (snprintf(ug_file_opt, PATH_MAX, "%s/libug-%s.so", SETTING_UG_PATH, ug_name) < 0)
 695                 return false;
 696
 697         struct stat st;
 698         bool result_opt = false;
 699
 700         if(stat(ug_file_opt, &st) == 0) {
 701                 result_opt = true;
 702         } else {
 703                 SETTING_TRACE_ERROR(" %s is *NOT* present\n", ug_file_opt);
 704                 result_opt = false;
 705         }
 706
 707         //-------------------------------------------------------------------------------------
 708         char ug_file_usr[PATH_MAX];
 709         bool result_usr = false;
 710         if (snprintf(ug_file_usr, PATH_MAX, "%s/libug-%s.so", SETTING_UG_PATH_USR, ug_name) < 0)
 711                 return false;
 712
 713         if(stat(ug_file_usr, &st) == 0) {
 714                 result_usr = true;
 715         } else {
 716                 SETTING_TRACE_ERROR(" %s is *NOT* present\n", ug_file_usr);
 717                 result_usr = false;
 718         }
 719
 720         // false  & false --> false
 721         // true   & false --> true
 722         // false  & true  --> true
 723         // true   &  true  --> true
 724
 725         return (result_usr || result_opt);
 726 }
 727
 728 /*other relative function*/
 729 char *get_ug_path_from_ug_args(void *data)
 730 {
 731         /*SETTING_TRACE_BEGIN;*/
 732         char *p = (char *)data;
 733         if (NULL == p || '\0' == p[0]) {
 734                 return NULL;
 735         }
 736
 737         char *q = strchr(p, '|');
 738         char *path = NULL;
 739
 740         if (q) {                /* copy out the content before '|'; eg, ab|cd */
 741                 path = (char *)calloc(1, q - p + 1);
 742                 setting_retvm_if(!path, NULL, "calloc failed");
 743                 safeCopyStr(path, p, q - p);
 744                 /* redundant handle */
 745                 path[q - p] = '\0';
 746         } else {                /* copy out all the content. eg.abb */
 747
 748                 path = (char *)calloc(1, safeStrLen(p) + 1);
 749                 setting_retvm_if(!path, NULL, "calloc failed");
 750                 safeCopyStr(path, p, safeStrLen(p));
 751         }
 752         /*SETTING_TRACE("get the ug['%s']", path);*/
 753         return path;
 754 }
 755
 756 service_h get_bundle_from_ug_args(void *data)
 757 {
 758         /*SETTING_TRACE_BEGIN;*/
 759         char *p = (char *)data;
 760         if (NULL == p || '\0' == p[0]) {
 761                 return NULL;
 762         }
 763         char *m = NULL;
 764         char *q = strchr(p, '|');
 765         if (q) {                /* (key, value) pairs exit. eg: ug_args = "sevenemail-setting-efl|caller:setting; cmd:main option" */
 766                 /* alloc data */
 767                 service_h svc;
 768                 if (service_create(&svc))
 769                         return NULL;
 770                 int str_len = safeStrLen(p) + 1;
 771                 char *v_key = (char *)calloc(1, str_len);
 772                 if (!v_key) {
 773                         service_destroy(svc);
 774                         return NULL;
 775                 }
 776
 777                 char *v_value = (char *)calloc(1, str_len);
 778                 if (!v_value) {
 779                         service_destroy(svc);
 780                         FREE(v_key);
 781                         return NULL;
 782                 }
 783
 784                 p = ++q;
 785                 while (p) {
 786                         q = strchr(p, ';');
 787                         if (q) {        /* not the last field */
 788                                 m = strchr(p, ':');     /* ziduannei */
 789                                 if (m) {
 790                                         safeCopyStr(v_key, p, m - p);
 791
 792                                         ++m;
 793                                         safeCopyStr(v_value, m, q - m);
 794                                         SETTING_TRACE
 795                                             ("To add ('%s', '%s') to bundle data",
 796                                              v_key, v_value);
 797                                         service_add_extra_data(svc, v_key, v_value);
 798                                 } else {
 799                                         SETTING_TRACE_ERROR
 800                                             ("invalid key-value format!!\n");
 801                                         break;  /* end the whole while */
 802                                 }
 803                         } else {        /* the last field */
 804
 805                                 m = strchr(p, ':');     /* ziduannei */
 806                                 if (m) {
 807                                         safeCopyStr(v_key, p, m - p);
 808                                         ++m;
 809                                         safeCopyStr(v_value, m, safeStrLen(m));
 810
 811                                         service_add_extra_data(svc, v_key, v_value);
 812                                 } else {
 813                                         SETTING_TRACE_ERROR
 814                                             ("invalid key-value format!!\n");
 815                                 }
 816                                 break;  /* end the whole while */
 817                         }
 818
 819                         memset(v_key, '\0', str_len);
 820                         memset(v_value, '\0', str_len);
 821                         p = ++q;
 822                 }
 823
 824                 FREE(v_key);
 825                 FREE(v_value);
 826                 return svc;
 827         } else {                /* eg: ug_args = "setting-browser-efl" */
 828
 829                 /*SETTING_TRACE("(key, value) pairs not exit");*/
 830                 return NULL;
 831         }
 832
 833 }
 834