setting-personalpage/src/setting-personalpage.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 /**
  23  *@defgroup setting-personalpage
  24  *UG creation code for setting-personalpage
  25  */
  26
  27 #include <setting-personalpage.h>
  28 #include <setting-cfg.h>
  29 #include <notification.h>
  30 #include <ode.h>
  31 #include <app_manager.h>
  32
  33 #ifndef UG_MODULE_API
  34 #define UG_MODULE_API __attribute__ ((visibility("default")))
  35 #endif
  36
  37 char *get_unlock_method_str(void *priv)
  38 {
  39         SETTING_TRACE_BEGIN;
  40         int value = 0;
  41
  42         vconf_get_int(VCONFKEY_SETAPPL_PERSONAL_MODE_UNLOCK_METHOD_INT, &value);
  43
  44         if (value == 1) {
  45                 return "IDS_ST_BODY_SIMPLE_PASSWORD"; /*setting_gettext("PIN"); */
  46         } else if (value == 2) {
  47                 return "IDS_COM_BODY_AUTH_PASSWORD"; /*setting_gettext("IDS_COM_BODY_OFF_M_STATUS"); */
  48         } else {
  49                 return "IDS_ST_BODY_NOT_ASSIGNED";
  50         }
  51 }
  52
  53 void setting_personalpage_vconf_change_cb(keynode_t *key, void *data)
  54 {
  55         SETTING_TRACE_BEGIN;
  56         ret_if(NULL == data);
  57         SettingPersonalpageUG *ad = (SettingPersonalpageUG *) data;
  58
  59         char *vconf_name = vconf_keynode_get_name(key);
  60         SETTING_TRACE("key name : %s", vconf_name);
  61         if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL)) {
  62                 int status = vconf_keynode_get_bool(key);
  63
  64                 /*update toggle */
  65                 SETTING_TRACE("update tobble to %d", status);
  66 #if SUPPORT_MASTER_CONTROL
  67                 elm_check_state_set(ad->master_control, status);
  68 #else
  69                 setting_update_gl_item_chk_status(ad->data_personal_mode, status);
  70 #endif
  71                 /*update unlock method menu */
  72                 if (ad->data_unlock_method && ad->data_unlock_method->item) {
  73                         if (status) {
  74                                 setting_enable_genlist_item(ad->data_unlock_method->item);
  75                         } else {
  76                                 setting_disable_genlist_item(ad->data_unlock_method->item);
  77                         }
  78                 }
  79         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_PERSONAL_MODE_UNLOCK_METHOD_INT)) {
  80                 if (ad->data_unlock_method && ad->data_unlock_method->item) {
  81                         ad->data_unlock_method->sub_desc = (char *)g_strdup(get_unlock_method_str(ad));
  82                         elm_object_item_data_set(ad->data_unlock_method->item, ad->data_unlock_method);
  83                         elm_genlist_item_update(ad->data_unlock_method->item);
  84                 }
  85         }
  86 }
  87
  88 static void setting_personalpage_ug_cb_resize(void *data, Evas *e,
  89                                               Evas_Object *obj, void *event_info)
  90 {
  91         ret_if(data == NULL);
  92
  93         SettingPersonalpageUG *ad = (SettingPersonalpageUG *) data;     /* ad is point to data */
  94         setting_view_update(&setting_view_personalpage_main, ad);
  95 }
  96
  97 Evas_Object *setting_personalpage_create_win_layout_without_bg(Evas_Object *win_layout,
  98                                                                Evas_Object *win_obj)
  99 {
 100         Evas_Object *layout = NULL;
 101         /*  Base Layout */
 102         layout = elm_layout_add(win_obj);
 103         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 104         setting_retvm_if(layout == NULL, FALSE, "layout == NULL");
 105
 106         elm_layout_theme_set(layout, "layout", "application", "default");
 107         evas_object_show(layout);
 108         return layout;
 109 }
 110
 111 static void *setting_personalpage_ug_on_create(ui_gadget_h ug,
 112                                                enum ug_mode mode, app_control_h service,
 113                                                void *priv)
 114 {
 115         SETTING_TRACE_BEGIN;
 116         setting_retvm_if((!priv), NULL, "!priv");
 117
 118         SettingPersonalpageUG *personalUG = priv;
 119         personalUG->ug = ug;
 120
 121         personalUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 122         personalUG->win_get = (Evas_Object *) ug_get_window();
 123         evas_object_show(personalUG->win_main_layout);
 124         personalUG->evas = evas_object_evas_get(personalUG->win_main_layout);
 125
 126         /*setting_retvm_if(personalUG->win_main_layout == NULL, NULL, */
 127         /*               "[Setting >> Personal page] cannot get main window "); */
 128         if (!personalUG->win_main_layout)
 129                 SETTING_TRACE_ERROR("can't get parent layout");
 130
 131         bindtextdomain(SETTING_PACKAGE, SETTING_LOCALEDIR);
 132
 133         /* register view node table */
 134         setting_view_node_table_intialize();
 135
 136         char *viewtype = NULL;
 137         app_control_get_extra_data(service, "viewtype", &viewtype);
 138
 139         if (viewtype && !safeStrCmp(viewtype, "unlock_method")) {
 140                 int current_unlock = -1;
 141                 vconf_get_int(VCONFKEY_SETAPPL_PERSONAL_MODE_UNLOCK_METHOD_INT, &current_unlock);
 142                 if (current_unlock == 1 || current_unlock == 2) {
 143                         personalUG->ly_main = setting_personalpage_create_win_layout_without_bg(personalUG->win_get, personalUG->win_get);
 144                         /* just change on/off using password ug. */
 145                         personalUG->viewtype = PERSONAL_VIEW_PW_UG;
 146                         /*setting_personalpage_create_password_sg(personalUG, SETTING_PERSONAL_PW_CALLER_ON_OFF); */
 147                         return personalUG->ly_main;
 148                 } else {
 149                         personalUG->viewtype = PERSONAL_VIEW_UNLOCK_METHOD;
 150                         setting_view_node_table_register(&setting_view_personalpage_unlock, NULL);
 151                         personalUG->view_to_load = &setting_view_personalpage_unlock;
 152                 }
 153         } else {
 154                 personalUG->viewtype = PERSONAL_VIEW_MAIN;
 155                 setting_view_node_table_register(&setting_view_personalpage_main, NULL);
 156                 setting_view_node_table_register(&setting_view_personalpage_unlock, &setting_view_personalpage_main);
 157                 personalUG->view_to_load = &setting_view_personalpage_main;
 158
 159                 /* register vconf callback */
 160                 vconf_notify_key_changed(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, setting_personalpage_vconf_change_cb, personalUG);
 161                 vconf_notify_key_changed(VCONFKEY_SETAPPL_PERSONAL_MODE_UNLOCK_METHOD_INT, setting_personalpage_vconf_change_cb, personalUG);
 162         }
 163         FREE(viewtype);
 164
 165         setting_retvm_if(NULL == personalUG->view_to_load, NULL,
 166                          "NULL == personalUG->view_to_load");
 167
 168         setting_view_node_set_cur_view(personalUG->view_to_load);
 169         setting_view_create(personalUG->view_to_load, (void *)personalUG);
 170         evas_object_event_callback_add(personalUG->win_main_layout,
 171                                        EVAS_CALLBACK_RESIZE,
 172                                        setting_personalpage_ug_cb_resize, personalUG);
 173
 174         SETTING_TRACE_END;
 175         return personalUG->ly_main;
 176 }
 177
 178 void __off_popup_resp_cb(void *data, Evas_Object *obj, void *event_info)
 179 {
 180         SETTING_TRACE_BEGIN;
 181         ret_if(!data);
 182
 183         SettingPersonalpageUG *ad = (SettingPersonalpageUG *)data;
 184
 185         int response_type = btn_type(obj);
 186
 187         if (response_type == POPUP_RESPONSE_CANCEL) {
 188                 SETTING_TRACE("CANCEL");
 189         } else if (response_type == POPUP_RESPONSE_OK) {
 190                 /* if ok, do nothing */
 191                 SETTING_TRACE("OK");
 192
 193                 if (ad->off_popup_check) {
 194                         int status = elm_check_state_get(ad->off_popup_check);
 195                         vconf_set_bool("db/setting/personal_off_popup_do_not_show_flag", status);
 196                 }
 197                 setting_personalpage_unmount(ad);
 198         }
 199
 200         if (ad->off_popup) {
 201                 evas_object_del(ad->off_popup);
 202                 ad->off_popup = NULL;
 203         }
 204
 205         ug_destroy_me(ad->ug);
 206 }
 207
 208 static void setting_personalpage_ug_on_start(ui_gadget_h ug, app_control_h service,
 209                                              void *priv)
 210 {
 211         setting_retm_if((!priv), "!priv");
 212         SettingPersonalpageUG *personalUG = priv;
 213
 214         if (personalUG->viewtype == PERSONAL_VIEW_PW_UG) {
 215                 int current = 0;
 216                 vconf_get_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, &current);
 217                 if (current) { /* On to Off */
 218                         int do_not_show = 0;
 219                         vconf_get_bool("db/setting/personal_off_popup_do_not_show_flag", &do_not_show);
 220                         if (do_not_show) {
 221                                 setting_personalpage_unmount(personalUG);
 222                                 ug_destroy_me(personalUG->ug);
 223                         } else {
 224                                 /* add popup */
 225                                 /*elm_win_alpha_set(personalUG->win_get, EINA_TRUE); */
 226                                 personalUG->off_popup = setting_create_popup_with_label_check(personalUG, personalUG->ly_main,
 227                                                                                               NULL,
 228                                                                                               _("IDS_ST_POP_ANY_PERSONAL_CONTENT_WILL_NOT_BE_ACCESSIBLE_IN_NORMAL_MODE"),
 229                                                                                               _("IDS_ST_BODY_DO_NOT_SHOW_AGAIN"), &(personalUG->off_popup_check),
 230                                                                                               __off_popup_resp_cb, 0,
 231                                                                                               2,
 232                                                                                               "IDS_COM_SK_CANCEL", "IDS_COM_SK_OK");
 233                         }
 234                 } else {
 235                         setting_personalpage_create_password_sg(personalUG, SETTING_PERSONAL_PW_CALLER_ON_OFF);
 236                 }
 237         }
 238 }
 239
 240 static void setting_personalpage_ug_on_pause(ui_gadget_h ug, app_control_h service,
 241                                              void *priv)
 242 {
 243 }
 244
 245 static void setting_personalpage_ug_on_resume(ui_gadget_h ug, app_control_h service,
 246                                               void *priv)
 247 {
 248         SETTING_TRACE_BEGIN;
 249         /*ug_destroy_me(ug); */
 250 }
 251
 252 static void setting_personalpage_ug_on_destroy(ui_gadget_h ug, app_control_h service,
 253                                                void *priv)
 254 {
 255         /*SETTING_TRACE_BEGIN; */
 256         setting_retm_if((!priv), "!priv");
 257         SettingPersonalpageUG *personalUG = priv;
 258
 259         app_control_h reply;
 260         if (!app_control_create(&reply)) {
 261                 service_reply_to_launch_request(reply, service, APP_CONTROL_ERROR_NONE);
 262                 app_control_destroy(reply);
 263         }
 264
 265         evas_object_event_callback_del(personalUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_personalpage_ug_cb_resize);   /* fix flash issue for gallery */
 266
 267         personalUG->ug = ug;
 268
 269         if (personalUG->viewtype == PERSONAL_VIEW_UNLOCK_METHOD) {
 270                 setting_view_destroy(&setting_view_personalpage_unlock, personalUG);
 271         } else if (personalUG->viewtype == PERSONAL_VIEW_PW_UG) {
 272                 /*SETTING_TRACE_DEBUG("viewtype is PW_UG"); */
 273                 if (personalUG->ly_main != NULL) {
 274                         if (personalUG->off_popup) {
 275                                 evas_object_del(personalUG->off_popup);
 276                                 personalUG->off_popup = NULL;
 277                         }
 278                         /*SETTING_TRACE_DEBUG("delete ly_main"); */
 279                         evas_object_del(personalUG->ly_main);
 280                         personalUG->ly_main = NULL;
 281                 }
 282         } else {
 283                 /* unregister vconf callback */
 284                 vconf_ignore_key_changed(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, setting_personalpage_vconf_change_cb);
 285                 vconf_ignore_key_changed(VCONFKEY_SETAPPL_PERSONAL_MODE_UNLOCK_METHOD_INT, setting_personalpage_vconf_change_cb);
 286                 setting_view_destroy(&setting_view_personalpage_unlock, personalUG);
 287                 setting_view_destroy(&setting_view_personalpage_main, personalUG);
 288         }
 289
 290         FREE(personalUG->change_unlock_method_data);
 291
 292         if (NULL != ug_get_layout(personalUG->ug)) {
 293                 evas_object_hide((Evas_Object *) ug_get_layout(personalUG->ug));
 294                 evas_object_del((Evas_Object *) ug_get_layout(personalUG->ug));
 295         }
 296 }
 297
 298 static void setting_personalpage_ug_on_message(ui_gadget_h ug, app_control_h msg,
 299                                                app_control_h service, void *priv)
 300 {
 301
 302 }
 303
 304 static void setting_personalpage_ug_on_event(ui_gadget_h ug,
 305                                              enum ug_event event, app_control_h service,
 306                                              void *priv)
 307 {
 308         SETTING_TRACE_BEGIN;
 309         SettingPersonalpageUG *ad = (SettingPersonalpageUG *)priv;
 310         setting_retm_if(NULL == ad, "ad is NULL");
 311         switch (event) {
 312                 case UG_EVENT_LOW_MEMORY:
 313                         break;
 314                 case UG_EVENT_LOW_BATTERY:
 315                         break;
 316                 case UG_EVENT_LANG_CHANGE:
 317                         setting_navi_items_update(ad->navi_bar);
 318                         break;
 319                 case UG_EVENT_ROTATE_PORTRAIT:
 320                 case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 321                 case UG_EVENT_ROTATE_LANDSCAPE:
 322                 case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN: {
 323                                 SETTING_TRACE_DEBUG("rotation events : %d", event);
 324                         }
 325                         break;
 326                 case UG_EVENT_REGION_CHANGE:
 327                         break;
 328                 default:
 329                         break;
 330         }
 331 }
 332
 333 static void setting_personalpage_ug_on_key_event(ui_gadget_h ug,
 334                                                  enum ug_key_event event,
 335                                                  app_control_h service, void *priv)
 336 {
 337         if (!priv)
 338                 return;
 339         SettingPersonalpageUG *ad = (SettingPersonalpageUG *) priv;     /* ad is point to priv */
 340         switch (event) {
 341                 case UG_KEY_EVENT_END: {
 342                                 if (elm_naviframe_top_item_get(ad->navi_bar) ==
 343                                     elm_naviframe_bottom_item_get(ad->navi_bar)) {
 344                                         ug_destroy_me(ug);
 345                                 } else {
 346                                         /* elm_naviframe_item_pop(ad->navi_bar); */
 347                                         setting_view_cb_at_endKey(ad);
 348                                 }
 349                         }
 350                         break;
 351
 352                 default:
 353                         break;
 354         }
 355 }
 356
 357 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 358 {
 359         SETTING_TRACE_BEGIN;
 360         SettingPersonalpageUG *personalUG = calloc(1, sizeof(SettingPersonalpageUG));
 361         setting_retvm_if(!personalUG, -1,
 362                          "Create SettingPersonalpageUG obj failed");
 363
 364         ops->create = setting_personalpage_ug_on_create;
 365         ops->start = setting_personalpage_ug_on_start;
 366         ops->pause = setting_personalpage_ug_on_pause;
 367         ops->resume = setting_personalpage_ug_on_resume;
 368         ops->destroy = setting_personalpage_ug_on_destroy;
 369         ops->message = setting_personalpage_ug_on_message;
 370         ops->event = setting_personalpage_ug_on_event;
 371         ops->key_event = setting_personalpage_ug_on_key_event;
 372         ops->priv = personalUG;
 373         ops->opt = UG_OPT_INDICATOR_ENABLE;
 374
 375         return 0;
 376 }
 377
 378 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 379 {
 380         struct SettingPersonalpageUG *personalUG;
 381         setting_retm_if(!ops, "ops == NULL");
 382
 383         personalUG = ops->priv;
 384         if (personalUG)
 385                 FREE(personalUG);
 386 }
 387
 388 void setting_personalpage_layout_passwd_ug_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 389 {
 390         Evas_Object *base = ug_get_layout(ug);
 391         if (!base)
 392                 return;
 393
 394         switch (mode) {
 395                 case UG_MODE_FULLVIEW:
 396                         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 397                                                          EVAS_HINT_EXPAND);
 398                         evas_object_show(base);
 399                         break;
 400                 default:
 401                         break;
 402         }
 403
 404         return;
 405 }
 406
 407 void setting_personalpage_destroy_password_ug_cb(ui_gadget_h ug, void *priv)
 408 {
 409         SETTING_TRACE_BEGIN;
 410         if (ug) {
 411                 setting_ug_destroy(ug);
 412         }
 413 }
 414
 415 void create_notification(void *data)
 416 {
 417         notification_h noti;
 418         notification_error_e err;
 419
 420         int id;
 421         int ret;
 422
 423         notification_delete_all_by_type("org.tizen.setting.personal", NOTIFICATION_VARIABLE_TYPE_NONE);
 424
 425         /* 1 line notification on the notification bar. */
 426         notification_status_message_post(_("IDS_ST_TPOP_PERSONAL_MODE_ENABLED_ABB"));
 427
 428         noti = notification_new(NOTIFICATION_TYPE_ONGOING, NOTIFICATION_GROUP_ID_NONE, NOTIFICATION_PRIV_ID_NONE);
 429         if (noti) {
 430                 err = notification_set_pkgname(noti, "org.tizen.setting.personal");
 431                 SETTING_TRACE_DEBUG("notification_set_pkgname() returns %d", err);
 432                 err = notification_set_text_domain(noti, SETTING_PACKAGE, SETTING_LOCALEDIR);
 433                 SETTING_TRACE_DEBUG("notification_set_text_domain() returns %d", err);
 434                 err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_TITLE,
 435                                             _("IDS_ST_HEADER_PERSONAL_MODE"),
 436                                             "IDS_ST_HEADER_PERSONAL_MODE", NOTIFICATION_VARIABLE_TYPE_NONE);
 437                 SETTING_TRACE_DEBUG("notification_set_text() returns %d", err);
 438                 err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT,
 439                                             _("IDS_ST_TPOP_PERSONAL_MODE_ENABLED_ABB"),
 440                                             "IDS_ST_TPOP_PERSONAL_MODE_ENABLED_ABB", NOTIFICATION_VARIABLE_TYPE_NONE);
 441                 SETTING_TRACE_DEBUG("notification_set_text() returns %d", err);
 442
 443                 err = notification_set_layout(noti, NOTIFICATION_LY_ONGOING_EVENT);
 444                 SETTING_TRACE_DEBUG("notification_set_layout() returns %d", err);
 445                 err = notification_insert(noti, &id);
 446                 SETTING_TRACE_DEBUG("notification_insert() returns %d", err);
 447                 SETTING_TRACE_DEBUG("notification(%d) is created.", id);
 448
 449                 ret = notification_free(noti);
 450                 if (ret != NOTIFICATION_ERROR_NONE) {
 451                         SETTING_TRACE_ERROR("Fail to notification_free [%d]", ret);
 452                 }
 453         }
 454 }
 455
 456 void setting_personalpage_unmount(void *data)
 457 {
 458         SETTING_TRACE_BEGIN;
 459         ret_if(data == NULL);
 460         SettingPersonalpageUG *ad = (SettingPersonalpageUG *) data;
 461
 462         /* unmount */
 463         if (ode_init() != 0) {
 464                 SETTING_TRACE("change #1. init failed");
 465                 setting_create_simple_popup(ad, ad->navi_bar, NULL, "Fail to change unlock method");
 466                 return;
 467         }
 468         if (pse_unmount() != 0) {
 469                 SETTING_TRACE("change #2. unmount failed");
 470                 setting_create_simple_popup(ad, ad->navi_bar, NULL, "Fail to change unlock method");
 471                 ode_deinit();
 472                 return;
 473         }
 474         ode_deinit();
 475
 476         vconf_set_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, 0);
 477         notification_delete_all_by_type("org.tizen.setting.personal", NOTIFICATION_VARIABLE_TYPE_NONE);
 478         /* 1 line notification on the notification bar. */
 479         notification_status_message_post(_("IDS_ST_TPOP_PERSONAL_MODE_DISABLED_ABB"));
 480 }
 481
 482 void __unmount_popup_resp_cb(void *data, Evas_Object *obj, void *event_info)
 483 {
 484         SETTING_TRACE_BEGIN;
 485         ret_if(data == NULL);
 486         SettingPersonalpageUG *ad = (SettingPersonalpageUG *)data;
 487
 488         setting_personalpage_unmount(ad);
 489         if (ad->unmount_popup) {
 490                 evas_object_del(ad->unmount_popup);
 491                 ad->unmount_popup = NULL;
 492         }
 493         ug_destroy_me(ad->ug);
 494 }
 495
 496 void setting_personalpage_end_password_ug_cb(ui_gadget_h ug, void *priv)
 497 {
 498         SETTING_TRACE_BEGIN;
 499         ret_if(priv == NULL);
 500         SettingPersonalpageUG *ad = (SettingPersonalpageUG *) priv;
 501
 502         ad->ug_passwd = NULL;
 503
 504         if (ad->do_nothing_flag == 1 || !ad->result_cb_called) {
 505                 /*SETTING_TRACE_DEBUG("viewtype %d", ad->viewtype); */
 506                 ad->do_nothing_flag = 0;
 507                 if (ad->viewtype == PERSONAL_VIEW_PW_UG)
 508                         ug_destroy_me(ad->ug);
 509                 return;
 510         }
 511
 512         ad->result_cb_called = 0;
 513
 514         if (ad->unmount_flag == 1) {
 515                 ad->unmount_flag = 0;
 516
 517                 char temp[256] = {0,};
 518                 snprintf(temp, 256, "%s<br>%s", _("IDS_COM_INCORRECT_PASSWORD_ENTERED_5_TIMES"), _("IDS_ST_TPOP_PERSONAL_MODE_DISABLED_ABB"));
 519
 520                 ad->unmount_popup = setting_create_popup_without_btn(ad, ad->win_main_layout,
 521                                                                      NULL,
 522                                                                      temp,
 523                                                                      __unmount_popup_resp_cb, 2, TRUE, TRUE);
 524                 return;
 525         }
 526
 527         if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_UNLOCK_PIN || ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_UNLOCK_PASSWORD) {
 528                 int current = -1;
 529                 vconf_get_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, &current);
 530                 if (current == 0) {
 531                         /* mount */
 532                         if (ode_init() != 0) {
 533                                 setting_create_simple_popup(ad, ad->navi_bar, NULL, "IDS_ST_TPOP_FAILED_TO_ENABLE_PERSONAL_MODE_TRY_AGAIN_ABB");
 534                                 return;
 535                         }
 536
 537                         char *personal_data = NULL;
 538
 539                         personal_data = vconf_get_str("db/setting/personal_key");
 540                         if (pse_mount(personal_data) != 0) {
 541                                 setting_create_simple_popup(ad, ad->navi_bar, NULL, "IDS_ST_TPOP_FAILED_TO_ENABLE_PERSONAL_MODE_TRY_AGAIN_ABB");
 542                                 ode_deinit();
 543                                 FREE(personal_data);
 544                                 return;
 545                         }
 546                         FREE(personal_data);
 547                         ode_deinit();
 548                         vconf_set_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, !current);
 549                         create_notification(ad);
 550                 } else {
 551                         /* mount again because key is changed */
 552                         /* unmount first. */
 553                         if (ode_init() != 0) {
 554                                 SETTING_TRACE("change #1. init failed");
 555                                 setting_create_simple_popup(ad, ad->navi_bar, NULL, "Fail to change unlock method");
 556                                 return;
 557                         }
 558                         if (pse_unmount() != 0) {
 559                                 SETTING_TRACE("change #2. unmount failed");
 560                                 setting_create_simple_popup(ad, ad->navi_bar, NULL, "Fail to change unlock method");
 561                                 ode_deinit();
 562                                 return;
 563                         }
 564                         /* re-mount with new. */
 565                         char *personal_data = NULL;
 566                         personal_data = vconf_get_str("db/setting/personal_key");
 567
 568                         if (pse_mount(personal_data) != 0) {
 569                                 SETTING_TRACE("change #3. re-mount failed");
 570                                 setting_create_simple_popup(ad, ad->navi_bar, NULL, "Fail to change unlock method");
 571                                 ode_deinit();
 572                                 FREE(personal_data);
 573                                 return;
 574                         }
 575                         ode_deinit();
 576                         FREE(personal_data);
 577                 }
 578                 vconf_set_int(VCONFKEY_SETAPPL_PERSONAL_MODE_UNLOCK_METHOD_INT, ad->pw_ug_caller - 1);
 579                 if (ad->viewtype == PERSONAL_VIEW_UNLOCK_METHOD)
 580                         ug_destroy_me(ad->ug);
 581                 else
 582                         setting_view_change(&setting_view_personalpage_unlock, &setting_view_personalpage_main, ad);
 583         } else if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_UNLOCK_METHOD) {
 584                 setting_view_change(&setting_view_personalpage_main, &setting_view_personalpage_unlock, ad);
 585         } else if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_PERSONAL
 586                    || ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_ON_OFF) {
 587                 int current = -1;
 588                 int new_status = -1;
 589                 vconf_get_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, &current);
 590
 591                 new_status = !current;
 592                 SETTING_TRACE("new_status %d", new_status);
 593                 if (new_status == 1) {
 594                         /* mount */
 595                         if (ode_init() != 0) {
 596                                 setting_create_simple_popup(ad, ad->win_get, NULL, "IDS_ST_TPOP_FAILED_TO_ENABLE_PERSONAL_MODE_TRY_AGAIN_ABB");
 597                                 if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_ON_OFF)
 598                                         ug_destroy_me(ad->ug);
 599                                 else
 600                                         return;
 601                         }
 602
 603                         char *personal_data = NULL;
 604
 605                         personal_data = vconf_get_str("db/setting/personal_key");
 606
 607                         if (pse_mount(personal_data) != 0) {
 608                                 setting_create_simple_popup(ad, ad->win_get, NULL, "IDS_ST_TPOP_FAILED_TO_ENABLE_PERSONAL_MODE_TRY_AGAIN_ABB");
 609                                 if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_ON_OFF) {
 610                                         ug_destroy_me(ad->ug);
 611                                 } else {
 612                                         FREE(personal_data);
 613                                         ode_deinit();
 614                                         return;
 615                                 }
 616                         }
 617                         FREE(personal_data);
 618                         ode_deinit();
 619
 620                         vconf_set_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, new_status);
 621                         create_notification(ad);
 622                 } else if (new_status == 0) {
 623                         /* unmount */
 624                         if (ode_init() != 0) {
 625                                 setting_create_simple_popup(ad, ad->win_get, NULL, "IDS_ST_TPOP_FAILED_TO_DISABLE_PERSONAL_MODE_TRY_AGAIN_ABB");
 626                                 if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_ON_OFF)
 627                                         ug_destroy_me(ad->ug);
 628                                 else
 629                                         return;
 630                         }
 631
 632                         if (pse_unmount() != 0) {
 633                                 setting_create_simple_popup(ad, ad->win_get, NULL, "IDS_ST_TPOP_FAILED_TO_DISABLE_PERSONAL_MODE_TRY_AGAIN_ABB");
 634                                 if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_ON_OFF) {
 635                                         ug_destroy_me(ad->ug);
 636                                 } else {
 637                                         ode_deinit();
 638                                         return;
 639                                 }
 640                         }
 641                         ode_deinit();
 642
 643                         vconf_set_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, new_status);
 644
 645                         notification_delete_all_by_type("setting-personalpage-efl", NOTIFICATION_VARIABLE_TYPE_NONE);
 646                         /* 1 line notification on the notification bar. */
 647                         notification_status_message_post(_("IDS_ST_TPOP_PERSONAL_MODE_DISABLED_ABB"));
 648                 }
 649                 if (ad->pw_ug_caller == SETTING_PERSONAL_PW_CALLER_ON_OFF)
 650                         ug_destroy_me(ad->ug);
 651         }
 652 }
 653
 654 void setting_personalpage_result_password_ug_cb(ui_gadget_h ug, app_control_h service, void *priv)
 655 {
 656         SETTING_TRACE_BEGIN;
 657         /* error check */
 658         retm_if(priv == NULL, "Data paremeter is NULL");
 659         SettingPersonalpageUG *ad = (SettingPersonalpageUG *) priv;
 660
 661         char *result = NULL;
 662         app_control_get_extra_data(service, "result", &result);
 663         if (!result)
 664                 return;
 665
 666         SETTING_TRACE_DEBUG("result : %s", result);
 667
 668         if (!safeStrCmp(result, "Cancel") || !safeStrCmp(result, "Fail") || !safeStrCmp(result, "Restore")) {
 669                 ad->do_nothing_flag = 1;
 670                 ad->unmount_flag = 0;
 671         } else if (!safeStrCmp(result, "Unmount")) {
 672                 ad->unmount_flag = 1;
 673                 ad->do_nothing_flag = 0;
 674         }
 675
 676         ad->result_cb_called = 1;
 677
 678         SETTING_TRACE_END;
 679 }
 680
 681 gboolean setting_personalpage_create_password_sg(void *data, int caller)
 682 {
 683         SETTING_TRACE_BEGIN;
 684         /* error check */
 685         retv_if(data == NULL, FALSE);
 686
 687         SettingPersonalpageUG *ad = (SettingPersonalpageUG *) data;     /* ad is point to data */
 688
 689         /* prevent the ug from being loaded again due to window event queuing */
 690         /* added by JTS: CQ H0100135346 */
 691         if (ad->ug_passwd) {
 692                 SETTING_TRACE("Password UG is already loaded.");
 693                 return FALSE;
 694         }
 695
 696         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 697
 698         if (!cbs)
 699                 return FALSE;
 700         cbs->layout_cb = setting_personalpage_layout_passwd_ug_cb;
 701         cbs->result_cb = setting_personalpage_result_password_ug_cb;
 702         cbs->destroy_cb = setting_personalpage_destroy_password_ug_cb;
 703         cbs->end_cb = setting_personalpage_end_password_ug_cb;
 704         cbs->priv = (void *)ad;
 705
 706         app_control_h svc;
 707         if (app_control_create(&svc)) {
 708                 FREE(cbs);
 709                 return FALSE;
 710         }
 711
 712         ad->do_nothing_flag = 0;
 713         ad->pw_ug_caller = caller;
 714
 715         if (caller == SETTING_PERSONAL_PW_CALLER_PERSONAL
 716             || caller == SETTING_PERSONAL_PW_CALLER_ON_OFF)
 717                 app_control_add_extra_data(svc, "viewtype", "SETTING_PW_TYPE_PERSONAL_PAGE_ON");
 718         else if (caller == SETTING_PERSONAL_PW_CALLER_UNLOCK_METHOD)
 719                 app_control_add_extra_data(svc, "viewtype", "SETTING_PW_TYPE_PERSONAL_PAGE");
 720         else if (caller == SETTING_PERSONAL_PW_CALLER_UNLOCK_PIN)
 721                 app_control_add_extra_data(svc, "viewtype", "SETTING_PW_TYPE_PERSONAL_PAGE_NEW_SIMPLE");
 722         else if (caller == SETTING_PERSONAL_PW_CALLER_UNLOCK_PASSWORD)
 723                 app_control_add_extra_data(svc, "viewtype", "SETTING_PW_TYPE_PERSONAL_PAGE_NEW_PASSWORD");
 724
 725         elm_object_tree_focus_allow_set(ad->ly_main, EINA_FALSE);
 726         ad->ug_passwd = setting_ug_create(ad->ug, "setting-password-efl", UG_MODE_FULLVIEW, svc, cbs);
 727         if (NULL == ad->ug_passwd) {    /* error handling */
 728                 evas_object_show(ad->ly_main);
 729         }
 730
 731         app_control_destroy(svc);
 732         FREE(cbs);
 733
 734         return TRUE;
 735 }
 736
 737 #define SUBINDEX_NAME "Personal mode"
 738
 739 static Setting_Cfg_Node_T s_cfg_node_array[] = {
 740         /*{"IDS_ST_HEADER_PERSONAL_MODE", SETTING_ICON_PATH_CFG"settings_personal_mode.png", "viewtype:frontpage", NULL, 0, 0, Cfg_Item_View_Node_Toggle, NULL, SUBINDEX_NAME, NULL}, */
 741         {"IDS_ST_MBODY_UNLOCK_METHOD", SETTING_ICON_PATH_CFG"settings_personal_mode.png", "viewtype:frontpage", 0, 0, 0, Cfg_Item_View_Node, NULL, SUBINDEX_NAME, NULL, NULL},
 742 };
 743
 744
 745 UG_MODULE_API int setting_plugin_search_init(app_control_h service, void *priv, char **applocale)
 746 {
 747         SETTING_TRACE_BEGIN;
 748         SETTING_TRACE(">> setting-personalpage-efl DB search code");
 749
 750         *applocale = strdup("setting:/usr/apps/org.tizen.setting/res/locale");
 751
 752         Eina_List **pplist = (Eina_List **)priv;
 753         int i;
 754         int size = sizeof(s_cfg_node_array) / sizeof(s_cfg_node_array[0]);
 755         for (i = 0; i < size; i++) {
 756                 Setting_Cfg_Node_T *node = setting_plugin_search_item_subindex_add(s_cfg_node_array[i].key_name, s_cfg_node_array[i].ug_args, s_cfg_node_array[i].icon_path, s_cfg_node_array[i].item_type,  s_cfg_node_array[i].data, s_cfg_node_array[i].sub_index);
 757                 *pplist = eina_list_append(*pplist, node);
 758         }
 759         return 0;
 760 }
 761
 762 EXPORT_PUBLIC
 763 int get_personal_mode(Cfg_Item_State *state, void *data)
 764 {
 765         SETTING_TRACE_BEGIN;
 766         int err = 0;
 767         int value = -1;
 768
 769         err = vconf_get_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, &value);
 770         if (value == 1)
 771                 *state = Cfg_Item_On;
 772         else
 773                 *state = Cfg_Item_Off;
 774
 775         return err;
 776 }
 777
 778 EXPORT_PUBLIC
 779 int set_personal_mode(Cfg_Item_State state, void *item, void *data)
 780 {
 781         SETTING_TRACE_BEGIN;
 782         /* launch personal mode */
 783         bool is_running = FALSE;
 784         app_manager_is_running("org.tizen.setting.personal", &is_running);
 785         if (!is_running) {
 786                 app_control_h svc;
 787                 if (app_control_create(&svc)) {
 788                         /*FREE(cbs); */
 789                         return 0;
 790                 }
 791                 app_control_add_extra_data(svc, "viewtype", "unlock_method");
 792                 app_control_set_app_id(svc, "org.tizen.setting.personal");
 793                 app_control_set_operation(svc, APP_CONTROL_OPERATION_DEFAULT);
 794                 app_control_send_launch_request(svc, NULL, NULL);
 795                 app_control_destroy(svc);
 796         }
 797         return 0;
 798 }
 799
 800 EXPORT_PUBLIC
 801 cfg_func_table personal_opt_tab = {
 802         .get_item_state = get_personal_mode,
 803         .set_item_state = set_personal_mode,
 804         .set_item_update_ui = NULL,
 805 };
 806
 807 UG_MODULE_API int setting_plugin_search_query_ops(char *str_id, void **tfunc_obj)
 808 {
 809         SETTING_TRACE_BEGIN;
 810         if (str_id && !safeStrCmp(str_id, _("IDS_ST_HEADER_PERSONAL_MODE"))) {
 811                 *tfunc_obj = (void *)&personal_opt_tab;
 812         }
 813
 814         return 0;
 815 }
 816