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