setting-about/src/setting-about-main.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-about-main.h>
  23 #include <aul.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <system_info.h>
  27 #include <fcntl.h>
  28
  29 #include <bluetooth.h>
  30 #include <wifi.h>
  31
  32 #include <app_manager.h>
  33 #include <efl_assist_events.h>
  34 #include <ITapiModem.h>
  35
  36
  37 #ifndef KEY_BACK
  38 #define KEY_BACK "X86Back_MOCK"
  39 #endif
  40
  41
  42 #define MAX_DEVICE_NAME_LEN             32
  43
  44 #define DEVICED_BUS_NAME                        "org.tizen.system.deviced"
  45 #define DEVICED_OBJECT_PATH                     "/Org/Tizen/System/DeviceD"
  46 #define DEVICED_INTERFACE_NAME          DEVICED_BUS_NAME
  47 #define DEVICED_PATH_BOARD                      DEVICED_OBJECT_PATH"/Board"
  48 #define DEVICED_INTERFACE_BOARD         DEVICED_INTERFACE_NAME".Board"
  49 #define METHOD_GET_SERIAL                       "GetSerial"
  50
  51
  52 /** @todo : need to handle unicode encoded input characters */
  53
  54 #define DEVICE_NAME                                     "IDS_ST_HEADER_DEVICE_NAME"
  55 #define DEVICE_NAME_EXCEED_STR  "IDS_ST_TPOP_MAXIMUM_NUMBER_OF_CHARACTERS_REACHED"
  56
  57
  58 #define EMPTY_LIMITATION_STR            "IDS_ST_BODY_THE_NAME_FIELD_CANNOT_BE_EMPTY"
  59 #define SOFTWARE_UPDATE_STR             "IDS_ST_MBODY_SOFTWARE_UPDATE"
  60 #define DEVICE_NAME_UNALLOWED_SPACE_KEY_STR "Device name cannot contain spaces"
  61 #define DEVICE_NAME_DEFAULE     "Redwood"
  62
  63 #define APP_NAME "Settings"
  64
  65 static int setting_about_main_create(void *cb);
  66 static int setting_about_main_destroy(void *cb);
  67 static int setting_about_main_update(void *cb);
  68 static int setting_about_main_cleanup(void *cb);
  69
  70 setting_view setting_view_about_main = {
  71         .create = setting_about_main_create,
  72         .destroy = setting_about_main_destroy,
  73         .update = setting_about_main_update,
  74         .cleanup = setting_about_main_cleanup,
  75 };
  76
  77 void __setting_about_gl_realized_cb(void *data, Evas_Object *obj, void *event_info)
  78 {
  79         /*SETTING_TRACE_BEGIN; */
  80         setting_retm_if(event_info == NULL, "invalid parameter: event_info is NULL");
  81         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
  82         /*Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *)elm_object_item_data_get(item); */
  83
  84         #if 0
  85         if (elm_config_access_get()) {
  86                 /* ===== Accessibility ==== */
  87                 const Elm_Genlist_Item_Class *itc = elm_genlist_item_item_class_get(item);
  88                 if (itc && itc->item_style && !safeStrCmp(itc->item_style, "dialogue/editfield/title")) {
  89                         /* Register bg_dialogue image instead whole item */
  90                         Evas_Object *acc = elm_object_item_part_access_register(item, "bg_dialogue");
  91                 }
  92         }
  93         #endif
  94
  95 }
  96
  97 #if 0
  98 static void __setting_about_main_remove_noti(void *data)
  99 {
 100         SETTING_TRACE_BEGIN;
 101         setting_retm_if(data == NULL, "Invalid argument: data is NULL");
 102         SettingAboutUG *ad = (SettingAboutUG *) data;
 103         notification_h noti = NULL;
 104         notification_error_e ret = NOTIFICATION_ERROR_NONE;
 105
 106         if (ad->noti_id) {
 107                 noti = notification_load(APP_NAME, ad->noti_id);
 108                 if (noti == NULL) {
 109                         SETTING_TRACE("Notification can be deleted already");
 110                 } else {
 111                         ret = notification_delete(noti);
 112                         if (ret != NOTIFICATION_ERROR_NONE) {
 113                                 SETTING_TRACE_ERROR("Fail to notification_delete [%d]", ret);
 114
 115                                 ret = notification_free(noti);
 116                                 if (ret != NOTIFICATION_ERROR_NONE) {
 117                                         SETTING_TRACE_ERROR("Fail to notification_free [%d]", ret);
 118                                 }
 119                                 return;
 120                         }
 121
 122                         ret = notification_free(noti);
 123                         if (ret != NOTIFICATION_ERROR_NONE) {
 124                                 SETTING_TRACE_ERROR("Fail to notification_free [%d]", ret);
 125                                 return;
 126                         }
 127                 }
 128                 ad->noti_id = 0;
 129         }
 130 }
 131 #endif
 132
 133 /**
 134  * @brief popup response callback fuc.
 135  *
 136  * @param data application context
 137  * @param obj Evas Object
 138  * @param event_info even type
 139  *
 140  * @return no return
 141  */
 142 static void __setting_about_popup_rsp_cb(void *data, Evas_Object *obj, void *event_info)
 143 {
 144
 145         SETTING_TRACE_BEGIN;
 146         setting_retm_if(obj == NULL, "obj parameter is NULL");
 147         setting_retm_if(data == NULL, "Data parameter is NULL");
 148         SettingAboutUG *ad = (SettingAboutUG *) data;
 149         /*Evas_Object *popup = data; */
 150         switch (btn_type(obj)) {
 151                 case POPUP_RESPONSE_OK: {
 152                                 if (ad->popup) {
 153                                         ad->popup_showed_flag = FALSE;
 154
 155                                         evas_object_del(ad->popup);
 156                                         ad->popup = NULL;
 157                                 }
 158                                 if (ad->item_dev_name && ad->item_dev_name->eo_check) {
 159                                         char *name_value = NULL;
 160                                         name_value = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
 161                                         if (NULL == name_value) {
 162                                                 /*use the defaule name if get vconf failed*/
 163                                                 name_value = (char *)g_strdup(DEVICE_NAME_DEFAULE);
 164                                         }
 165                                         elm_object_focus_set(ad->item_dev_name->eo_check, EINA_TRUE);
 166                                         /*for genlist update */
 167                                         elm_entry_entry_set(ad->item_dev_name->eo_check, name_value);
 168                                         elm_entry_cursor_end_set(ad->item_dev_name->eo_check);
 169                                         G_FREE(ad->item_dev_name->sub_desc);/*release first */
 170                                         ad->item_dev_name->sub_desc = (char *)g_strdup(name_value);
 171                                         FREE(name_value);
 172                                         SETTING_TRACE("ad->item_dev_name->sub_desc:%s", ad->item_dev_name->sub_desc);
 173                                         Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(ad->item_dev_name->eo_check);
 174                                         if (imf_context) {
 175                                                 ecore_imf_context_input_panel_show(imf_context);
 176                                         }
 177                                 }
 178                                 break;
 179                         }
 180                 default: {
 181                                 break;
 182                         }
 183         }
 184
 185 }
 186
 187 /**
 188  * @brief callback run for idler task to destroy an popup.
 189  *
 190  * @param data application context
 191  *
 192  * @return FALSE for call it once, TRUE for call once the CPU is in idler
 193  */
 194 static Eina_Bool __setting_about_popup_remove_delay(void *data)
 195 {
 196         SETTING_TRACE_BEGIN;
 197         SettingAboutUG *ad = data;
 198         if (ad->popup_space) {
 199                 evas_object_del(ad->popup_space);
 200                 ad->popup_space = NULL;
 201                 ad->popup_showed_flag = FALSE;
 202         }
 203         return FALSE;
 204 }
 205
 206 /**
 207  * @brief callback for popup destory.
 208  *
 209  * @param data application context
 210  * @param e Evas handler
 211  * @param obj Evas object
 212  * @param event_info event type
 213  */
 214 static void __setting_about_popup_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 215
 216 {
 217         SETTING_TRACE_BEGIN;
 218         retm_if(data == NULL, "Data parameter is NULL");
 219         SettingAboutUG *ad = (SettingAboutUG *)data;
 220         ad->popup = NULL;
 221         ad->popup_showed_flag = FALSE;
 222 }
 223
 224 /**
 225  * @brief callback run for idler task to show an popup.
 226  *
 227  * @param data application context
 228  */
 229 static Eina_Bool __setting_about_popup_show_delay(void *data)
 230 {
 231         SETTING_TRACE_BEGIN;
 232         retvm_if(data == NULL, FALSE, "Data parameter is NULL");
 233         SettingAboutUG *ad = (SettingAboutUG *)data;
 234
 235         /*popup the message and display the original name if the input is empty*/
 236         SETTING_TRACE("POP UP again");
 237
 238         if (NULL == ad->popup) {
 239                 ad->popup_showed_flag = true;
 240                 ad->popup = setting_create_popup_with_btn(ad, ad->win_get, "IDS_ST_HEADER_ENTER_VALID_DEVICE_NAME_ABB",
 241                                                           _("IDS_ST_POP_YOU_MUST_ENTER_A_DEVICE_NAME"),
 242                                                           __setting_about_popup_rsp_cb, 0,
 243                                                           1, _("IDS_ST_BUTTON_OK_ABB"));
 244                 evas_object_event_callback_add(ad->popup, EVAS_CALLBACK_DEL, __setting_about_popup_del_cb, ad);
 245         }
 246
 247         return FALSE;
 248 }
 249
 250 /**
 251  * @brief callback run for idler task to destroy an popup.
 252  *
 253  * @param data application context
 254  *
 255  * @return FALSE for call it once, TRUE for call once the CPU is in idler
 256  */
 257 static void __setting_about_popup_mobile_ap_turn_off_ask_resp_cb(void *data,
 258                                                                  Evas_Object *obj,
 259                                                                  void *event_info)
 260 {
 261         SETTING_TRACE_BEGIN;
 262         setting_retm_if(data == NULL, "Data parameter is NULL");
 263         SettingAboutUG *ad = (SettingAboutUG *)data;
 264         int response_type = btn_type(obj);
 265
 266         if (POPUP_RESPONSE_OK == response_type) {
 267                 /* disable tehering*/
 268 #if SUPPORT_TETHERING
 269                 tethering_h th = NULL;
 270                 tethering_error_e ret = TETHERING_ERROR_NONE;
 271
 272                 ret = tethering_create(&th);
 273                 if (ret != TETHERING_ERROR_NONE) {
 274                         return;
 275                 }
 276                 if (tethering_is_enabled(NULL, TETHERING_TYPE_WIFI) == TRUE) {
 277                         tethering_disable(th, TETHERING_TYPE_WIFI);
 278                 }
 279                 tethering_destroy(th);
 280 #endif
 281                 if (ad->item_dev_name && ad->item_dev_name->eo_check) {
 282                         elm_object_focus_allow_set(ad->item_dev_name->eo_check, EINA_TRUE);
 283                         elm_object_focus_set(ad->item_dev_name->eo_check, EINA_TRUE);
 284                         elm_entry_cursor_end_set(ad->item_dev_name->eo_check);
 285
 286                         Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(ad->item_dev_name->eo_check);
 287                         if (imf_context) {
 288                                 ecore_imf_context_input_panel_show(imf_context);
 289                         }
 290                 }
 291         } else if (POPUP_RESPONSE_CANCEL == response_type) {
 292
 293                 /* do nothing */
 294
 295         }
 296
 297         if (ad->popup) {
 298                 evas_object_del(ad->popup);
 299                 ad->popup = NULL;
 300         }
 301
 302
 303 }
 304
 305 /**
 306  * @brief regulatory popup response cp.
 307  *
 308  * @param data application context
 309  * @param obj evas object
 310  * @param event_info event type
 311  */
 312
 313 static void __setting_about_popup_regulatory_info_rsp_cb(void *data, Evas_Object *obj, void *event_info)
 314 {
 315         retm_if(data == NULL, "Data parameter is NULL");
 316         evas_object_del(data);
 317 }
 318
 319
 320 /**
 321  * @brief show regulatory info popup.
 322  *
 323  * @param data application context
 324  */
 325 static void __setting_about_popup_regulatory_info(void *data)
 326 {
 327         SETTING_TRACE_BEGIN;
 328
 329         Evas_Object *popup;
 330         SettingAboutUG *ad;
 331         Evas_Object *layout;
 332         Evas_Object *icon;
 333         Evas_Object *btn1;
 334         char buf[4096];
 335
 336         ad = (SettingAboutUG *) data;
 337         popup = elm_popup_add(ad->win_main_layout);
 338         ea_object_event_callback_add(popup, EA_CALLBACK_BACK, ea_popup_back_cb, NULL);
 339
 340         elm_object_part_text_set(popup, "title,text", _(KeyStr_Regulatory_Info));
 341         layout = elm_layout_add(popup);
 342         elm_layout_file_set(layout, SETTING_THEME_EDJ_NAME, "popup_center_image");
 343         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 344
 345         icon = elm_image_add(layout);
 346         snprintf(buf, sizeof(buf), "%s/00_popup_regulatory_info.png", SETTING_ICON_PATH);
 347         elm_image_file_set(icon, buf, NULL);
 348         elm_image_resizable_set(icon, EINA_TRUE, EINA_TRUE);
 349         elm_object_part_content_set(layout, "elm.swallow.content", icon);
 350
 351         evas_object_show(layout);
 352         elm_object_content_set(popup, layout);
 353
 354         btn1 = elm_button_add(popup);
 355         elm_object_style_set(btn1, "popup");
 356         elm_object_text_set(btn1, _("IDS_ST_BUTTON_OK"));
 357         elm_object_part_content_set(popup, "button1", btn1);
 358         evas_object_smart_callback_add(btn1, "clicked", __setting_about_popup_regulatory_info_rsp_cb, popup);
 359         evas_object_show(popup);
 360
 361         SETTING_TRACE_END;
 362 }
 363
 364 /**
 365  * @brief get Model Name.
 366  *              - No ini: Unavailable
 367  *              - I9500 @ target: GT-I9500
 368  *              - I9500 @ emul: SDK
 369  *              - SLP   @ target: GT-SLP
 370  *              - SLP   @ emul: SDK
 371  *
 372  * @param szStr the buffer for store the model name
 373  * @param nSize buffer size
 374  */
 375 void setting_about_main_get_phone_model_name(char *szStr, int nSize)
 376 {
 377         retm_if(szStr == NULL, "szStr parameter is NULL");
 378
 379         char *value = NULL;
 380         int ret = system_info_get_platform_string("http://tizen.org/system/model_name", &value);
 381         SETTING_TRACE("value : %s", value);
 382         if (ret != SYSTEM_INFO_ERROR_NONE) {
 383                 SETTING_TRACE_ERROR("fail to call system_info_get_platform_string");
 384                 FREE(value);
 385                 snprintf(szStr, nSize, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 386                 return;
 387         }
 388
 389         if (value) {
 390                 snprintf(szStr, nSize, "%s", value);
 391         } else {
 392                 snprintf(szStr, nSize, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 393         }
 394
 395         FREE(value);
 396 }
 397
 398 /**
 399  * @brief get software version.
 400  *
 401  * @param szStr the buffer for store SW version
 402  * @param nSize buffer size
 403  */
 404 void setting_about_main_get_sw_version(char *szStr, int nSize)
 405 {
 406         retm_if(szStr == NULL, "szStr parameter is NULL");
 407
 408         char *version = NULL;
 409         int ret = system_info_get_platform_string("http://tizen.org/feature/platform.version", &version);
 410         if (ret != SYSTEM_INFO_ERROR_NONE) {
 411                 SETTING_TRACE_ERROR("fail to call system_info_get_platform_string");
 412                 FREE(version);
 413                 snprintf(szStr, nSize, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 414                 return;
 415         }
 416
 417         char *build_info = NULL;
 418         ret = system_info_get_platform_string("http://tizen.org/system/build.string", &build_info);
 419         if (ret != SYSTEM_INFO_ERROR_NONE) {
 420                 SETTING_TRACE_ERROR("fail to call system_info_get_platform_string");
 421                 FREE(version);
 422                 FREE(build_info);
 423                 snprintf(szStr, nSize, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 424                 return;
 425         }
 426
 427         snprintf(szStr, nSize, "TIZEN %s (%s)", version, build_info);
 428
 429         FREE(version);
 430         FREE(build_info);
 431 }
 432
 433 /**
 434  * @brief get software version.
 435  *
 436  * @param szStr the buffer for store SW version
 437  * @param nSize buffer size
 438  */
 439 void setting_about_main_get_wifi_mac_address_string(char *str, int size)
 440 {
 441         SETTING_TRACE_BEGIN;
 442         setting_retm_if(str == NULL, "str parameter is NULL");
 443         setting_retm_if(size < SETTING_ABOUT_WIFI_MAC_STR_LEN + 1, "size parameter is wrong");
 444
 445         char *mac_addr = NULL;
 446         int status = wifi_get_mac_address(&mac_addr);
 447         if (WIFI_ERROR_NONE != status) {
 448                 SETTING_TRACE_ERROR("Failed to call wifi_get_mac_address()");
 449         } else {
 450                 SETTING_TRACE_ERROR("Success to call wifi_get_mac_address()");
 451         }
 452
 453         if (mac_addr) {
 454                 safeCopyStr(str, mac_addr, SETTING_ABOUT_WIFI_MAC_STR_LEN);
 455                 SETTING_TRACE_DEBUG("get_wifi_mac_address : %s", mac_addr);
 456                 free(mac_addr);
 457         }
 458
 459
 460         SETTING_TRACE_DEBUG("get_wifi_mac_address : %s", str);
 461
 462         if ((status != WIFI_ERROR_NONE) || (safeStrLen(str) == 0)) {
 463                 snprintf(str, size, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 464         }
 465 }
 466
 467 static DBusMessage *dbus_method_sync_with_reply(const char *dest, const char *path,
 468                                                 const char *interface, const char *method,
 469                                                 const char *sig, char *param[])
 470 {
 471         DBusConnection *conn;
 472         DBusMessage *msg;
 473         DBusMessageIter iter;
 474         DBusMessage *reply;
 475         DBusError err;
 476
 477         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 478         if (!conn) {
 479                 return NULL;
 480         }
 481
 482         msg = dbus_message_new_method_call(dest, path, interface, method);
 483         if (!msg) {
 484                 return NULL;
 485         }
 486
 487         dbus_message_iter_init_append(msg, &iter);
 488
 489         dbus_error_init(&err);
 490
 491         reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err);
 492         if (!reply) {
 493         }
 494
 495         if (dbus_error_is_set(&err)) {
 496                 SETTING_TRACE_ERROR("dbus_connection_send error(%s:%s)", err.name, err.message);
 497                 dbus_error_free(&err);
 498                 reply = NULL;
 499         }
 500
 501         dbus_message_unref(msg);
 502         return reply;
 503 }
 504
 505 /**
 506  * @brief get serial number.
 507  *
 508  * @param szStr the buffer for store SN
 509  * @param nSize buffer size
 510  */
 511 void setting_about_main_get_sn(char *szStr, int nSize)
 512 {
 513         retm_if(szStr == NULL, "szStr parameter is NULL");
 514
 515         DBusError err;
 516         DBusMessage *msg;
 517         int ret, len;
 518         char *serial_num;
 519
 520         msg = dbus_method_sync_with_reply(DEVICED_BUS_NAME, DEVICED_PATH_BOARD,
 521                                           DEVICED_INTERFACE_BOARD, METHOD_GET_SERIAL, NULL, NULL);
 522         if (!msg) {
 523                 SETTING_TRACE_ERROR("fail send message");
 524                 snprintf(szStr, nSize, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 525                 return;
 526         }
 527
 528         dbus_error_init(&err);
 529
 530
 531         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &serial_num, DBUS_TYPE_INT32, &len, DBUS_TYPE_INVALID);
 532         if (!ret) {
 533                 SETTING_TRACE_ERROR("no message : [%s:%s]", err.name, err.message);
 534                 snprintf(szStr, nSize, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 535                 return;
 536         }
 537
 538         dbus_message_unref(msg);
 539         dbus_error_free(&err);
 540
 541         if (serial_num && strlen(serial_num)) {
 542                 snprintf(szStr, nSize, "%s", serial_num);
 543         } else {
 544                 snprintf(szStr, nSize, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 545         }
 546 }
 547
 548
 549 /**
 550  * @brief get current battery percentage.
 551  *
 552  * @param szStr the buffer for store battery percentage
 553  * @param nSize buffer size
 554  */
 555 void setting_about_main_get_battery_string(char *str, int size)
 556 {
 557         setting_retm_if(str == NULL, "str parameter is NULL");
 558
 559         int val = -1;
 560         char file[MAX_DISPLAY_STR_LEN_ON_PHONE_INFO] = { 0, };
 561         snprintf(file, MAX_DISPLAY_STR_LEN_ON_PHONE_INFO,
 562                  "%s/%s/%s", SETTING_ABOUT_POWER_SUPPLY_PATH, "battery", "capacity");
 563
 564         char buf[MAX_DISPLAY_STR_LEN_ON_PHONE_INFO] = { 0, };
 565         int fd = 0;
 566         int r = 0;
 567
 568         fd = open(file, O_RDONLY);
 569         if (fd != -1) {
 570                 r = read(fd, buf, MAX_DISPLAY_STR_LEN_ON_PHONE_INFO);
 571                 if ((r >= 0) && (r < MAX_DISPLAY_STR_LEN_ON_PHONE_INFO)) {
 572                         buf[r] = '\0';
 573                         val = atoi(buf);
 574                         snprintf(str, size, "%d%s", val, "\%");
 575                 } else {
 576                         SETTING_TRACE_ERROR("read file fail");
 577                         snprintf(str, size, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 578                 }
 579
 580                 close(fd);
 581         } else {
 582                 SETTING_TRACE_ERROR("open file fail");
 583                 snprintf(str, size, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 584         }
 585 }
 586
 587 /**
 588  * @brief get bluetooth address.
 589  *
 590  * @param szStr the buffer for store bluetooth address
 591  * @param nSize buffer size
 592  */
 593 void setting_about_main_get_bluetooth_address_string(char *str, int size)
 594 {
 595         setting_retm_if(str == NULL, "str parameter is NULL");
 596
 597         int ret = 0;
 598
 599         ret = bt_initialize();
 600         setting_retm_if(ret != 0, "bluetooth initialization failed");
 601
 602         char *local_address = NULL;
 603         ret = bt_adapter_get_address(&local_address);
 604
 605         bt_deinitialize();
 606
 607         if (ret < 0) {
 608                 snprintf(str, size, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 609                 SETTING_TRACE_DEBUG("bt address : %s failed get bt address with error code:%d", str, ret);
 610         } else {
 611                 SETTING_TRACE_DEBUG("bt address : %s", local_address);
 612                 snprintf(str, size, "%s", local_address);
 613         }
 614
 615         if (local_address) {
 616                 free(local_address);
 617         }
 618 }
 619
 620 /**
 621  * @brief get CPU usage.
 622  *
 623  * @param szStr the buffer for store CPU usage
 624  * @param nSize buffer size
 625  *
 626  * @return -ENOENT means failed to get CPU info, otherwise ok.
 627  */
 628 int setting_about_main_stat_get_cpuinfo(float *usr_pct, float *sys_pct)
 629 {
 630         setting_retvm_if(usr_pct == NULL, -ENOENT, "param usr_pct is null");
 631         setting_retvm_if(sys_pct == NULL, -ENOENT, "param sys_pct is null");
 632
 633         /*  default value */
 634         *usr_pct = 0.0;
 635         *sys_pct = 0.0;
 636         static unsigned long long usr_time = 0, /*nice_time = 0,*/ sys_time = 0;
 637         static unsigned long long old_usr = 0, /*old_nice = 0,*/ old_sys = 0;
 638         static struct timeval old_tv, cur_tv;
 639         unsigned long long elapsed_tick;
 640         long tick_per_sec;
 641         long cpu_num;
 642         FILE *fp = NULL;
 643         int ret = 0;
 644
 645         tick_per_sec = sysconf(_SC_CLK_TCK);
 646         cpu_num = sysconf(_SC_NPROCESSORS_ONLN);
 647
 648         if (cpu_num < 1) {
 649                 cpu_num = 1;
 650         }
 651
 652         gettimeofday(&cur_tv, NULL);
 653         fp = fopen(SETTING_ABOUT_STAT_PATH, "r");
 654         if (fp == NULL) {
 655                 SETTING_TRACE_ERROR("fp == NULL");
 656                 return -ENOENT;
 657         }
 658
 659         char cpu_info[MAX_COMMON_BUFFER_LEN] = {0,};
 660         char *cpu_info_p = fgets(cpu_info, MAX_COMMON_BUFFER_LEN, fp);
 661
 662         if (cpu_info_p == NULL) {
 663                 SETTING_TRACE_ERROR("fgets failed");
 664                 fclose(fp);   /* free - code */
 665                 return -ENOENT;
 666         }
 667
 668         char *substr = NULL;
 669         unsigned long long tmp_long = 0;
 670         int i = 0;
 671         /* split cpu_info, get 3 numbers headmost*/
 672         while ((substr = strsep(&cpu_info_p, " \t")) != NULL) {
 673                 char *endptr = NULL;
 674                 tmp_long = strtoull(substr, &endptr, 10);
 675                 if (tmp_long != 0 && tmp_long != ULLONG_MAX) {
 676                         switch (i) {
 677                                 case 0:
 678                                         usr_time = tmp_long;
 679                                         break;
 680                                 case 1:
 681                                         /*nice_time = tmp_long;*/
 682                                         break;
 683                                 case 2:
 684                                         sys_time = tmp_long;
 685                                         break;
 686                                 default:
 687                                         break;
 688                         }
 689                         i++;
 690                 }
 691                 if (i >= 3) {
 692                         break;
 693                 }
 694         }
 695
 696         fclose(fp);
 697         fp = NULL;
 698         if (old_usr == 0) {
 699                 ret = -EAGAIN;
 700                 SETTING_TRACE_ERROR("old_usr == 0");
 701                 goto out;
 702         }
 703
 704         elapsed_tick = (cur_tv.tv_sec - old_tv.tv_sec) * tick_per_sec +
 705                        ((cur_tv.tv_usec - old_tv.tv_usec) * tick_per_sec) / 1000000;
 706
 707         /* REMOVE BS */
 708         if (elapsed_tick != 0) {
 709                 *usr_pct =
 710                     ((float)(usr_time - old_usr) * 100 / elapsed_tick) /
 711                     cpu_num;
 712         } else {
 713                 *usr_pct = 0;
 714         }
 715         /* REMOVE BS */
 716         if (elapsed_tick != 0) {
 717                 *sys_pct =
 718                     ((float)(sys_time - old_sys) * 100 / elapsed_tick) /
 719                     cpu_num;
 720         } else {
 721                 *sys_pct = 0;
 722         }
 723
 724 out:
 725         old_usr = usr_time;
 726         /*old_nice = nice_time; */
 727         old_sys = sys_time;
 728         old_tv = cur_tv;
 729
 730         return ret;
 731 }
 732
 733 #if 0
 734 /**
 735  * @brief get device root status.
 736  *
 737  * @param szStr the buffer for store device root status
 738  * @param nSize buffer size
 739  */
 740 static void setting_about_main_get_status_string(char *str, int size)
 741 {
 742         SETTING_TRACE_BEGIN;
 743         setting_retm_if(str == NULL, "str parameter is NULL");
 744
 745         struct_cordon_status *cordon_status = NULL;
 746         cordon_status = (struct_cordon_status *)malloc(sizeof(struct_cordon_status));
 747         if (NULL == cordon_status) {
 748                 SETTING_TRACE_ERROR("Memory allocation failed");
 749                 return ;
 750         }
 751         memset(cordon_status, 0, sizeof(struct_cordon_status));
 752
 753         SETTING_TRACE("cordon_get_previous_root_status_before");
 754         int ret = cordon_get_previous_root_status(cordon_status);
 755         SETTING_TRACE("cordon_get_previous_root_status_end");
 756         if (0 == ret) {
 757                 if (cordon_status->is_device_rooted) {
 758                         snprintf(str, size, "%s", SETTING_ABOUT_STATUS_ROOT_STR);
 759                 } else {
 760                         snprintf(str, size, "%s", SETTING_ABOUT_STATUS_UNROOT_STR);
 761                 }
 762         } else {
 763                 SETTING_TRACE_ERROR("Failed to call cordon_get_previous_root_status() with error code %d", ret);
 764                 snprintf(str, size, "%s", "IDS_ST_HEADER_UNAVAILABLE");
 765         }
 766         free(cordon_status);
 767 }
 768 #endif
 769
 770 /**
 771  * @brief create button on naviframe tile part.
 772  *
 773  * @param parent the new created button's parent layout
 774  * @param text button text
 775  * @param func callback for button click
 776  * @param data application data for button click callback.
 777  *
 778  * @return new created button
 779  */
 780 static Evas_Object *setting_about_naviframe_btn_create(Evas_Object *parent, const char *text, Evas_Smart_Cb func, void *data)
 781 {
 782         Evas_Object *btn = elm_button_add(parent);
 783         if (!btn) {
 784                 return NULL;
 785         }
 786         elm_object_style_set(btn, "naviframe/title_text");
 787         elm_object_text_set(btn, text);
 788         evas_object_smart_callback_add(btn, "clicked", func, data);
 789         return btn;
 790 }
 791
 792 /**
 793  * @brief button done response callback.
 794  *
 795  * @param data application data
 796  * @param obj the button evas object
 797  * @param event_info event type
 798  */
 799 static void setting_about_naviframe_btn_done_cb(void *data, Evas_Object *obj, void *event_info)
 800 {
 801         SETTING_TRACE_BEGIN;
 802         setting_retm_if(data == NULL, "data is NULL");
 803         SettingAboutUG *ad = (SettingAboutUG *)data;
 804         if (ad->item_dev_name && ad->item_dev_name->eo_check) {
 805                 const char *entry_str = NULL;
 806                 char *entry_str_utf8 = NULL;
 807                 char *name_value = NULL;
 808
 809                 entry_str = elm_entry_entry_get(ad->item_dev_name->eo_check);
 810                 if (entry_str) {
 811                         entry_str_utf8 = elm_entry_markup_to_utf8(entry_str);
 812                 }
 813                 name_value = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
 814
 815                 if (!ad->empty_flag && safeStrCmp(name_value, entry_str_utf8) != 0) {
 816                         if (0 != vconf_set_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR, entry_str_utf8)) {
 817                                 SETTING_TRACE_ERROR("Set vconf[%s] failed", VCONFKEY_SETAPPL_DEVICE_NAME_STR);
 818                         }
 819                 }
 820                 if (EINA_TRUE == elm_object_focus_get(ad->item_dev_name->eo_check)) {
 821                         elm_object_focus_set(ad->item_dev_name->eo_check, EINA_FALSE);
 822                 }
 823                 FREE(entry_str_utf8);
 824         }
 825         elm_naviframe_item_pop(ad->navi_bar);
 826         SETTING_TRACE_END;
 827 }
 828
 829 /**
 830  * @brief button cancel response callback.
 831  *
 832  * @param data application data
 833  * @param obj the button evas object
 834  * @param event_info event type
 835  */
 836 static void setting_about_naviframe_btn_cancel_cb(void *data, Evas_Object *obj, void *event_info)
 837 {
 838         SETTING_TRACE_BEGIN;
 839         setting_retm_if(data == NULL, "data is NULL");
 840         SettingAboutUG *ad = (SettingAboutUG *)data;
 841         if (ad->item_dev_name && ad->item_dev_name->eo_check) {
 842                 char *name = NULL;
 843                 char *pa_sub_desc = NULL;
 844                 name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
 845                 if (name) {
 846                         pa_sub_desc = elm_entry_utf8_to_markup(name);
 847                 }
 848                 if (pa_sub_desc) {
 849                         elm_entry_entry_set(ad->item_dev_name->eo_check, pa_sub_desc);
 850                         G_FREE(ad->item_dev_name->sub_desc);/*release first */
 851                         ad->item_dev_name->sub_desc = (char *)g_strdup(pa_sub_desc);
 852                 }
 853                 FREE(pa_sub_desc);
 854
 855                 if (isSpaceStr(ad->item_dev_name->sub_desc)) {
 856                         ad->empty_flag = TRUE;
 857                 } else {
 858                         ad->empty_flag = FALSE;
 859                 }
 860
 861                 SETTING_TRACE("ad->item_dev_name->sub_desc:%s", ad->item_dev_name->sub_desc);
 862                 if (EINA_TRUE == elm_object_focus_get(ad->item_dev_name->eo_check)) {
 863                         elm_object_focus_set(ad->item_dev_name->eo_check, EINA_FALSE);
 864                 }
 865         }
 866         elm_naviframe_item_pop(ad->navi_bar);
 867         SETTING_TRACE_END;
 868 }
 869 static void __setting_about_main_popup_cb(void *data, Evas_Object *obj, void *event_info)
 870 {
 871         SETTING_TRACE_BEGIN;
 872         setting_retm_if(obj == NULL, "obj parameter is NULL");
 873         setting_retm_if(data == NULL, "Data parameter is NULL");
 874         SettingAboutUG *ad = (SettingAboutUG *) data;
 875
 876         switch (btn_type(obj)) {
 877                 case POPUP_RESPONSE_OK: {
 878                                 if (ad->popup_space) {
 879                                         ad->popup_showed_flag = FALSE;
 880                                         evas_object_del(ad->popup_space);
 881                                         ad->popup_space = NULL;
 882                                 }
 883                                 break;
 884                         }
 885                 default: {
 886                                 break;
 887                         }
 888         }
 889 }
 890
 891
 892 /**
 893  * @brief device name entry input handing
 894  *      - get the current entry text
 895  *      - check if the current input text is reached to max length
 896  *    and show messge to user
 897  *
 898  * @param data application data
 899  * @param obj the entry evas object
 900  */
 901 static void __setting_about_entry_changed_cb(void *data, Evas_Object *obj)
 902 {
 903         retm_if(!data || !obj, "Data parameter is NULL");
 904         /*return if entry is not focused too */
 905
 906         Setting_GenGroupItem_Data *list_item =
 907             (Setting_GenGroupItem_Data *) data;
 908         SettingAboutUG *ad = list_item->userdata;
 909         retm_if(ad == NULL, "Data parameter is NULL");
 910
 911         const char *entry_str = elm_entry_entry_get(obj);
 912         int entry_len = safeStrLen(entry_str);
 913         SETTING_TRACE("entry_str:[%s], lenght:%d", entry_str, entry_len);
 914
 915         SETTING_TRACE("maxLengthReachFlag:[%d], enterKeyPressFlag:%d", list_item->maxLengthReachFlag, list_item->enterKeyPressFlag);
 916
 917         /*fix PLM P131106-02776
 918         after keyboard popup cut the entry text, the entry text don't reach max length, so need to delete popup */
 919         if (ad->popup_showed_flag && ad->popup_space && !list_item->maxLengthReachFlag) {
 920                 evas_object_del(ad->popup_space);
 921                 ad->popup_space = NULL;
 922                 ad->popup_showed_flag = FALSE;
 923
 924         }
 925
 926         list_item->maxLengthReachFlag = FALSE;
 927         list_item->enterKeyPressFlag = FALSE;
 928         list_item->spaceKeyPressFlag = FALSE;
 929
 930         /*for genlist update */
 931         G_FREE(list_item->sub_desc);/*release first */
 932         list_item->sub_desc = (char *)g_strdup(entry_str);
 933
 934         if (isSpaceStr(entry_str)) {
 935                 if (!ad->empty_flag) ad->empty_flag = TRUE;
 936         } else {
 937                 if (ad->empty_flag) ad->empty_flag = FALSE;
 938         }
 939 }
 940
 941 /**
 942  * @brief device name entry changed callback.
 943  *
 944  * @param data application data
 945  * @param obj the entry evas object
 946  * @param event_info event type
 947  */
 948 static void
 949 __setting_about_entry_device_name_changed_cb(void *data, Evas_Object *obj,
 950                                              void *event_info)
 951 {
 952         /*SETTING_TRACE_BEGIN; */
 953         setting_retm_if(obj == NULL, "obj is NULL");
 954         setting_retm_if(data == NULL, "data is NULL");
 955         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 956         SettingAboutUG *ad = list_item->userdata;
 957         retm_if(ad == NULL, "Data parameter is NULL");
 958
 959         /* 1. entry is empty */
 960         /* 2. entry is not empty */
 961         if (list_item->item) {
 962                 if (elm_entry_is_empty(obj)) {
 963                         elm_object_item_signal_emit(list_item->item, "elm,state,eraser,hide", "");
 964                 } else {
 965                         Eina_Bool device_focus_status = elm_object_focus_get(ad->item_dev_name->eo_check);
 966                         if (device_focus_status) {
 967                                 /*SETTING_TRACE("name is NOT empty, but focus"); */
 968                                 elm_object_item_signal_emit(list_item->item, "elm,state,eraser,show", "");
 969                         }
 970                 }
 971                 elm_object_item_signal_emit(list_item->item, "elm,state,guidetext,hide", "");
 972         }
 973
 974         __setting_about_entry_changed_cb(data, obj);
 975         /*SETTING_TRACE_END; */
 976 }
 977
 978 /**
 979  * @brief device name entry focus callback.
 980  *
 981  * @param data application data
 982  * @param obj the entry evas object
 983  * @param event_info event type
 984  */
 985 static void __setting_about_entry_focused(void *data, Evas_Object *obj, void *event_info) /* Focused callback will show X marked button and hide guidetext. */
 986 {
 987         SETTING_TRACE_BEGIN;
 988         retm_if(!data || !obj, "Data parameter is NULL");
 989         Setting_GenGroupItem_Data *item_dev_name = data;
 990
 991
 992         /* accessibiliy */
 993         elm_entry_cursor_end_set(obj);
 994         const char *txt = elm_entry_entry_get(obj);
 995         if (!txt || 0 == strlen(txt)) {
 996                 txt = elm_object_part_text_get(obj, "elm.guide");
 997         }
 998
 999         /* Say entry focused */
1000         Eina_Stringshare *str = eina_stringshare_printf("%s, Edit Field, Keyboard opened", txt);
1001         elm_access_say((char *)str);
1002         eina_stringshare_del(str);
1003
1004         SettingAboutUG *ad = item_dev_name->userdata;
1005         retm_if(!ad, "ad parameter is NULL");
1006         Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(item_dev_name->eo_check);
1007         if (imf_context) {
1008                 ecore_imf_context_input_panel_show(imf_context);
1009         }
1010 }
1011
1012 /**
1013  * @brief device name entry unfocus callback.
1014  *
1015  * @param data application data
1016  * @param obj the entry evas object
1017  * @param event_info event type
1018  */
1019 static void __setting_about_entry_unfocus_cb(void *data, Evas_Object *obj, void *event_info)
1020 {
1021         SETTING_TRACE_BEGIN;
1022         retm_if(!data || !obj, "Data parameter is NULL");
1023
1024
1025         const char *entry_str = elm_entry_entry_get(obj);
1026         char *entry_str_utf8 = NULL;
1027         entry_str_utf8 = elm_entry_markup_to_utf8(entry_str);
1028         SETTING_TRACE("To store \"%s\" into vconf[%s]", entry_str_utf8, VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1029
1030         Setting_GenGroupItem_Data *item_dev_name = data;
1031         SettingAboutUG *ad = item_dev_name->userdata;
1032
1033
1034
1035         if (isSpaceStr(entry_str)) {
1036                 if (!ad->empty_flag) {
1037                         ad->empty_flag = TRUE;
1038                 }
1039         } else {
1040                 if (ad->empty_flag) {
1041                         ad->empty_flag = FALSE;
1042                 }
1043         }
1044
1045         setting_hide_input_pannel_cb(item_dev_name->eo_check);
1046
1047
1048
1049         FREE(entry_str_utf8);
1050         elm_entry_select_none(obj);
1051
1052         SETTING_TRACE_END;
1053
1054 }
1055
1056
1057 /**
1058  * @brief device name entry max length reached callback.
1059  *
1060  * @param data application data
1061  * @param obj the entry evas object
1062  * @param event_info event type
1063  */
1064 static void __setting_about_entry_max_len_reached(void *data, Evas_Object *obj, void *event_info)
1065 {
1066         SETTING_TRACE_BEGIN;
1067         retm_if(data == NULL, "Data parameter is NULL");
1068         retm_if(!elm_object_focus_get(obj), "Entry is not focused"); /*notify only when entry is being focused on. */
1069
1070         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
1071         list_item->maxLengthReachFlag = true;
1072
1073         SettingAboutUG *ad = list_item->userdata;
1074         if (list_item->maxLengthReachFlag && list_item->enterKeyPressFlag == FALSE) {
1075
1076                 if (!ad->popup_showed_flag && NULL == ad->popup_space) {
1077                         ad->popup_showed_flag = TRUE;/*workaroud to fix popup blink issue. */
1078                         char strMax[BUF_SIZE] = {0,};
1079                         snprintf(strMax, BUF_SIZE, _("IDS_ST_POP_THE_MAXIMUM_NUMBERS_OF_CHARACTERS_FOR_YOUR_DEVICE_NAME_HPD_HAS_BEEN_EXCEEDED"),
1080                                  MAX_DEVICE_NAME_LEN);
1081
1082                         ad->popup_space = setting_create_popup_with_btn(ad, ad->win_get, "IDS_ST_HEADER_ENTER_VALID_DEVICE_NAME_ABB",
1083                                                                         strMax, __setting_about_main_popup_cb, 0, 1, _("IDS_ST_BUTTON_OK_ABB"));
1084                 }
1085         }
1086 }
1087
1088 /**
1089  * @brief device name entry input panel state event call back
1090  *      - input panel state event:ECORE_IMF_INPUT_PANEL_STATE_EVENT
1091  *
1092  * @param data application data
1093  * @param obj the entry evas object
1094  * @param event_info event type
1095  */
1096 static void __setting_about_entry_input_panel_event_cb(void *data, Ecore_IMF_Context *ctx, int value)
1097 {
1098         SETTING_TRACE_BEGIN;
1099         retm_if(data == NULL, "Data parameter is NULL");
1100         retm_if(ctx == NULL, "obj parameter is NULL");
1101         SettingAboutUG *ad = (SettingAboutUG *)data;
1102
1103         if (value == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
1104                 SETTING_TRACE("value == ECORE_IMF_INPUT_PANEL_STATE_SHOW");
1105         } else if (value == ECORE_IMF_INPUT_PANEL_STATE_HIDE) {
1106                 SETTING_TRACE("value == ECORE_IMF_INPUT_PANEL_STATE_HIDE");
1107
1108                 if (ad->item_dev_name) {
1109
1110                         if (ad->empty_flag) {
1111                                 ad->idler_add_popup = ecore_idler_add(__setting_about_popup_show_delay, ad);
1112                         }
1113
1114                 }
1115                 /*if Setting is overlapped by other app,the entry will lost its focus,
1116                 the input pannel will be hided and any popup should be removed to fix blinking issue.*/
1117                 if (ad->pause_flag) {
1118                         ad->idler_remove_popup = ecore_idler_add(__setting_about_popup_remove_delay, ad);
1119                 }
1120                 elm_object_focus_set(ad->navi_bar, EINA_FALSE);
1121
1122         }
1123 }
1124
1125 /**
1126  * @brief aboutUG vconf changed callback
1127  *
1128  * @param key the changed vconf key node.
1129  * @param data application data
1130  * @param event_info event type
1131  */
1132 static void __setting_about_main_vconf_change_cb(keynode_t *key, void *data)
1133 {
1134         SETTING_TRACE_BEGIN;
1135         setting_retm_if(NULL == key, "key is NULL");
1136         setting_retm_if(NULL == data, "data is NULL");
1137         SettingAboutUG *ad = (SettingAboutUG *)data;
1138
1139         int status = vconf_keynode_get_int(key);
1140         char *vconf_name = vconf_keynode_get_name(key);
1141
1142         if (!safeStrCmp(vconf_name, VCONFKEY_WIFI_STATE)) {
1143                 SETTING_TRACE("status:%d", status);
1144                 char str[MAX_DISPLAY_STR_LEN_ON_PHONE_INFO] = {0,};
1145                 setting_about_main_get_wifi_mac_address_string(str, sizeof(str));
1146                 if (ad->item_data_wifi) {
1147                         G_FREE(ad->item_data_wifi->sub_desc);
1148                         ad->item_data_wifi->sub_desc = (char *)g_strdup(str);
1149                         elm_object_item_data_set(ad->item_data_wifi->item, ad->item_data_wifi);
1150                         elm_genlist_item_update(ad->item_data_wifi->item);
1151                 }
1152         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_DEVICE_NAME_STR)) {
1153                 char *name_value = NULL;
1154                 name_value = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1155                 if (NULL == name_value) {
1156                         /*use the defaule name if get vconf failed*/
1157                         name_value = (char *)g_strdup(DEVICE_NAME_DEFAULE);
1158                 }
1159                 SETTING_TRACE("name:%s", name_value);
1160                 if (ad->item_dev_name && ad->item_dev_name->eo_check) {
1161                         /*for genlist update */
1162                         if (safeStrCmp(ad->item_dev_name->sub_desc, name_value) != 0) {
1163                                 char *str_name = elm_entry_utf8_to_markup(name_value);
1164                                 elm_entry_entry_set(ad->item_dev_name->eo_check, str_name);
1165                                 elm_entry_cursor_end_set(ad->item_dev_name->eo_check);
1166                                 G_FREE(ad->item_dev_name->sub_desc);/*release first */
1167                                 ad->item_dev_name->sub_desc = (char *)g_strdup(str_name);
1168                                 FREE(str_name);
1169                         }
1170                 }
1171                 if (ad->item_dev_name_main && ad->item_dev_name_main->sub_desc) {
1172                         if (safeStrCmp(ad->item_dev_name_main->sub_desc, name_value) != 0) {
1173                                 char *str_name = elm_entry_utf8_to_markup(name_value);
1174                                 char *tmp = ad->item_dev_name_main->sub_desc;
1175                                 ad->item_dev_name_main->sub_desc = (char *)g_strdup(str_name);
1176                                 elm_genlist_item_fields_update(ad->item_dev_name_main->item, "*", ELM_GENLIST_ITEM_FIELD_TEXT);
1177                                 FREE(str_name);
1178                                 G_FREE(tmp);
1179
1180                         }
1181                 }
1182                 FREE(name_value);
1183         } else {
1184                 SETTING_TRACE_ERROR("vconf_name is error");
1185         }
1186 }
1187
1188 /**
1189  * @brief UG destroy callback
1190  *
1191  * @param ug the UG which is needed to be destoried
1192  * @param priv application data
1193  */
1194 static void __destroy_ug_cb(ui_gadget_h ug, void *priv)
1195 {
1196         SETTING_TRACE_BEGIN;
1197
1198         /* restore the '<-' button on the navigate bar */
1199         ret_if(!priv);
1200         SettingAboutUG *ad = (SettingAboutUG *) priv;   /* ad is point to priv */
1201
1202         if (ug) {
1203                 setting_ug_destroy(ug);
1204                 ad->ug_loading = NULL;
1205         }
1206         elm_object_tree_focus_allow_set(ad->ly_main, EINA_TRUE);
1207 }
1208
1209 /**
1210  * @brief Lunch cetificates UG(setting-manage-certificates-efl)
1211  *
1212  * @param data application data
1213  */
1214 static void __setting_about_main_certificates_clicked(void *data)
1215 {
1216         SETTING_TRACE_BEGIN;
1217         retm_if(data == NULL, "Data parameter is NULL");
1218         SettingAboutUG *ad = (SettingAboutUG *)data;
1219
1220         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1221         if (!cbs) {
1222                 return;
1223         }
1224
1225         cbs->layout_cb = setting_about_layout_ug_cb;
1226         cbs->result_cb = NULL;
1227         cbs->destroy_cb = __destroy_ug_cb;
1228         cbs->priv = (void *)ad;
1229
1230         elm_object_tree_focus_allow_set(ad->ly_main, EINA_FALSE);
1231         ad->ug_loading =
1232             setting_ug_create(ad->ug, "setting-manage-certificates-efl", UG_MODE_FULLVIEW, NULL, cbs);
1233
1234         if (NULL == ad->ug_loading) {   /* error handling */
1235                 SETTING_TRACE_ERROR("NULL == ad->ug_loading");
1236         }
1237         FREE(cbs);
1238 }
1239
1240 /**
1241  * @brief Lunch UG setting-phone-efl
1242  *
1243  * @param data application context
1244  */
1245 static void __setting_about_main_licence_launch(void *data)
1246 {
1247         SETTING_TRACE_BEGIN;
1248         retm_if(data == NULL, "Data parameter is NULL");
1249         SettingAboutUG *ad = (SettingAboutUG *)data;
1250
1251         app_control_h svc;
1252         if (app_control_create(&svc)) {
1253                 return;
1254         }
1255
1256         app_control_add_extra_data(svc, "viewtype", "license");
1257
1258         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1259         if (!cbs) {
1260                 app_control_destroy(svc);
1261                 return;
1262         }
1263
1264         cbs->layout_cb = setting_about_layout_ug_cb;
1265         cbs->result_cb = NULL;
1266         cbs->destroy_cb = __destroy_ug_cb;
1267         cbs->priv = (void *)ad;
1268
1269
1270         elm_object_tree_focus_allow_set(ad->ly_main, EINA_FALSE);
1271         ad->ug_loading =
1272             setting_ug_create(ad->ug, "setting-phone-efl", UG_MODE_FULLVIEW, svc, cbs);
1273
1274         if (NULL == ad->ug_loading) {   /* error handling */
1275                 SETTING_TRACE_ERROR("NULL == ad->ug_loading");
1276         }
1277         app_control_destroy(svc);
1278         FREE(cbs);
1279 }
1280
1281 /**
1282  * @brief expanlist sub-item selected callback
1283  *
1284  * @param data app context
1285  * @param obj evas object
1286  * @param event_info event type
1287  */
1288 static void __setting_about_sub_list_sel_cb(void *data, Evas_Object *obj, void *event_info)
1289 {
1290         SETTING_TRACE_BEGIN;
1291         /* error check */
1292         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
1293         Elm_Object_Item *subitem = (Elm_Object_Item *) event_info;
1294         Elm_Object_Item *parentItem = elm_genlist_item_parent_get(subitem);
1295         elm_genlist_item_selected_set(subitem, 0);
1296         Setting_GenGroupItem_Data *data_subItem = elm_object_item_data_get(subitem);
1297         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);  /* parent data */
1298         ret_if(NULL == data_subItem || NULL == data_parentItem);
1299
1300
1301         int err;
1302         setting_set_string_slp_key(data_parentItem->int_slp_setting_binded, data_subItem->keyStr, &err);
1303         setting_retm_if(0 != err, "Set vconf error[%d]", data_parentItem->int_slp_setting_binded);
1304
1305         data_parentItem->sub_desc = (char *)g_strdup(_(data_subItem->keyStr));
1306         elm_object_item_data_set(data_parentItem->item, data_parentItem);
1307         elm_genlist_item_update(data_parentItem->item);
1308         elm_radio_value_set(data_subItem->rgd, data_subItem->chk_status);
1309 }
1310
1311 /**
1312  * @brief expanlist sub-item radio checked callback
1313  *
1314  * @param data app context
1315  * @param obj evas object
1316  * @param event_info event type
1317  */
1318
1319 static void __setting_about_sub_list_rd_change(void *data, Evas_Object *obj, void *event_info)
1320 {
1321         SETTING_TRACE_BEGIN;
1322         retm_if(data == NULL, "Data parameter is NULL");
1323         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
1324
1325         Elm_Object_Item *subItem = list_item->item;
1326         Elm_Object_Item *parentItem = elm_genlist_item_parent_get(subItem);
1327
1328         Setting_GenGroupItem_Data *data_subItem = elm_object_item_data_get(subItem);     /* subItem data */
1329         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);  /* parent data */
1330         ret_if(NULL == data_subItem || NULL == data_parentItem);
1331
1332         int err;
1333         setting_set_string_slp_key(data_parentItem->int_slp_setting_binded, data_subItem->keyStr, &err);
1334
1335         ret_if(0 != err);
1336         data_parentItem->sub_desc = (char *)g_strdup(_(data_subItem->keyStr));
1337         elm_object_item_data_set(data_parentItem->item, data_parentItem);
1338         elm_genlist_item_update(data_parentItem->item);
1339         elm_radio_value_set(obj, data_subItem->chk_status);
1340 }
1341
1342 /**
1343  * @brief expanlist state changed callback
1344  *
1345  * @param data app context
1346  * @param obj evas object
1347  * @param event_info event type
1348  */
1349 void setting_about_main_exp_cb(void *data, Evas_Object *obj, void *event_info)
1350 {
1351         SETTING_TRACE_BEGIN;
1352         setting_retm_if(data == NULL, "Data parameter is NULL");
1353         setting_retm_if(event_info == NULL, "event_info parameter is NULL");
1354
1355         SettingAboutUG *ad = (SettingAboutUG *) data;
1356         Elm_Object_Item *parentItem = event_info;        /* parent item */
1357         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);
1358         Evas_Object *scroller = elm_object_item_widget_get(parentItem);
1359
1360         Evas_Object *rgd = elm_radio_add(scroller);
1361         elm_radio_value_set(rgd, -1);
1362
1363         int err;
1364         char sel_num[SETTING_SIM_MSISDN_DIALING_NUMBER_LEN] = { 0, };
1365         setting_retm_if(NULL == data_parentItem, "data_parentItem is NULL");
1366         setting_get_string_slp_key(data_parentItem->int_slp_setting_binded, sel_num, &err);
1367         SETTING_TRACE("binded: %d, checked: %s, err: %d", data_parentItem->int_slp_setting_binded, sel_num, err);
1368
1369         int i = 0;
1370         int sel_idx = -1;
1371         Setting_GenGroupItem_Data *item_data = NULL;
1372
1373         /*for(; i < SETTING_ABOUT_MY_NUMBERS_LEN; i++) { */
1374         for (; i < ad->my_numbers.count; i++) {
1375                 if (ad->my_numbers.list[i].num[0] == '\0') {
1376                         break;
1377                 }
1378
1379                 if (sel_idx == -1 && 0 == safeStrCmp(sel_num, ad->my_numbers.list[i].num)) {
1380                         sel_idx = i;
1381                 }
1382                 item_data = setting_create_Gendial_exp_sub_field(scroller,
1383                                                                  &(ad->itc_1icon_1text_sub),
1384                                                                  __setting_about_sub_list_sel_cb, ad, parentItem,
1385                                                                  SWALLOW_Type_1RADIO, rgd,
1386                                                                  i,
1387                                                                  ad->my_numbers.list[i].num, __setting_about_sub_list_rd_change);
1388                 if (item_data) {
1389                         item_data->userdata = ad;
1390                 } else {
1391                         SETTING_TRACE_ERROR("item_data is NULL");
1392                 }
1393         }
1394
1395         elm_radio_value_set(rgd, sel_idx);
1396 }
1397
1398 /**
1399 * @brief Do process when clicking '<-' button
1400 *
1401 * @param data application context
1402 * @param obj evas object
1403 * @param event_info event type
1404 */
1405 static Eina_Bool
1406 setting_about_main_click_softkey_back_cb(void *data, Evas_Object *obj,
1407                                          void *event_info)
1408 {
1409         SETTING_TRACE_BEGIN;
1410         setting_retvm_if(data == NULL, EINA_FALSE, "Data parameter is NULL");
1411         SettingAboutUG *ad = (SettingAboutUG *) data;
1412         if (ad->empty_flag) {
1413 #if 0
1414                 if (ad->popup) {
1415                         evas_object_del(ad->popup);
1416                         ad->popup = NULL;
1417                 }
1418                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _(EMPTY_LIMITATION_STR),
1419                                                              __setting_about_popup_rsp_cb, POPUP_INTERVAL, FALSE, FALSE);
1420                 if (ad->item_dev_name) {
1421                         elm_object_focus_set(ad->item_dev_name->eo_check, EINA_TRUE);
1422                 }
1423 #endif
1424                 return EINA_FALSE;
1425         }
1426
1427         /*imf must be hided before view is destroyed. */
1428         /*Following code is just to improve the hiding speed. If not add these code, */
1429         /*the input pannel will also be hided with the view destroyed,but it works too slow. */
1430         if (ad->item_dev_name) {
1431                 elm_object_focus_set(ad->item_dev_name->eo_check, EINA_FALSE);
1432                 setting_hide_input_pannel_cb(ad->item_dev_name->eo_check);
1433         }
1434
1435         /* Send destroy request */
1436         ug_destroy_me(ad->ug);
1437
1438         return EINA_FALSE;
1439 }
1440
1441 static Eina_Bool __setting_about_child_view_back_cb(void *data, Elm_Object_Item *it)
1442 {
1443         SETTING_TRACE_BEGIN;
1444         /* error check */
1445         retvm_if(data == NULL, EINA_TRUE, "Data parameter is NULL");
1446
1447         SettingAboutUG *ad =  data;
1448         if (ad->empty_flag) {
1449 #if 0
1450                 if (ad->popup) {
1451                         evas_object_del(ad->popup);
1452                         ad->popup = NULL;
1453                 }
1454                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _(EMPTY_LIMITATION_STR),
1455                                                              __setting_about_popup_rsp_cb, POPUP_INTERVAL, FALSE, FALSE);
1456                 if (ad->item_dev_name) {
1457                         elm_object_focus_set(ad->item_dev_name->eo_check, EINA_TRUE);
1458                 }
1459 #endif
1460                 return EINA_FALSE;
1461         } else {
1462                 if (ad->event_handler) {
1463                         ecore_event_handler_del(ad->event_handler);
1464                         ad->event_handler = NULL;
1465                 }
1466                 if (ad->name_update_idler) {
1467                         ecore_idler_del(ad->name_update_idler);
1468                         ad->name_update_idler = NULL;
1469                 }
1470                 return EINA_TRUE;
1471         }
1472 }
1473
1474 static Eina_Bool __setting_about_name_view_key_down(void *data, int type, void *event)
1475 {
1476         SETTING_TRACE_BEGIN;
1477         Evas_Event_Key_Down *ev = event;
1478
1479         if (!ev || !data) {
1480                 return ECORE_CALLBACK_RENEW;
1481         }
1482
1483 #if 0
1484         SettingAboutUG *ad = data;
1485         if (!strcmp(ev->keyname, KEY_BACK)) {
1486                 setting_about_naviframe_btn_cancel_cb(ad, NULL, NULL);
1487         }
1488         return ECORE_CALLBACK_RENEW;
1489 #endif
1490 }
1491 static Eina_Bool setting_about_name_focus_update_cb(const void *data)
1492 {
1493         SETTING_TRACE_BEGIN;
1494         /* error check */
1495         setting_retvm_if(data == NULL, ECORE_CALLBACK_RENEW, "Data parameter is NULL");
1496         SettingAboutUG *ad = data;
1497         if (ad->item_dev_name && ad->item_dev_name->eo_check) {
1498                 evas_object_show(ad->item_dev_name->eo_check);
1499                 elm_object_focus_set(ad->item_dev_name->eo_check, EINA_TRUE);
1500
1501                 ad->name_update_idler = NULL;
1502                 return ECORE_CALLBACK_CANCEL;
1503         } else {
1504                 return ECORE_CALLBACK_RENEW;
1505         }
1506
1507 }
1508
1509
1510 /**
1511  * Setting > About > Device name > (new view) here
1512  */
1513 static void __setting_about_main_creat_name_view(data)
1514 {
1515         SETTING_TRACE_BEGIN;
1516         /* error check */
1517         setting_retm_if(data == NULL, "Data parameter is NULL");
1518         SettingAboutUG *ad =    data;
1519
1520         Evas_Object *scroller = NULL;
1521         scroller = elm_genlist_add(ad->navi_bar);
1522         setting_retm_if(scroller == NULL, "Cannot set scroller object  as contento of layout");
1523         //elm_genlist_realization_mode_set(scroller, EINA_TRUE);
1524         /*elm_object_style_set(scroller, "dialogue"); */
1525         elm_genlist_clear(scroller);    /* first to clear list */
1526         elm_genlist_mode_set(scroller, ELM_LIST_COMPRESS);
1527         evas_object_smart_callback_add(scroller, "realized", __gl_realized_cb, NULL);
1528
1529         /* Device name */
1530         char *name_value = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1531         char *pa_sub_desc = elm_entry_utf8_to_markup(name_value);
1532         FREE(name_value);
1533
1534         ad->empty_flag = FALSE;
1535         if (NULL == pa_sub_desc || '\0' == pa_sub_desc[0]) {
1536                 ad->empty_flag = TRUE;
1537         }
1538
1539         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *)calloc(1, sizeof(Setting_GenGroupItem_Data));
1540         if (!item_data) {
1541                 FREE(pa_sub_desc);
1542         }
1543         setting_retvm_if(!item_data, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER, "calloc failed");
1544
1545         item_data->keyStr = (char *)g_strdup(SETTING_ABOUT_DEVICE_NAME_STR);
1546         item_data->sub_desc = (char *)g_strdup(pa_sub_desc);
1547         item_data->swallow_type = SWALLOW_Type_LAYOUT_EDITFIELD;
1548         item_data->chk_status = 0;
1549         item_data->chk_change_cb = __setting_about_entry_device_name_changed_cb;
1550         item_data->userdata = ad;
1551         item_data->isSinglelineFlag = FALSE;
1552         item_data->stop_change_cb = __setting_about_entry_unfocus_cb;
1553         item_data->maxlength_reached_cb = __setting_about_entry_max_len_reached;
1554         item_data->focus_cb = __setting_about_entry_focused;
1555         item_data->x_callback_cb = __setting_about_entry_input_panel_event_cb;
1556         item_data->guide_text = (char *)g_strdup(EMPTY_LIMITATION_STR);
1557         item_data->isGroupStyleTOP = TRUE;
1558         item_data->focus_unallowed = get_tethering_status();
1559         /*item_data->entry_auto_focus = TRUE; */
1560
1561         item_data->limit_filter_data = calloc(1, sizeof(Elm_Entry_Filter_Limit_Size));
1562         if (item_data->limit_filter_data) {
1563                 /*max byte len is 32 -> MAX_DEVICE_NAME_LEN */
1564                 item_data->limit_filter_data->max_byte_count = MAX_DEVICE_NAME_LEN;
1565                 item_data->win_main = ad->win_get;
1566         } else {
1567                 SETTING_TRACE_ERROR("fail to calloc");
1568         }
1569
1570         item_data->digits_filter_data = calloc(1, sizeof(Elm_Entry_Filter_Accept_Set));
1571         if (item_data->digits_filter_data) {
1572                 item_data->digits_filter_data->accepted = NULL;
1573         } else {
1574                 SETTING_TRACE_ERROR("fail to calloc");
1575         }
1576
1577         item_data->input_panel_disable_flag = EINA_TRUE;
1578
1579         /* add genlist item here for the device name */
1580         item_data->item = elm_genlist_item_append(scroller, &(itc_editfield), item_data, NULL, ELM_GENLIST_ITEM_NONE,
1581                                                   NULL, ad);
1582
1583         ad->item_dev_name = item_data;
1584         if (ad->item_dev_name) {
1585                 __BACK_POINTER_SET(ad->item_dev_name);
1586                 elm_genlist_item_select_mode_set(ad->item_dev_name->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1587                 /*ad->item_dev_name->group_style = SETTING_GROUP_STYLE_TOP; */
1588                 /*setting_genlist_item_groupstyle_set(ad->item_dev_name, SETTING_GROUP_STYLE_TOP); */
1589         } else {
1590                 SETTING_TRACE_ERROR("ad->item_dev_name is NULL");
1591         }
1592
1593         FREE(pa_sub_desc);
1594
1595         Elm_Object_Item *navi_it = setting_push_layout_navi_bar(_(DEVICE_NAME),
1596                                                                 NULL, NULL, NULL,
1597                                                                 NULL, NULL, NULL,
1598                                                                 ad, scroller, ad->navi_bar, NULL);
1599         elm_naviframe_item_pop_cb_set(navi_it, __setting_about_child_view_back_cb, ad);
1600
1601         Evas_Object *btn;
1602         /* Title Cancel Button */
1603         btn = elm_button_add(ad->navi_bar);
1604         elm_object_style_set(btn, "naviframe/title_cancel");
1605         evas_object_smart_callback_add(btn, "clicked", setting_about_naviframe_btn_cancel_cb, ad);
1606         elm_object_item_part_content_set(navi_it, "title_left_btn", btn);
1607
1608         /* Title Done Button */
1609         btn = elm_button_add(ad->navi_bar);
1610         elm_object_style_set(btn, "naviframe/title_done");
1611         evas_object_smart_callback_add(btn, "clicked", setting_about_naviframe_btn_done_cb, ad);
1612         elm_object_item_part_content_set(navi_it, "title_right_btn", btn);
1613
1614         ad->event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, __setting_about_name_view_key_down, ad);
1615         ad->name_update_idler = ecore_idler_add(setting_about_name_focus_update_cb, ad);
1616 }
1617
1618 /**
1619  * @brief Do process when clicking on some genlist item
1620  *
1621  * @param data application context
1622  * @param obj evas object
1623  * @param event_info event type
1624  */
1625 static void
1626 setting_about_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
1627                                             void *event_info)
1628 {
1629         SETTING_TRACE_BEGIN;
1630         /* error check */
1631         setting_retm_if(data == NULL, "Data parameter is NULL");
1632
1633         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
1634         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1635         elm_genlist_item_selected_set(item, 0);
1636         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
1637         retm_if(list_item == NULL, "return of elm_object_item_data_get is NULL");
1638
1639         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
1640         if (!safeStrCmp("IDS_ST_HEADER_MANAGE_CERTIFICATES_ABB", list_item->keyStr)) {
1641                 __setting_about_main_certificates_clicked(data);
1642         } else if (!safeStrCmp(KeyStr_Regulatory_Info, list_item->keyStr)) {
1643                 __setting_about_popup_regulatory_info(data);
1644         } else if (!safeStrCmp("IDS_ST_MBODY_LEGAL_INFORMATION_ABB", list_item->keyStr)) {
1645                 __setting_about_main_licence_launch(data);
1646         } else if (!safeStrCmp("IDS_ST_MBODY_SOFTWARE_UPDATE", list_item->keyStr)) {
1647 #ifdef SUPPORT_FOTA
1648                 SettingAboutUG *ad = (SettingAboutUG *)list_item->userdata;
1649                 Evas_Object *back_btn = elm_object_item_part_content_get(ad->navi_item, "prev_btn");
1650                 if (back_btn) {
1651                         SETTING_TRACE_DEBUG("Change focus to back_btn");
1652                         elm_object_focus_set(back_btn, EINA_TRUE);
1653                 }
1654
1655                 app_launcher("org.tizen.oma-dm");
1656 #endif
1657         } else if (!safeStrCmp(SETTING_ABOUT_DEVICE_NAME_STR, list_item->keyStr)) {
1658                 __setting_about_main_creat_name_view(data);
1659         }
1660 }
1661
1662
1663
1664 /**
1665  * @brief callback function for genlist event "drag"
1666  *
1667  * @param data application context
1668  * @param obj evas object
1669  * @param event_info event type
1670  */
1671 static void setting_about_main_gl_drag(void *data, Evas_Object *obj, void *event)
1672 {
1673         ret_if(!data);
1674         retm_if(event == NULL, "Invalid argument: event info is NULL");
1675         SettingAboutUG *ad = (SettingAboutUG *) data;
1676         ad->drag_flag = TRUE;
1677 }
1678
1679
1680 /**
1681  * @brief callback function for EVAS_CALLBACK_MOUSE_UP
1682  *
1683  * @param data application context
1684  * @param e evas
1685  * @param obj evas object
1686  * @param event_info event type
1687  */
1688 static void
1689 setting_about_main_gl_mouse_up(void *data, Evas *e, Evas_Object *obj, void *event)
1690 {
1691         /*SETTING_TRACE_BEGIN; */
1692         ret_if(!data);
1693         SettingAboutUG *ad = (SettingAboutUG *) data;
1694         retm_if(event == NULL, "Invalid argument: event info is NULL");
1695         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event;
1696
1697         if (ad->drag_flag) {
1698                 ad->drag_flag = FALSE;
1699                 return;
1700         }
1701
1702         if (ad->item_dev_name) {
1703                 Elm_Object_Item *selected_item = elm_genlist_at_xy_item_get(ad->genlsit, ev->output.x, ev->output.y, NULL);
1704                 if (ad->item_dev_name->item == selected_item) {
1705                         if (elm_object_focus_get(ad->item_dev_name->eo_check)) {
1706                                 Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(ad->item_dev_name->eo_check);
1707                                 if (imf_context) {
1708                                         ecore_imf_context_input_panel_show(imf_context);
1709                                 }
1710                                 return;
1711                         }
1712
1713                         if (get_tethering_status()) {
1714                                 if (ad->popup) {
1715                                         evas_object_del(ad->popup);
1716                                         ad->popup = NULL;
1717                                 }
1718
1719                                 ad->popup = setting_create_popup_with_btn(ad, ad->win_get,
1720                                                                           NULL, _(SETTING_ABOUT_MOBILE_AP_TURNED_OFF),
1721                                                                           __setting_about_popup_mobile_ap_turn_off_ask_resp_cb, 0,
1722                                                                           2, _("IDS_ST_BODY_TURN_OFF"), _("IDS_ST_BUTTON_CANCEL_ABB2"));
1723                         } else {
1724                                 elm_object_focus_set(ad->item_dev_name->eo_check, EINA_TRUE);
1725                                 elm_entry_cursor_end_set(ad->item_dev_name->eo_check);
1726
1727                                 Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(ad->item_dev_name->eo_check);
1728                                 if (imf_context) {
1729                                         ecore_imf_context_input_panel_show(imf_context);
1730                                 }
1731                         }
1732                 } else {
1733                         elm_object_focus_set(ad->item_dev_name->eo_check, EINA_FALSE);/*to make inputing words input */
1734                 }
1735         }
1736         /*SETTING_TRACE_END; */
1737 }
1738
1739
1740 /**
1741  * @brief callback run for timer task to update CPU, Battery info
1742  *
1743  * @param data application context
1744  *
1745  * @return FALSE for call it once and then destory the timer, TRUE for always call it when the timer is reached.
1746  */
1747 static Eina_Bool setting_about_main_timer_update_cb(const void *data)
1748 {
1749         retv_if(data == NULL, TRUE);
1750         SettingAboutUG *ad = (SettingAboutUG *) data;
1751
1752         char str[MAX_DISPLAY_STR_LEN_ON_PHONE_INFO] = { 0, };
1753         if (ad->item_data_cpu) {
1754                 float usr, sys;
1755                 int ret = setting_about_main_stat_get_cpuinfo(&usr, &sys);
1756                 if (ret == -ENOENT) {
1757                         SETTING_TRACE_ERROR("call __stat_get_cpuinfo fail");
1758                         snprintf(str, sizeof(str), "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
1759                 } else {
1760                         snprintf(str, sizeof(str), "%.0f%s", usr + sys, "\%");
1761                 }
1762
1763                 ad->item_data_cpu->sub_desc = (char *)g_strdup(str);
1764                 elm_object_item_data_set(ad->item_data_cpu->item, ad->item_data_cpu);
1765                 elm_genlist_item_update(ad->item_data_cpu->item);
1766         }
1767
1768         if (ad->item_data_battery) {
1769                 setting_about_main_get_battery_string(str, sizeof(str));
1770                 /*SETTING_TRACE("str:%s", str);*/
1771                 ad->item_data_battery->sub_desc = (char *)g_strdup(str);
1772
1773                 elm_object_item_data_set(ad->item_data_battery->item, ad->item_data_battery);
1774                 elm_genlist_item_update(ad->item_data_battery->item);
1775         }
1776         if (ad->need_update) {
1777                 if (ad->item_data_my_phone_number) {
1778                         G_FREE(ad->item_data_my_phone_number->sub_desc);
1779                         ad->item_data_my_phone_number->sub_desc = (char *)g_strdup(SETTING_ABOUT_PUK_LOCKED);
1780                         elm_object_item_data_set(ad->item_data_my_phone_number->item, ad->item_data_my_phone_number);
1781                         elm_genlist_item_update(ad->item_data_my_phone_number->item);
1782                         ad->need_update = FALSE;
1783                 }
1784         }
1785         return TRUE;
1786 }
1787
1788 /**
1789  * @brief create main view genlist items
1790  *
1791  * @param data application data
1792  *
1793  * @return FALSE for call it once and then destory the timer, TRUE for always call it when the timer is reached.
1794  */
1795 int setting_about_main_generate_genlist(void *data)
1796 {
1797         SETTING_TRACE_BEGIN;
1798         /* error check */
1799         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1800
1801         SettingAboutUG *ad = (SettingAboutUG *) data;
1802         bool is_emul_bin = isEmulBin();
1803
1804         Evas_Object *scroller = ad->genlsit;
1805         Elm_Object_Item *item = NULL;
1806         Setting_GenGroupItem_Data *item_data = NULL;
1807         char str[MAX_DISPLAY_STR_LEN_ON_PHONE_INFO] = { 0, };
1808         telephony_handle_list_s tapi_handle_list;
1809         int i = 0;
1810         int tapi_handle_count = 0;
1811         int ret_value = 0;
1812         int ret_get_app_info = 0;
1813         app_info_h app_info = NULL;
1814         ret_get_app_info = app_info_create("org.tizen.oma-dm", &app_info);
1815
1816         /* [UI] Software update */
1817         if (ret_get_app_info != APP_MANAGER_ERROR_NONE) {
1818                 SETTING_TRACE("No corresponding app_id for [%s]\n", "org.tizen.oma-dm");
1819         } else {
1820                 if (!is_emul_bin) {
1821                         item_data = setting_create_Gendial_field_def(scroller, &(ad->itc_1text),
1822                                         setting_about_main_mouse_up_Gendial_list_cb,
1823                                         ad, SWALLOW_Type_INVALID, NULL, NULL,
1824                                         0, "IDS_ST_MBODY_SOFTWARE_UPDATE",
1825                                         NULL, NULL);
1826                         if (item_data) {
1827                                 item_data->userdata = ad;
1828                                 setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_TOP);
1829                         } else {
1830                                 SETTING_TRACE_ERROR("item_data is NULL");
1831                         }
1832                 }
1833         }
1834
1835         /* [UI] Certificates */
1836         /* implementation is in progress. */
1837         item_data = setting_create_Gendial_field_def(scroller, &(ad->itc_1text),
1838                         setting_about_main_mouse_up_Gendial_list_cb,
1839                         ad, SWALLOW_Type_INVALID, NULL, NULL,
1840                         0, "IDS_ST_HEADER_MANAGE_CERTIFICATES_ABB", NULL, NULL);
1841         if (item_data) {
1842                 setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_BOTTOM);
1843         } else {
1844                 SETTING_TRACE_ERROR("item_data is NULL");
1845         }
1846
1847         item = elm_genlist_item_append(scroller, &itc_seperator, NULL, NULL,
1848                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1849         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1850
1851         /* [UI] Licence */
1852         setting_create_Gendial_field_def(scroller, &(ad->itc_1text),
1853                         setting_about_main_mouse_up_Gendial_list_cb,
1854                         ad, SWALLOW_Type_INVALID, NULL, NULL,
1855                         0, "IDS_ST_MBODY_LEGAL_INFORMATION_ABB", NULL, NULL);
1856
1857         /*//////////////////////////////////////////////////////////////////// */
1858         /* [UI] separator */
1859         elm_genlist_item_select_mode_set(elm_genlist_item_append(scroller, &itc_seperator, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL),
1860                         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1861         (void)setting_create_Gendial_field_titleItem(scroller,
1862                         &(ad->itc_group_item),
1863                         "IDS_ST_BODY_DEVICE_INFORMATION", NULL);
1864         /*//////////////////////////////////////////////////////////////////// */
1865
1866         /* 1. Name */
1867         /* Device name */
1868         char *name_value = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1869         char *pa_sub_desc = elm_entry_utf8_to_markup(name_value);
1870         FREE(name_value);
1871
1872         ad->empty_flag = FALSE;
1873         if (NULL == pa_sub_desc || '\0' == pa_sub_desc[0]) {
1874                 ad->empty_flag = TRUE;
1875         }
1876         /* [UI] Name */
1877         ad->item_dev_name_main = item_data =
1878                 setting_create_Gendial_field_def(scroller, &(itc_2text_2), setting_about_main_mouse_up_Gendial_list_cb,
1879                                 ad, SWALLOW_Type_INVALID, NULL,
1880                                 NULL, 0, SETTING_ABOUT_DEVICE_NAME_STR, pa_sub_desc, NULL);
1881         if (item_data) {
1882                 setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_TOP);
1883                 __BACK_POINTER_SET(ad->item_dev_name_main);
1884         } else {
1885                 SETTING_TRACE_ERROR("item_data is NULL");
1886         }
1887         FREE(pa_sub_desc);
1888
1889
1890         /* 2. Phone number */
1891         /* Initialize telephony handle */
1892         int telephony_init_ret = telephony_init(&tapi_handle_list);
1893         if (telephony_init_ret != TELEPHONY_ERROR_NONE) {
1894                 tapi_handle_count = 0;
1895         } else {
1896                 tapi_handle_count = tapi_handle_list.count;
1897         }
1898         SETTING_TRACE_DEBUG("tapi_handle_list.count:%d", tapi_handle_list.count);
1899         /* my numbers(SIM1 and SIM2) */
1900         for (i = 0; i < tapi_handle_count; i++) {
1901                 memset(str, 0x00, sizeof(str));
1902                 char *my_number = NULL;
1903                 ret_value = telephony_sim_get_subscriber_number(tapi_handle_list.handle[i], &my_number);
1904                 if (ret_value != TELEPHONY_ERROR_NONE) {
1905                         SETTING_TRACE_ERROR("telephony_sim_get_subscriber_number() failed!!! [%d]", ret_value);
1906                         my_number = (char *)g_strdup("IDS_ST_HEADER_UNAVAILABLE");
1907                 } else if (isEmptyStr(my_number)) {
1908                         SETTING_TRACE_DEBUG("telephony_sim_get_subscriber_number() success, BUT return empty my number");
1909                         my_number = (char *)g_strdup("IDS_ST_HEADER_UNAVAILABLE");
1910                 }
1911                 /* [UI] Phone number */
1912                 item_data =
1913                         setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
1914                                         NULL, SWALLOW_Type_INVALID, NULL,
1915                                         NULL, 0, "IDS_ST_BODY_PHONE_NUMBER", my_number, NULL);
1916                 if (item_data) {
1917                         elm_object_item_disabled_set(item_data->item, EINA_TRUE);
1918                         elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1919                         setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_CENTER);
1920                 } else {
1921                         SETTING_TRACE_ERROR("item_data is NULL");
1922                 }
1923                 FREE(my_number);
1924
1925         }
1926
1927         /* 3. [UI] Model number */
1928         memset(str, 0x00, sizeof(str));
1929         setting_about_main_get_phone_model_name(str, sizeof(str));
1930         item_data =
1931                 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
1932                                 NULL, SWALLOW_Type_INVALID, NULL,
1933                                 NULL, 0, "IDS_ST_BODY_MODEL_NUMBER", str, NULL);
1934         if (item_data) {
1935                 elm_object_item_disabled_set(item_data->item, EINA_TRUE);
1936                 elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1937                 setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_CENTER);
1938         } else {
1939                 SETTING_TRACE_ERROR("item_data is NULL");
1940         }
1941         ad->item_model = item_data;
1942
1943         /* 4. [UI] Tizen version */
1944         memset(str, 0x00, sizeof(str));
1945         setting_about_main_get_sw_version(str, sizeof(str));
1946         item_data =
1947                 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
1948                                 NULL, SWALLOW_Type_INVALID, NULL,
1949                                 NULL, 0, "IDS_ST_MBODY_TIZEN_VERSION", str, NULL);
1950         if (item_data) {
1951                 elm_object_item_disabled_set(item_data->item, EINA_TRUE);
1952                 elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1953                 setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_CENTER);
1954         } else {
1955                 SETTING_TRACE_ERROR("item_data is NULL");
1956         }
1957         ad->item_version = item_data;
1958
1959         /* 5. IMEI(IMEI 1 andd IMEI 2) */
1960         for (i = 0; i < tapi_handle_count; i++) {
1961                 memset(str, 0x00, sizeof(str));
1962                 /*setting_about_main_get_imei(str, sizeof(str),tapi_handle_list.handle[i]); */
1963                 char *imei = NULL;
1964                 ret_value = telephony_modem_get_imei(tapi_handle_list.handle[i], &imei);
1965                 if (ret_value != TELEPHONY_ERROR_NONE) {
1966                         SETTING_TRACE_ERROR("telephony_modem_get_imei() failed!!! [%d]", ret_value);
1967                         imei = (char *)g_strdup("IDS_ST_HEADER_UNAVAILABLE");
1968                 }
1969                 /* [UI] IMEI */
1970                 item_data =
1971                         setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
1972                                         NULL, SWALLOW_Type_INVALID, NULL,
1973                                         NULL, 0, SETTING_ABOUT_IMEI_STR, imei, NULL);
1974                 if (item_data) {
1975                         elm_object_item_disabled_set(item_data->item, EINA_TRUE);
1976                         elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1977                         setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_CENTER);
1978                 } else {
1979                         SETTING_TRACE_ERROR("item_data is NULL");
1980                 }
1981                 FREE(imei);
1982
1983         }
1984         ret_value = telephony_deinit(&tapi_handle_list);
1985         if (ret_value != TELEPHONY_ERROR_NONE) {
1986                 SETTING_TRACE_ERROR("Deinitialize failed!!!");
1987         }
1988         /*ad->item_data_imei = item_data; */
1989
1990         /* 6. [UI] Bluetooth address */
1991         if (!is_emul_bin) {  /* requested by DI Kim due to BT BS on 11/26 */
1992                 memset(str, 0x00, sizeof(str));
1993                 setting_about_main_get_bluetooth_address_string(str, sizeof(str));
1994                 ad->item_data_bt =
1995                         setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
1996                                         NULL, SWALLOW_Type_INVALID, NULL,
1997                                         NULL, 0, "IDS_ST_MBODY_BLUETOOTH_ADDRESS", str, NULL); /*ad->itc_2text_2 */
1998                 if (ad->item_data_bt) {
1999                         elm_object_item_disabled_set(ad->item_data_bt->item, EINA_TRUE);
2000                         elm_genlist_item_select_mode_set(ad->item_data_bt->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2001                         setting_genlist_item_groupstyle_set(ad->item_data_bt, SETTING_GROUP_STYLE_CENTER);
2002                         __BACK_POINTER_SET(ad->item_data_bt);
2003                 } else {
2004                         SETTING_TRACE_ERROR("item_data is NULL");
2005                 }
2006         }
2007
2008         /* 7. [UI] Wi-Fi MAC address */
2009         memset(str, 0x00, sizeof(str));
2010         setting_about_main_get_wifi_mac_address_string(str, sizeof(str));
2011
2012         SETTING_TRACE_DEBUG("[about main] get_wifi_mac_address : %s", str);
2013
2014         ad->item_data_wifi =
2015                 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
2016                                 NULL, SWALLOW_Type_INVALID, NULL,
2017                                 NULL, 0, "IDS_ST_BODY_WI_FI_MAC_ADDRESS", str, NULL);
2018         if (ad->item_data_wifi) {
2019                 elm_object_item_disabled_set(ad->item_data_wifi->item, EINA_TRUE);
2020                 elm_genlist_item_select_mode_set(ad->item_data_wifi->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2021                 setting_genlist_item_groupstyle_set(ad->item_data_wifi, SETTING_GROUP_STYLE_CENTER);
2022                 __BACK_POINTER_SET(ad->item_data_wifi);
2023         } else {
2024                 SETTING_TRACE_ERROR("item_data is NULL");
2025         }
2026
2027         /* 8. [UI] Serial number */
2028         memset(str, 0x00, sizeof(str));
2029         setting_about_main_get_sn(str, sizeof(str));
2030         item_data =
2031                 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
2032                                 NULL, SWALLOW_Type_INVALID, NULL,
2033                                 NULL, 0, SETTING_ABOUT_SN_STR, str, NULL);
2034         if (item_data) {
2035                 elm_object_item_disabled_set(item_data->item, EINA_TRUE);
2036                 elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2037                 setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_CENTER);
2038         } else {
2039                 SETTING_TRACE_ERROR("item_data is NULL");
2040         }
2041         ad->item_data_sn = item_data;
2042
2043         /* 9. [UI] Battery power */
2044         memset(str, 0x00, sizeof(str));
2045         setting_about_main_get_battery_string(str, sizeof(str));
2046         item_data =
2047                 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
2048                                 NULL, SWALLOW_Type_INVALID, NULL,
2049                                 NULL, 0, "IDS_ST_BUTTON_BATTERY_POWER_ABB", str, NULL);
2050         if (item_data) {
2051                 elm_object_item_disabled_set(item_data->item, EINA_TRUE);
2052                 elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2053                 ad->item_data_battery = item_data;
2054                 setting_genlist_item_groupstyle_set(ad->item_data_battery, SETTING_GROUP_STYLE_CENTER);
2055                 __BACK_POINTER_SET(ad->item_data_battery);
2056         } else {
2057                 SETTING_TRACE_ERROR("item_data is NULL");
2058         }
2059
2060         /* 10. [UI] CPU usage */
2061         memset(str, 0x00, sizeof(str));
2062         float usr, sys;
2063         int ret = setting_about_main_stat_get_cpuinfo(&usr, &sys);
2064         if (ret == -ENOENT) {
2065                 SETTING_TRACE_ERROR("call __stat_get_cpuinfo fail");
2066                 snprintf(str, sizeof(str), "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
2067         } else {
2068                 snprintf(str, sizeof(str), "%.0f%s", usr + sys, "\%");
2069         }
2070         ad->item_data_cpu = item_data =
2071                 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
2072                                 NULL, SWALLOW_Type_INVALID, NULL,
2073                                 NULL, 0, SETTING_ABOUT_CPU_USAGE_STR, str, NULL);
2074         if (ad->item_data_cpu) {
2075                 elm_object_item_disabled_set(ad->item_data_cpu->item, EINA_TRUE);
2076                 elm_genlist_item_select_mode_set(ad->item_data_cpu->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2077                 setting_genlist_item_groupstyle_set(ad->item_data_cpu, SETTING_GROUP_STYLE_BOTTOM);
2078                 __BACK_POINTER_SET(ad->item_data_cpu);
2079         } else {
2080                 SETTING_TRACE_ERROR("item_data is NULL");
2081         }
2082
2083
2084         /* 12. Security status */
2085 #if 0
2086         app_info_h app_info2 = NULL;
2087         ret_get_app_info = app_info_create("org.tizen.smack-update-service", &app_info2);
2088         if (ret_get_app_info == APP_MANAGER_ERROR_NONE) {
2089                 char *security_status = NULL;
2090                 security_status = vconf_get_str(VCONFKEY_SECURITY_SPD_INSTALLED_POLICY_VERSION);
2091                 if (!security_status) {
2092                         SETTING_TRACE_ERROR("Failed to register into SPD server");
2093                         security_status = (char *)g_strdup("IDS_ST_HEADER_UNAVAILABLE");
2094                 }
2095         }
2096 #else
2097                 char *security_status = (char *)g_strdup("IDS_ST_HEADER_UNAVAILABLE");
2098 #endif
2099                 item_data =
2100                         setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
2101                                         NULL, SWALLOW_Type_INVALID, NULL,
2102                                         NULL, 0, "IDS_ST_TMBODY_SECURITY_STATUS", security_status, NULL);
2103                 if (item_data) {
2104                         elm_object_item_disabled_set(item_data->item, EINA_TRUE);
2105                         elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2106                 } else {
2107                         SETTING_TRACE_ERROR("item_data is NULL");
2108                 }
2109                 G_FREE(security_status);
2110
2111                 if (app_info) {
2112                         app_info_destroy(app_info);
2113                 }
2114
2115                 ad->update_timer =
2116                         ecore_timer_add(1, (Ecore_Task_Cb) setting_about_main_timer_update_cb, ad);
2117
2118                 return SETTING_RETURN_SUCCESS;
2119         }
2120
2121
2122         /**
2123          * @brief TAPI response callback,get the SIM LOCK data
2124          *
2125          * @param handle the changed vconf key node.
2126          * @param result application data
2127          * @param data it is struct TelSimLockInfo_t,store SIM lock info
2128          * @param user_data application data
2129          *
2130          * @see tel_get_sim_lock_info
2131          */
2132         static void __on_pin_getlock_info(TapiHandle *handle, int result, void *data, void *user_data)
2133         {
2134                 SETTING_TRACE_BEGIN;
2135                 ret_if(data == NULL || user_data == NULL);
2136                 TelSimPinOperationResult_t sec_rt = result;
2137                 TelSimLockInfo_t *lock = data;
2138                 SettingAboutUG *ad = (SettingAboutUG *)user_data;
2139
2140                 /*lock->lock_status = TAPI_SIM_LOCK_PERM_BLOCKED; //for UT */
2141                 SETTING_TRACE_DEBUG("sec_ret[%d]", sec_rt);
2142                 SETTING_TRACE_DEBUG("lock_status:%d", lock->lock_status);
2143                 if (TAPI_SIM_LOCK_PERM_BLOCKED == lock->lock_status) {
2144                         /*update sub description with "PUK is locked" */
2145                         if (ad->item_data_my_phone_number) {
2146                                 G_FREE(ad->item_data_my_phone_number->sub_desc);
2147                                 ad->item_data_my_phone_number->sub_desc = (char *)g_strdup(SETTING_ABOUT_PUK_LOCKED);
2148                                 elm_object_item_data_set(ad->item_data_my_phone_number->item, ad->item_data_my_phone_number);
2149                                 elm_genlist_item_update(ad->item_data_my_phone_number->item);
2150                         } else {
2151                                 ad->need_update = TRUE;
2152                         }
2153                 }
2154         }
2155
2156         /**
2157          * @brief create aboutUG main view layout
2158          *
2159          * @param cb aboutUG data
2160          * @return 1 for success
2161          */
2162         static int setting_about_main_create(void *cb)
2163         {
2164                 SETTING_TRACE_BEGIN;
2165                 /* error check */
2166                 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2167
2168                 SettingAboutUG *ad = (SettingAboutUG *) cb;
2169
2170                 Evas_Object *scroller = elm_genlist_add(ad->win_main_layout);
2171                 retvm_if(scroller == NULL, SETTING_DRAW_ERR_FAIL_SCROLLER,
2172                                 "Cannot set scroller object  as contento of layout");
2173                 //elm_genlist_realization_mode_set(scroller, EINA_TRUE);
2174                 elm_object_style_set(scroller, "dialogue");
2175                 elm_genlist_clear(scroller);    /* first to clear list */
2176                 ad->genlsit = scroller;
2177                 evas_object_smart_callback_add(scroller, "realized", __gl_realized_cb, NULL);
2178                 evas_object_smart_callback_add(scroller, "realized", __setting_about_gl_realized_cb, NULL);
2179
2180                 ad->ly_main =
2181                         setting_create_layout_navi_bar(ad->win_main_layout, ad->win_get,
2182                                         KeyStr_AboutDevice,
2183                                         _("IDS_ST_BUTTON_BACK"), NULL, NULL,
2184                                         (setting_call_back_func)setting_about_main_click_softkey_back_cb,
2185                                         NULL, NULL, ad, scroller,
2186                                         &ad->navi_bar, NULL);
2187
2188                 ad->btn_done = setting_about_naviframe_btn_create(ad->navi_bar, _("IDS_SA_BUTTON_DONE_ABB"), setting_about_naviframe_btn_done_cb, ad);
2189                 /*Title Text Right Button */
2190                 ad->btn_cancel = setting_about_naviframe_btn_create(ad->navi_bar, _("IDS_ST_BUTTON_CANCEL_ABB"), setting_about_naviframe_btn_cancel_cb, ad);
2191                 ad->genlsit = scroller;
2192
2193                 evas_object_smart_callback_add(scroller, "drag", setting_about_main_gl_drag, ad);
2194
2195                 evas_object_event_callback_add(scroller, EVAS_CALLBACK_MOUSE_UP, setting_about_main_gl_mouse_up, ad);
2196
2197                 ad->navi_item = elm_naviframe_top_item_get(ad->navi_bar);
2198
2199                 setting_about_main_generate_genlist((void *)ad);
2200
2201                 int ret = vconf_notify_key_changed(VCONFKEY_WIFI_STATE,
2202                                 __setting_about_main_vconf_change_cb, ad);
2203                 if (ret != 0) {
2204                         SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
2205                 }
2206                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2207                                 __setting_about_main_vconf_change_cb, ad);
2208                 if (ret != 0) {
2209                         SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
2210                 }
2211
2212                 setting_view_about_main.is_create = 1;
2213                 SETTING_TRACE_END;
2214                 return SETTING_RETURN_SUCCESS;
2215         }
2216
2217         /**
2218          * @brief destroy aboutUG main view layout
2219          *
2220          * @param cb aboutUG data
2221          * @return 1 for success
2222          */
2223         static int setting_about_main_destroy(void *cb)
2224         {
2225                 SETTING_TRACE_BEGIN;
2226                 /* error check */
2227                 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2228
2229                 SettingAboutUG *ad = (SettingAboutUG *) cb;
2230
2231                 evas_object_smart_callback_del(ad->genlsit, "realized", __gl_realized_cb);
2232
2233                 int ret = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE,
2234                                 __setting_about_main_vconf_change_cb);
2235                 if (ret != 0) {
2236                         SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
2237                 }
2238                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2239                                 __setting_about_main_vconf_change_cb);
2240                 if (ret != 0) {
2241                         SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
2242                 }
2243
2244                 //__setting_about_main_remove_noti(ad);
2245
2246
2247                 if (ad->update_timer) {
2248                         ecore_timer_del(ad->update_timer);
2249                         ad->update_timer = NULL;
2250                 }
2251                 if (ad->update_idler) {
2252                         ecore_idler_del(ad->update_idler);
2253                         ad->update_idler = NULL;
2254                 }
2255                 if (ad->idler_add_popup) {
2256                         ecore_idler_del(ad->idler_add_popup);
2257                         ad->idler_add_popup = NULL;
2258                 }
2259                 if (ad->idler_remove_popup) {
2260                         ecore_idler_del(ad->idler_remove_popup);
2261                         ad->idler_remove_popup = NULL;
2262                 }
2263                 if (ad->idler_remove_space_popup) {
2264                         ecore_idler_del(ad->idler_remove_space_popup);
2265                         ad->idler_remove_space_popup = NULL;
2266                 }
2267                 if (ad->popup) {
2268                         evas_object_del(ad->popup);
2269                         ad->popup = NULL;
2270                 }
2271                 if (ad->popup_space) {
2272                         evas_object_del(ad->popup_space);
2273                         ad->popup_space = NULL;
2274                 }
2275
2276                 if (ad->ly_main != NULL) {
2277                         evas_object_del(ad->ly_main);
2278                         ad->ly_main = NULL;
2279                 }
2280
2281                 if (ad->event_handler) {
2282                         ecore_event_handler_del(ad->event_handler);
2283                         ad->event_handler = NULL;
2284                 }
2285                 if (ad->name_update_idler) {
2286                         ecore_idler_del(ad->name_update_idler);
2287                         ad->name_update_idler = NULL;
2288                 }
2289                 setting_view_about_main.is_create = 0;
2290                 return SETTING_RETURN_SUCCESS;
2291         }
2292
2293         /**
2294          * @brief update aboutUG main view
2295          *
2296          * @param cb aboutUG data
2297          * @return 1 for success
2298          */
2299         static int setting_about_main_update(void *cb)
2300         {
2301                 SETTING_TRACE_BEGIN;
2302                 /* error check */
2303                 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2304
2305                 SettingAboutUG *ad = (SettingAboutUG *) cb;
2306
2307                 if (ad->item_dev_name) {
2308                         ad->is_dev_name_focus = elm_object_focus_get(ad->item_dev_name->eo_check);
2309                         ad->cursor_pos = elm_entry_cursor_pos_get(ad->item_dev_name->eo_check);
2310
2311                         SETTING_TRACE("elm_object_focus_get(ad->item_dev_name->eo_check):%d", elm_object_focus_get(ad->item_dev_name->eo_check));
2312
2313                         SETTING_TRACE("ad->is_dev_name_focus:%d", ad->is_dev_name_focus);
2314                         /*elm_object_focus_set(ad->item_dev_name->eo_check, EINA_TRUE);
2315                           Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(ad->item_dev_name->eo_check);
2316                           if (imf_context) {
2317                           ecore_imf_context_input_panel_show(imf_context);
2318                           }*/
2319                         /*} */
2320         }
2321
2322         if (ad->ly_main != NULL) {
2323                 evas_object_show(ad->ly_main);
2324         }
2325
2326         return SETTING_RETURN_SUCCESS;
2327 }
2328
2329 /**
2330  * @brief hide aboutUG main view
2331  *
2332  * @param cb aboutUG data
2333  * @return 1 for success
2334  */
2335 static int setting_about_main_cleanup(void *cb)
2336 {
2337         SETTING_TRACE_BEGIN;
2338         /* error check */
2339         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2340
2341         SettingAboutUG *ad = (SettingAboutUG *) cb;
2342
2343         if (ad->ly_main != NULL) {
2344                 /*  evas_object_hide(ad->ly_main); */
2345         }
2346
2347         return SETTING_RETURN_SUCCESS;
2348 }
2349