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