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_unResetable);
 128 #endif
 129
 130         /* System */
 131         __create_a_menu(KeyStr_System);
 132         /* a new group..        */
 133
 134         // Wallpaper -- here
 135 #if SUPPORT_WALLPAPER
 136         /* kinds of wallpaper version.. */
 137         __create_an_item(KeyStr_Wallpaper, IMG_Wallpaper, "setting-display-efl|viewtype:wallpaper", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 138 #endif
 139
 140         __create_an_item(KeyStr_Sounds, IMG_Sounds, "setting-profile-efl", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 141
 142 #if SUPPOR_SEPARATE_BRIGHTNESS
 143         __create_an_item(KeyStr_Brightness, IMG_Brightness, "setting-display-efl|viewtype:brightness", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 144 #endif
 145
 146 #if SUPPORT_SECURITY
 147         __create_an_item(KeyStr_Security, IMG_Security, "setting-security-efl", Cfg_Item_Pos_Level0, Cfg_Item_Resetable);
 148 #endif
 149
 150 #if SUPPORT_POWERSAVING
 151         __create_an_item(KeyStr_Powersaving, IMG_Powersaving, "setting-powersaving-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_Call, IMG_Call, "setting-call-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 190         __create_an_item(KeyStr_Messages, IMG_Messages, "msg-setting-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 191         __create_an_item(KeyStr_Email, IMG_Email, "email-setting-efl|VIEW_TYPE:main-view", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 192         __create_an_item(KeyStr_Contacts, IMG_Contacts, "contacts-settings-efl|request_type:71", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 193
 194         __create_an_item(KeyStr_Calendar, IMG_Calendar, "calendar-settings-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 195
 196         __create_an_item(KeyStr_Gallery, IMG_Gallery, "setting-gallery-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 197         __create_an_item(KeyStr_VoiceRecorder, IMG_VoiceRecorder, "setting-voicerecorder-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 198
 199 #if SUPPORT_FMradio
 200         // FMradio setting
 201         __create_an_item_by_pkg(KeyStr_FMRadio, "org.tizen.fm-radio", "setting-fmradio-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 202         SETTING_TRACE_DEBUG("Added FMRadio");
 203 #endif
 204
 205
 206
 207
 208
 209
 210 #if DISABLED_CODE
 211         __create_an_item_by_pkg(KeyStr_NFC, "com.samsung.nfc-app", "setting-nfc-efl", Cfg_Item_Pos_Level0, Cfg_Item_unResetable);
 212 #endif
 213
 214         /* Downloaded App */
 215         __create_a_menu(KeyStr_DownloadedAPPs);
 216
 217         /* write to file */
 218         int ret = setting_cfg_file_write( category_list );
 219
 220         json_node_free( category_list );
 221
 222         return ret;
 223 }
 224
 225
 226 /* load file */
 227 int setting_cfg_file_read( void )
 228 {
 229 #if DISABLED_CODE
 230         if (access( CFG_FILE_PATH, R_OK|F_OK ) !=0 )
 231         {
 232                 SETTING_TRACE("file [%s] not legal, need to check your file-system.[%s:%d]\n", CFG_FILE_PATH, __FILE__, __LINE__);
 233                 //return Cfg_Error_Type_FilePermissionDenied;
 234                 return FALSE;
 235         }
 236 #endif
 237         parser = json_parser_new (); /* to be freed on exit */
 238
 239         /* file -> parser */
 240         GError *error = NULL;
 241         gboolean ret = json_parser_load_from_file( parser, CFG_FILE_PATH, &error );
 242
 243         if( FALSE == ret )
 244         {
 245                 return FALSE;
 246 #if DISABLED_CODE
 247                 SETTING_TRACE_ERROR("error->message:%s", (char*)(error->message));
 248
 249         /* The file is existing and can be accessed normally, but it was
 250          * loaded failed as a json script, it means setting.cfg is
 251          * damaged(not the normal formatting ), we need to remove
 252          * the file and recreate in next running time*/
 253                 SETTING_TRACE_ERROR("The file[%s] is existing and can be accessed "\
 254                             "normally, but it was loaded failed as a json "\
 255                             "script, it means setting.cfg is damaged (the "\
 256                             "formatting ia abnormal), we need to remove the"\
 257                             " file and recreate in next running time!",
 258                             CFG_FILE_PATH);
 259
 260         SETTING_TRACE("Trying to removing the damaged file.");
 261         if (remove(CFG_FILE_PATH) != 0)
 262         {
 263             SETTING_TRACE_ERROR("Error to remove the damaged file");
 264             return FALSE;
 265         }
 266
 267         if( FALSE == setting_cfg_create() )
 268         {
 269             SETTING_TRACE_ERROR("Error to create a new config file");
 270             return FALSE;
 271         }
 272         /*if the failed is  caused by reading the file recursively invoking */
 273         return setting_cfg_file_read();
 274 #endif
 275         }
 276
 277         /* parser -> root */
 278         root = json_parser_get_root( parser ); /* to be freed on exit*/
 279         return TRUE;
 280 }
 281
 282 /**
 283 * @brief dump JSON to file
 284 */
 285 int setting_cfg_file_write( JsonNode * node )
 286 {
 287         GError *error = NULL;
 288         JsonGenerator *generator = json_generator_new ();
 289         json_generator_set_root ( generator, node );
 290         g_object_set( generator, "pretty", TRUE, NULL ); //write file in indent format
 291         gboolean ret = json_generator_to_file( generator, CFG_FILE_PATH, &error );
 292         g_object_unref(generator);
 293
 294         /* ***BEGIN***  DAC black screen SAMSUNG 2010/8/9 add
 295          *add read permission
 296          *chown -R inhouse:inhouse /home/inhouse/setting.cfg
 297          */
 298         if( FALSE == ret )
 299         {
 300                 SETTING_TRACE_ERROR("Error writing file %s!", CFG_FILE_PATH );
 301                 return FALSE;
 302         }
 303         return TRUE;
 304 }
 305
 306 /*   public functions  */
 307 #if DISABLED_CODE
 308 int setting_cfg_init( void )
 309 {
 310         g_type_init ();
 311
 312         struct stat st;
 313         //int ret = -1;
 314
 315         if (access( CFG_FILE_DIR_PATH, R_OK|W_OK|F_OK ) !=0 )
 316     {
 317                 SETTING_TRACE_ERROR("dir [%s] not legal, need to check your file-system.[%s:%d]\n", CFG_FILE_DIR_PATH, __FILE__, __LINE__);
 318         return Cfg_Error_Type_DirPermissionDenied;
 319     }
 320         if( stat(CFG_FILE_DIR_PATH, &st) != 0)/* to make more stable */
 321         {
 322                 /* if (0 != system("sudo mkdir /opt/data/setting/")); */
 323                 /* if (EINA_TRUE != ecore_file_mkpath(CFG_FILE_DIR_PATH)); */
 324                 if (EINA_TRUE != ecore_file_mkdir(CFG_FILE_DIR_PATH));
 325                 {
 326                         perror("mkdir");
 327                         return Cfg_Error_Type_Mkdir_Failed;
 328                 }
 329         }
 330
 331         if( stat(CFG_FILE_PATH, &st) != 0)
 332         {
 333                 SETTING_TRACE_ERROR("Config file doesn't exist. Create it!");
 334                 if(     FALSE == setting_cfg_create() )
 335                 {
 336                         /* perror("setting_cfg_create"); */
 337                         return Cfg_Error_Type_CreateCfg_Failed;
 338                 }
 339                 stat(CFG_FILE_PATH, &st);
 340         }
 341         /* ***BEGIN***  error handle(caused by unstable file system) SAMSUNG 2010/9/10 add*/
 342         else if (0 == st.st_size ||
 343              0 != access( CFG_FILE_PATH, R_OK|F_OK ))
 344         {
 345                 SETTING_TRACE("the %s is 0 Byte, we need to recreate it.", CFG_FILE_PATH);
 346                 /* delete the file */
 347                 if (remove(CFG_FILE_PATH) != 0)
 348                 {
 349                         perror("remove");
 350                         return Cfg_Error_Type_RemoveCfg_Failed;
 351                 }
 352                 if(     FALSE == setting_cfg_create() )
 353                 {
 354                         /* perror("setting_cfg_create"); */
 355                         return Cfg_Error_Type_CreateCfg_Failed;
 356                 }
 357
 358         }
 359         /* ****END****  error handle(caused by unstable  file system) SAMSUNG 2010/9/10 add
 360          * cfg file exists but invalid -> re-create
 361          * load file into parser
 362          */
 363         if( FALSE == setting_cfg_file_read() )
 364         {
 365                 /* remove current setting file */
 366                 if (remove(CFG_FILE_PATH) != 0)
 367                 {
 368                         /* perror("remove"); */
 369                         return Cfg_Error_Type_RemoveCfg_Failed;
 370                 }
 371                 return Cfg_Error_Type_ReadCfg_Failed;
 372         }
 373
 374         return Cfg_Error_Type_Sucess;
 375 }
 376 #endif
 377
 378 int setting_cfg_init( void )
 379 {
 380         g_type_init ();
 381
 382         if (!access(CFG_FILE_PATH, R_OK|W_OK|F_OK )) { // succeed to access
 383                 if(!setting_cfg_file_read()) { // return FALSE
 384                         if (remove(CFG_FILE_PATH)) {
 385                                 return Cfg_Error_Type_RemoveCfg_Failed;
 386                         }
 387                         return Cfg_Error_Type_ReadCfg_Failed;
 388                 }
 389
 390                 return Cfg_Error_Type_Sucess;
 391         } else { // fail to access
 392                 switch (errno) {
 393                         // file non-existing case
 394                         case ENOENT:
 395                                 SETTING_TRACE_ERROR("non-existing file/dir");
 396                                 ecore_file_mkdir(CFG_FILE_DIR_PATH);
 397                                 if (!setting_cfg_create()) { // return FALSE
 398                                         SETTING_TRACE_ERROR("Error to create a new config file");
 399                                         return Cfg_Error_Type_CreateCfg_Failed;
 400                                 }
 401                                 if(!setting_cfg_file_read() ) { // return FALSE
 402                                         if (remove(CFG_FILE_PATH)) {
 403                                                 return Cfg_Error_Type_RemoveCfg_Failed;
 404                                         }
 405                                         return Cfg_Error_Type_ReadCfg_Failed;
 406                                 }
 407
 408                                 return Cfg_Error_Type_Sucess;
 409                         // other cases
 410                         case EACCES:
 411                         case EROFS:
 412                         default:
 413                                 return Cfg_Error_Type_DirPermissionDenied;
 414                 }
 415         }
 416 }
 417
 418 void setting_cfg_exit( void )
 419 {
 420         json_node_free(root);
 421         g_object_unref (parser);
 422 }
 423
 424 int setting_cfg_file_update( void )
 425 {
 426         if (access( CFG_FILE_PATH, W_OK|F_OK ) !=0 )
 427         {
 428                 return FALSE;
 429         }
 430         return setting_cfg_file_write( root );
 431 }
 432
 433 int setting_cfg_get_category_length( void )
 434 {
 435         return json_array_get_length( json_node_get_array( root ) );
 436 }
 437
 438 char* setting_cfg_get_category_name( int category_index )
 439 {
 440         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 441         return (char*)json_object_get_string_member( category_obj, "name" );
 442 }
 443
 444 int setting_cfg_get_menu_length( int category_index )
 445 {
 446         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 447         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 448         return json_array_get_length( menu );
 449 }
 450
 451 char * setting_cfg_get_keyname_idx( int category_index, int menu_index )
 452 {
 453         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 454         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 455         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 456         return (char*)json_object_get_string_member( menu_item, "key_name" );
 457 }
 458
 459 char * setting_cfg_get_string_field_idx( int category_index, int menu_index, char *field_name)
 460 {
 461         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 462         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 463         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 464
 465         char *data = (char *)json_object_get_string_member( menu_item, field_name );
 466         if (!safeStrCmp(data, "(null)"))/* pass NULL to ug_args when create setting.cfg. */
 467         {
 468                 return NULL;
 469         }
 470         return data;
 471 }
 472
 473 int setting_cfg_get_int_field_idx( int category_index, int menu_index , char *field_name)
 474 {
 475         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 476         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 477         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 478         return json_object_get_int_member( menu_item, field_name );
 479 }
 480
 481 char * setting_cfg_get_icon_path_idx( int category_index, int menu_index )
 482 {
 483         return setting_cfg_get_string_field_idx(category_index, menu_index, "icon_path");
 484 }
 485
 486 char * setting_cfg_get_ug_args_idx( int category_index, int menu_index )
 487 {
 488         return setting_cfg_get_string_field_idx(category_index, menu_index, "ug_args");
 489 }
 490
 491 char * setting_cfg_get_ugpath_idx( int category_index, int menu_index )
 492 {
 493         return setting_cfg_get_string_field_idx(category_index, menu_index, "ug_path");
 494 }
 495
 496 char * setting_cfg_get_ugpath( char * keyname )
 497 {
 498         int i, j;
 499         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 500         {
 501                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 502                 {
 503                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 504                                 return setting_cfg_get_ugpath_idx( i, j );
 505                 }
 506         }
 507         return NULL;
 508 }
 509
 510 int setting_cfg_get_pos_idx( int category_index, int menu_index )
 511 {
 512         return setting_cfg_get_int_field_idx(category_index, menu_index, "pos");
 513 }
 514
 515 int setting_cfg_get_pos( char * keyname )
 516 {
 517         int i, j;
 518         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 519         {
 520                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 521                 {
 522                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 523                                 return setting_cfg_get_pos_idx( i, j );
 524                 }
 525         }
 526         return 0;
 527 }
 528
 529 void setting_cfg_set_pos_idx( int category_index, int menu_index, int pos )
 530 {
 531         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 532         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 533         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 534         json_object_remove_member( menu_item, "pos" );
 535         json_object_set_int_member( menu_item, "pos", pos );
 536 }
 537
 538 void setting_cfg_set_pos( char * keyname, int pos )
 539 {
 540         int i, j;
 541         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 542         {
 543                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 544                 {
 545                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 546                         {
 547                                 setting_cfg_set_pos_idx( i, j, pos );
 548                                 return ;
 549                         }
 550                 }
 551         }
 552
 553 }
 554
 555 int setting_cfg_get_click_times_idx( int category_index, int menu_index )
 556 {
 557         return setting_cfg_get_int_field_idx(category_index, menu_index, "click_times");
 558 }
 559
 560 int setting_cfg_get_click_times( char * keyname )
 561 {
 562         int i, j;
 563         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 564         {
 565                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 566                 {
 567                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 568                                 return setting_cfg_get_click_times_idx( i, j );
 569                 }
 570         }
 571         return 0;
 572 }
 573
 574 void setting_cfg_set_click_times_idx( int category_index, int menu_index, int click_times )
 575 {
 576         JsonObject * category_obj = json_array_get_object_element( json_node_get_array( root ), category_index );
 577         JsonArray * menu = json_object_get_array_member( category_obj, "menu" );
 578         JsonObject * menu_item = json_array_get_object_element( menu, menu_index );
 579         json_object_remove_member( menu_item, "click_times" );
 580         json_object_set_int_member( menu_item, "click_times", click_times );
 581 }
 582
 583 void setting_cfg_set_click_times( char * keyname, int click_times )
 584 {
 585         int i, j;
 586         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 587         {
 588                 for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 589                 {
 590                         if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 591                         {
 592                                 setting_cfg_set_click_times_idx( i, j, click_times );
 593                                 return ;
 594                         }
 595                 }
 596         }
 597
 598 }
 599
 600 int setting_cfg_get_resetable_flag_idx(int category_index, int menu_index)
 601 {
 602         return setting_cfg_get_int_field_idx(category_index, menu_index,
 603                                              "is_resetable");
 604 }
 605
 606 void setting_cfg_add_downloaded_app( char *keyname, char *icon_path, char *ug_args, int pos)
 607 {
 608         int i;
 609         JsonNode *menu_item;
 610         JsonObject *object;
 611         JsonArray *menu;
 612
 613         for( i=0; i<setting_cfg_get_category_length(); i++ )
 614         {
 615                 if( safeStrCmp( setting_cfg_get_category_name(i), "Downloaded App" ) == 0 )
 616                 {
 617                         menu_item = json_node_new( JSON_NODE_OBJECT );
 618                         object = json_object_new();
 619                         json_node_take_object ( menu_item, object );
 620                         json_object_set_string_member( object, "key_name", keyname );
 621                         json_object_set_string_member( object, "icon_path", icon_path );
 622                         json_object_set_string_member( object, "ug_args", ug_args );
 623                         json_object_set_int_member( object, "pos", pos );
 624
 625                         object = json_array_get_object_element( json_node_get_array( root ), i );
 626                         menu = json_object_get_array_member( object, "menu" );
 627                         json_array_add_element( menu, menu_item );
 628                 }
 629         }
 630 }
 631
 632 void setting_cfg_remove_downloaded_app( char * keyname )
 633 {
 634         int i, j;
 635         JsonObject *object;
 636         JsonArray *menu;
 637
 638         for( i = 0; i < setting_cfg_get_category_length(); i++ )
 639         {
 640                 if( safeStrCmp( setting_cfg_get_category_name(i), "Downloaded App" ) == 0 )
 641                 {
 642                         for( j = 0; j < setting_cfg_get_menu_length( i ); j++ )
 643                         {
 644                                 if( safeStrCmp( setting_cfg_get_keyname_idx( i, j ), keyname ) == 0 )
 645                                 {
 646                                         object = json_array_get_object_element( json_node_get_array( root ), i );
 647                                         menu = json_object_get_array_member( object, "menu" );
 648                                         json_array_remove_element( menu, j );
 649                                         return ;
 650                                 }
 651                         }
 652                 }
 653         }
 654 }
 655
 656 bool is_ug_installed_by_ug_args(void *data)
 657 {
 658         retv_if(!data, TRUE);//if passing NULL,drawing it
 659         char* ug_args = data;
 660         char *ug_name = get_ug_path_from_ug_args(ug_args);
 661
 662         bool is_installed_in_usr = false;
 663         bool is_installed_in_opt = false;
 664
 665         //1.first do exist-checking in /usr/ug/lib
 666         char ug_file[PATH_MAX + 1];
 667         snprintf(ug_file, PATH_MAX, "%s/libug-%s.so", SETTING_UG_PATH, ug_name);
 668         struct stat st;
 669         if(stat(ug_file, &st) != 0) {
 670
 671                 //2.if it does not exit in /usr/ug/lib, then do exist-checking in /usr/ug/lib
 672                 memset(ug_file, 0x00, PATH_MAX + 1);
 673                 snprintf(ug_file, PATH_MAX, "%s/libug-%s.so", SETTING_UG_PATH_USR, ug_name);
 674                 if(stat(ug_file, &st) != 0) {
 675                         //both not exist,skip it
 676                         SETTING_TRACE_ERROR(" libug-%s.so is *NOT* present, so skip it..\n", ug_name);
 677                         //return FALSE;
 678                         is_installed_in_usr = false;
 679                 }
 680         }
 681         is_installed_in_usr = true;
 682
 683         //2.first do exist-checking in /opt/ug/lib
 684         //char ug_file[PATH_MAX + 1];
 685         memset(ug_file, 0x00, PATH_MAX + 1);
 686         snprintf(ug_file, PATH_MAX, "%s/libug-%s.so", SETTING_UG_PATH_OPT, ug_name);
 687         //struct stat st;
 688         if(stat(ug_file, &st) != 0) {
 689
 690                 //2.if it does not exit in /usr/ug/lib, then do exist-checking in /usr/ug/lib
 691                 memset(ug_file, 0x00, PATH_MAX + 1);
 692                 snprintf(ug_file, PATH_MAX, "%s/libug-%s.so", SETTING_UG_PATH_USR_OPT, ug_name);
 693                 if(stat(ug_file, &st) != 0) {
 694                         //both not exist,skip it
 695                         SETTING_TRACE_ERROR(" libug-%s.so is *NOT* present, so skip it..\n", ug_name);
 696                         //return FALSE;
 697                         is_installed_in_opt = false;
 698                 }
 699         }
 700         is_installed_in_opt = true;
 701
 702         return (is_installed_in_opt || is_installed_in_opt);
 703 }
 704
 705 /*other relative function*/
 706 char *get_ug_path_from_ug_args(void *data)
 707 {
 708         /*SETTING_TRACE_BEGIN;*/
 709         char *p = (char *)data;
 710         if (NULL == p || '\0' == p[0]) {
 711                 return NULL;
 712         }
 713
 714         char *q = strchr(p, '|');
 715         char *path = NULL;
 716
 717         if (q) {                /* copy out the content before '|'; eg, ab|cd */
 718                 path = (char *)calloc(1, q - p + 1);
 719                 setting_retvm_if(!path, NULL, "calloc failed");
 720                 safeCopyStr(path, p, q - p);
 721                 /* redundant handle */
 722                 path[q - p] = '\0';
 723         } else {                /* copy out all the content. eg.abb */
 724
 725                 path = (char *)calloc(1, safeStrLen(p) + 1);
 726                 setting_retvm_if(!path, NULL, "calloc failed");
 727                 safeCopyStr(path, p, safeStrLen(p));
 728         }
 729         /*SETTING_TRACE("get the ug['%s']", path);*/
 730         return path;
 731 }
 732
 733 service_h get_bundle_from_ug_args(void *data)
 734 {
 735         /*SETTING_TRACE_BEGIN;*/
 736         char *p = (char *)data;
 737         if (NULL == p || '\0' == p[0]) {
 738                 return NULL;
 739         }
 740         char *m = NULL;
 741         char *q = strchr(p, '|');
 742         if (q) {                /* (key, value) pairs exit. eg: ug_args = "sevenemail-setting-efl|caller:setting; cmd:main option" */
 743                 /* alloc data */
 744                 service_h svc;
 745                 if (service_create(&svc))
 746                         return NULL;
 747                 int str_len = safeStrLen(p) + 1;
 748                 char *v_key = (char *)calloc(1, str_len);
 749                 if (!v_key) {
 750                         service_destroy(svc);
 751                         return NULL;
 752                 }
 753
 754                 char *v_value = (char *)calloc(1, str_len);
 755                 if (!v_value) {
 756                         service_destroy(svc);
 757                         FREE(v_key);
 758                         return NULL;
 759                 }
 760
 761                 p = ++q;
 762                 while (p) {
 763                         q = strchr(p, ';');
 764                         if (q) {        /* not the last field */
 765                                 m = strchr(p, ':');     /* ziduannei */
 766                                 if (m) {
 767                                         safeCopyStr(v_key, p, m - p);
 768
 769                                         ++m;
 770                                         safeCopyStr(v_value, m, q - m);
 771                                         SETTING_TRACE
 772                                             ("To add ('%s', '%s') to bundle data",
 773                                              v_key, v_value);
 774                                         service_add_extra_data(svc, v_key, v_value);
 775                                 } else {
 776                                         SETTING_TRACE_ERROR
 777                                             ("invalid key-value format!!\n");
 778                                         break;  /* end the whole while */
 779                                 }
 780                         } else {        /* the last field */
 781
 782                                 m = strchr(p, ':');     /* ziduannei */
 783                                 if (m) {
 784                                         safeCopyStr(v_key, p, m - p);
 785                                         ++m;
 786                                         safeCopyStr(v_value, m, safeStrLen(m));
 787
 788                                         service_add_extra_data(svc, v_key, v_value);
 789                                 } else {
 790                                         SETTING_TRACE_ERROR
 791                                             ("invalid key-value format!!\n");
 792                                 }
 793                                 break;  /* end the whole while */
 794                         }
 795
 796                         memset(v_key, '\0', str_len);
 797                         memset(v_value, '\0', str_len);
 798                         p = ++q;
 799                 }
 800
 801                 FREE(v_key);
 802                 FREE(v_value);
 803                 return svc;
 804         } else {                /* eg: ug_args = "setting-browser-efl" */
 805
 806                 /*SETTING_TRACE("(key, value) pairs not exit");*/
 807                 return NULL;
 808         }
 809
 810 }
 811