setting-locktype/src/setting-locktype.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-security
  24  *UG creation code for setting-security
  25  */
  26
  27 #include <setting-locktype.h>
  28 #include <efl_assist.h>
  29
  30 #include <Ecore_X.h>
  31 #include <utilX.h>
  32 #include <security-server.h>
  33
  34 #define Max_Passwd_View_Type_Len        64
  35 #ifndef UG_MODULE_API
  36 #define UG_MODULE_API __attribute__ ((visibility("default")))
  37 #endif
  38
  39 void setting_locktype_ug_popup_resp_cb(void *data, Evas_Object *obj, void *event_info)
  40 {
  41         SETTING_TRACE_BEGIN;
  42         retm_if(data == NULL, "Data parameter is NULL");
  43
  44         SettingLocktypeUG *ad = (SettingLocktypeUG *)data;
  45         if(ad->save_popup)
  46         {
  47                 evas_object_del(ad->save_popup);
  48                 ad->save_popup = NULL;
  49         }
  50         ug_destroy_me(ad->ug);
  51 }
  52
  53 int pwd_handler_do_nothing(SettingLocktypeUG *data, void* arg)
  54 {
  55         SETTING_TRACE_BEGIN;
  56         //SettingLocktypeUG *ad = (SettingLocktypeUG *)data;
  57         // DO NOTHING
  58         return 0;
  59 }
  60
  61 int pwd_handler_sec_pw_passwd(SettingLocktypeUG *data, void* arg)
  62 {
  63         SETTING_TRACE_BEGIN;
  64         SettingLocktypeUG *ad = (SettingLocktypeUG *)data;
  65
  66         if(vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_PASSWORD) == 0)
  67         {
  68                 ///* set radio */
  69                 if(ad->lock_type_rd)
  70                         elm_radio_value_set(ad->lock_type_rd, SETTING_SCREEN_LOCK_TYPE_PASSWORD);
  71
  72                 ad->save_popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_ST_POP_NEW_PASSWD_SAVED"),
  73                                                                                         setting_locktype_ug_popup_resp_cb,
  74                                                                                         POPUP_INTERVAL, FALSE, FALSE);
  75         }
  76         else
  77         {
  78                 SETTING_TRACE_ERROR("setting vconf value failed : screen_lock_type");
  79         }
  80
  81         return 0;
  82 }
  83
  84 int pwd_handler_sec_pw_simple_passwd (SettingLocktypeUG *data, void* arg)
  85 {
  86         SETTING_TRACE_BEGIN;
  87         SettingLocktypeUG *ad = (SettingLocktypeUG *)data;
  88
  89         SETTING_TRACE("ad->selected_lock_type:%s", ad->selected_lock_type);
  90         //'face and voice ' and 'simple password' share the same PASSWD_TYPE and callback function
  91         int lock_type = SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD;
  92         if(vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type) == 0)
  93         {
  94                 ///* set radio */
  95                 if(ad->lock_type_rd)
  96                         elm_radio_value_set(ad->lock_type_rd, lock_type);
  97
  98                 ad->save_popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_ST_POP_NEW_PASSWD_SAVED"),
  99                                                                                         setting_locktype_ug_popup_resp_cb,
 100                                                                                         POPUP_INTERVAL, FALSE, FALSE);
 101         }
 102         else
 103         {
 104                 SETTING_TRACE_ERROR("setting vconf value failed : screen_lock_type");
 105         }
 106         return 0;
 107 }
 108
 109 static struct _locktype_item locktype_table[] = {
 110         { SETTING_LOCKTYPE_PW_PASSWORD,                 "SETTING_PW_TYPE_SET_PASSWORD",                         pwd_handler_sec_pw_passwd },
 111         { SETTING_LOCKTYPE_PW_SIMPLE_PASSWD,    "SETTING_PW_TYPE_SET_SIMPLE_PASSWORD",          pwd_handler_sec_pw_simple_passwd },
 112         { SETTING_LOCKTYPE_PW_CHANGE_PASSWD,    "SETTING_PW_TYPE_SET_PASSWORD",                 pwd_handler_sec_pw_passwd },
 113         { SETTING_LOCKTYPE_PW_CHANGE_SIMPLE_PASSWD,     "SETTING_PW_TYPE_SET_SIMPLE_PASSWORD",          pwd_handler_sec_pw_simple_passwd },
 114         /*------------------------------------------------------------------------------------------------------------*/
 115         { SETTING_LOCKTYPE_PW_MAX,                              NULL,                                                                   pwd_handler_do_nothing}
 116 };
 117
 118 static void setting_locktype_ug_cb_resize(void *data, Evas *e,
 119                                           Evas_Object *obj, void *event_info)
 120 {
 121         ret_if(data == NULL);
 122
 123         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;     /* ad is point to data */
 124         setting_view_update(&setting_view_locktype_main, ad);
 125 }
 126
 127 static void *setting_locktype_ug_on_create(ui_gadget_h ug,
 128                                            enum ug_mode mode, app_control_h service,
 129                                            void *priv)
 130 {
 131         setting_retvm_if((!priv), NULL, "!priv");
 132
 133         SettingLocktypeUG *locktypeUG = priv;
 134         locktypeUG->ug = ug;
 135
 136         locktypeUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 137         locktypeUG->win_get = (Evas_Object *) ug_get_window();
 138         evas_object_show(locktypeUG->win_main_layout);
 139         locktypeUG->evas = evas_object_evas_get(locktypeUG->win_main_layout);
 140
 141         setting_retvm_if(locktypeUG->win_main_layout == NULL, NULL,
 142                          "[Setting >> About] cannot get main window ");
 143
 144         //setting_set_i18n(SETTING_PACKAGE, SETTING_LOCALEDIR);
 145         bindtextdomain(SETTING_PACKAGE, SETTING_LOCALEDIR);
 146
 147         /* register view node table */
 148         setting_view_node_table_intialize();
 149         setting_view_node_table_register(&setting_view_locktype_main, NULL);
 150
 151         setting_create_Gendial_itc("dialogue/1text", &(locktypeUG->itc_1text));
 152         setting_create_Gendial_itc("multiline/1text", &(locktypeUG->itc_bg_1icon));
 153         setting_create_Gendial_itc("dialogue/2text.3", &(locktypeUG->itc_2text_2));
 154         setting_create_Gendial_itc("dialogue/1text.1icon", &(locktypeUG->itc_1text_1icon));
 155         setting_create_Gendial_itc("dialogue/title", &(locktypeUG->itc_group_item));
 156         setting_create_Gendial_itc("dialogue/2text.3/expandable",&(locktypeUG->itc_2text_3_parent));
 157
 158
 159         locktypeUG->input_pwd = NULL;
 160         locktypeUG->notify = NULL;
 161
 162         app_control_get_extra_data(service, "current", &(locktypeUG->input_pwd));
 163         app_control_get_extra_data(service, "caller", &(locktypeUG->caller));
 164         if(locktypeUG->caller && !safeStrCmp(locktypeUG->caller, "encryption"))
 165         {
 166                 locktypeUG->viewtype = SETTING_LOCKTYPE_VIEWTYPE_ENCRYPTION;
 167         }
 168         else if(locktypeUG->caller && !safeStrCmp(locktypeUG->caller, "lockscreen"))
 169         {
 170                 locktypeUG->viewtype = SETTING_LOCKTYPE_VIEWTYPE_RECOVERY;
 171                 vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_SWIPE);
 172                 int result = security_server_reset_pwd("0000", 0, 0);
 173                 SETTING_TRACE_DEBUG("reset_pwd result : %d", result);
 174         }
 175         else
 176         {
 177                 locktypeUG->viewtype = SETTING_LOCKTYPE_VIEWTYPE_MAIN;
 178         }
 179         FREE(locktypeUG->caller);
 180
 181         setting_view_node_set_cur_view(&setting_view_locktype_main);
 182         setting_view_create(&setting_view_locktype_main, (void *)locktypeUG);
 183         evas_object_event_callback_add(locktypeUG->win_main_layout,
 184                                        EVAS_CALLBACK_RESIZE,
 185                                        setting_locktype_ug_cb_resize, locktypeUG);
 186
 187         return locktypeUG->ly_main;
 188 }
 189
 190 static void setting_locktype_ug_on_start(ui_gadget_h ug, app_control_h service,
 191                                          void *priv)
 192 {
 193 }
 194
 195 static void setting_locktype_ug_on_pause(ui_gadget_h ug, app_control_h service,
 196                                          void *priv)
 197 {
 198 }
 199
 200 static void setting_locktype_ug_on_resume(ui_gadget_h ug, app_control_h service,
 201                                           void *priv)
 202 {
 203 }
 204
 205 static void setting_locktype_ug_on_destroy(ui_gadget_h ug, app_control_h service,
 206                                            void *priv)
 207 {
 208         SETTING_TRACE_BEGIN;
 209         setting_retm_if((!priv), "!priv");
 210         SettingLocktypeUG *locktypeUG = priv;
 211         locktypeUG->ug = ug;
 212
 213         evas_object_event_callback_del(locktypeUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_locktype_ug_cb_resize);       /* fix flash issue for gallery */
 214
 215         if(locktypeUG->save_popup)
 216         {
 217                 evas_object_del(locktypeUG->save_popup);
 218                 locktypeUG->save_popup = NULL;
 219         }
 220
 221         setting_view_destroy(&setting_view_locktype_main, locktypeUG);
 222
 223         FREE(locktypeUG->input_pwd);
 224
 225         if (NULL != ug_get_layout(locktypeUG->ug)) {
 226                 evas_object_hide((Evas_Object *) ug_get_layout(locktypeUG->ug));
 227                 evas_object_del((Evas_Object *) ug_get_layout(locktypeUG->ug));
 228         }
 229
 230         SETTING_TRACE_END;
 231 }
 232
 233 static void setting_locktype_ug_on_message(ui_gadget_h ug, app_control_h msg,
 234                                            app_control_h service, void *priv)
 235 {
 236
 237 }
 238
 239 static void setting_locktype_ug_on_event(ui_gadget_h ug,
 240                                          enum ug_event event, app_control_h service,
 241                                          void *priv)
 242 {
 243         switch (event) {
 244         case UG_EVENT_LOW_MEMORY:
 245                 break;
 246         case UG_EVENT_LOW_BATTERY:
 247                 break;
 248         case UG_EVENT_LANG_CHANGE:
 249                 break;
 250         case UG_EVENT_ROTATE_PORTRAIT:
 251                 break;
 252         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 253                 break;
 254         case UG_EVENT_ROTATE_LANDSCAPE:
 255                 break;
 256         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 257                 break;
 258         case UG_EVENT_REGION_CHANGE:
 259                 break;
 260         default:
 261                 break;
 262         }
 263 }
 264
 265 static void setting_locktype_ug_on_key_event(ui_gadget_h ug,
 266                                              enum ug_key_event event,
 267                                              app_control_h service, void *priv)
 268 {
 269         if (!priv)
 270                 return;
 271         SettingLocktypeUG *ad = (SettingLocktypeUG *) priv;     /* ad is point to priv */
 272         switch (event) {
 273         case UG_KEY_EVENT_END:
 274                 {
 275                         if (elm_naviframe_top_item_get(ad->navi_bar) ==
 276                            elm_naviframe_bottom_item_get(ad->navi_bar)) {
 277                                 ug_destroy_me(ug);
 278                         } else {
 279                                 /* elm_naviframe_item_pop(ad->navi_bar); */
 280                                 setting_view_cb_at_endKey(ad);
 281                         }
 282                 }
 283                 break;
 284
 285         default:
 286                 break;
 287         }
 288 }
 289
 290 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 291 {
 292         SettingLocktypeUG *locktypeUG = calloc(1, sizeof(SettingLocktypeUG));
 293         setting_retvm_if(!locktypeUG, -1,
 294                          "Create SettingLocktypeUG obj failed");
 295
 296         memset(locktypeUG, 0x00, sizeof(SettingLocktypeUG));
 297
 298         ops->create = setting_locktype_ug_on_create;
 299         ops->start = setting_locktype_ug_on_start;
 300         ops->pause = setting_locktype_ug_on_pause;
 301         ops->resume = setting_locktype_ug_on_resume;
 302         ops->destroy = setting_locktype_ug_on_destroy;
 303         ops->message = setting_locktype_ug_on_message;
 304         ops->event = setting_locktype_ug_on_event;
 305         ops->key_event = setting_locktype_ug_on_key_event;
 306         ops->priv = locktypeUG;
 307         ops->opt = UG_OPT_INDICATOR_ENABLE;
 308
 309         return 0;
 310 }
 311
 312 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 313 {
 314         struct SettingLocktypeUG *locktypeUG;
 315         setting_retm_if(!ops, "ops == NULL");
 316
 317         locktypeUG = ops->priv;
 318         if (locktypeUG)
 319                 FREE(locktypeUG);
 320 }
 321
 322 /* ***************************************************
 323  *
 324  *general func
 325  *
 326  ***************************************************/
 327
 328 void setting_locktype_layout_passwd_ug_cb(ui_gadget_h ug,
 329                                                  enum ug_mode mode, void *priv)
 330 {
 331         if (!priv)
 332                 return;
 333
 334         Evas_Object *base = ug_get_layout(ug);
 335         if (!base)
 336                 return;
 337
 338         switch (mode) {
 339         case UG_MODE_FULLVIEW:
 340                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 341                                                  EVAS_HINT_EXPAND);
 342                 evas_object_show(base);
 343                 break;
 344         default:
 345                 break;
 346         }
 347
 348         return;
 349 }
 350
 351 void setting_locktype_destroy_password_ug_cb(ui_gadget_h ug,
 352                                                     void *priv)
 353 {
 354         SETTING_TRACE_BEGIN;
 355         ret_if(priv == NULL);
 356         SettingLocktypeUG *ad = (SettingLocktypeUG *) priv;
 357
 358         if(ad->ly_main)
 359                 elm_object_tree_focus_allow_set(ad->ly_main, EINA_TRUE);
 360         if (ug) {
 361                 ug_destroy(ug);
 362         }
 363 }
 364
 365 void setting_locktype_end_password_ug_cb(ui_gadget_h ug,
 366                                                     void *priv)
 367 {
 368         SETTING_TRACE_BEGIN;
 369         ret_if(priv == NULL);
 370         SettingLocktypeUG *ad = (SettingLocktypeUG *) priv;
 371         ad->ug_passwd = NULL;
 372 }
 373
 374 gboolean setting_locktype_create_password_sg(void *data)
 375 {
 376         SETTING_TRACE_BEGIN;
 377         /* error check */
 378         retv_if(data == NULL, FALSE);
 379
 380         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;     /* ad is point to data */
 381
 382         /* prevent the ug from being loaded again due to window event queuing */
 383         /* added by JTS: CQ H0100135346 */
 384         if (ad->ug_passwd) {
 385                 SETTING_TRACE("Password UG is already loaded.");
 386                 return FALSE;
 387         }
 388
 389         if((ad->pw_type < 0) || (ad->pw_type > SETTING_LOCKTYPE_PW_MAX))
 390                 return FALSE;
 391
 392         char str[Max_Passwd_View_Type_Len + 1] = { 0, };
 393         safeCopyStr(str, locktype_table[ad->pw_type].pw_type_string, Max_Passwd_View_Type_Len);
 394
 395         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 396
 397         if (!cbs)
 398                 return FALSE;
 399         cbs->layout_cb = setting_locktype_layout_passwd_ug_cb;
 400         cbs->result_cb = setting_locktype_result_password_ug_cb;
 401         cbs->destroy_cb = setting_locktype_destroy_password_ug_cb;
 402         cbs->end_cb = setting_locktype_end_password_ug_cb;
 403         cbs->priv = (void *)ad;
 404
 405         app_control_h svc;
 406         if (app_control_create(&svc)) {
 407                 FREE(cbs);
 408                 return FALSE;
 409         }
 410
 411         app_control_add_extra_data(svc, "viewtype", str);
 412         if(ad->viewtype == SETTING_LOCKTYPE_VIEWTYPE_ENCRYPTION)
 413                 app_control_add_extra_data(svc, "encryption", "TRUE");
 414
 415         if(ad->input_pwd)
 416                 app_control_add_extra_data(svc, "current", ad->input_pwd);
 417
 418         elm_object_tree_focus_allow_set(ad->ly_main, EINA_FALSE);
 419         ad->ug_passwd = setting_ug_create(ad->ug, "setting-password-efl", UG_MODE_FULLVIEW, svc, cbs);
 420         if (NULL == ad->ug_passwd) {    /* error handling */
 421                 evas_object_show(ad->ly_main);
 422         }
 423
 424         app_control_destroy(svc);
 425         FREE(cbs);
 426
 427         return TRUE;
 428 }
 429
 430 /* ***************************************************
 431  *
 432  *call back func
 433  *
 434  ***************************************************/
 435 // -1   on fail
 436 // 0~n  on success
 437 int _get_locktype_table_index(char* name)
 438 {
 439         int i=0;
 440
 441         for(i=0;i<SETTING_LOCKTYPE_PW_MAX;i++)
 442         {
 443                 if (0 == safeStrCmp(name, locktype_table[i].pw_type_string))
 444                         return i;
 445         }
 446         return -1;
 447 }
 448
 449 void
 450 setting_locktype_result_password_ug_cb(ui_gadget_h ug, app_control_h service,
 451                                        void *priv)
 452 {
 453         SETTING_TRACE_BEGIN;
 454         /* error check */
 455         retm_if(priv == NULL, "Data paremeter is NULL");
 456
 457         SettingLocktypeUG *ad = (SettingLocktypeUG *) priv;     /* ad is point to priv */
 458
 459         char *result = NULL;
 460
 461         app_control_get_extra_data(service, "result", &result);
 462
 463         /* divided pw view type */
 464         SETTING_TRACE("ad->pw_type: %d result :%s", ad->pw_type, result);
 465         ret_if(NULL == result);
 466
 467         if(safeStrCmp(result, "Cancel"))
 468         {
 469                 int index =  _get_locktype_table_index(result);
 470
 471                 if (index != -1)
 472                 {
 473                         locktype_table[index].passwd_handler(ad, NULL);
 474                         ad->pw_type = locktype_table[index].pw_type_num;
 475                 } else {
 476                         SETTING_TRACE_ERROR("no table entry");
 477                 }
 478         }
 479
 480         evas_object_show(ad->ly_main);
 481         FREE(result);
 482         SETTING_TRACE_END;
 483 }
 484