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