setting-locktype/src/setting-locktype-main.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <setting-common-data-type.h>
  22 #include <setting-common-data-slp-setting.h>
  23 #include <setting-common-draw-widget.h>
  24 #include <setting-common-view.h>
  25
  26 #include <setting-locktype-main.h>
  27 #include <security-server.h>
  28 #include <pkgmgr-info.h>
  29 #include <ail.h>
  30 #include <efl_assist.h>
  31 #if SUPPORT_ENCRYPTION
  32 #include <ode.h>
  33 #endif
  34 #if SUPPORT_LIBEAS
  35 #include <eas-svc.h>
  36 #endif
  37
  38 #if SUPPORT_FINGERPRINT
  39 #include <fingerprint_manager.h>
  40 #endif
  41
  42 #define TBD 0
  43
  44 static int setting_locktype_main_create(void *cb);
  45 static int setting_locktype_main_destroy(void *cb);
  46 static int setting_locktype_main_update(void *cb);
  47 static int setting_locktype_main_cleanup(void *cb);
  48 static void __record_btn_click_cb(void *data, Evas_Object *obj, void *event_info);
  49 setting_view setting_view_locktype_main = {
  50         .create = setting_locktype_main_create,
  51         .destroy = setting_locktype_main_destroy,
  52         .update = setting_locktype_main_update,
  53         .cleanup = setting_locktype_main_cleanup,
  54 };
  55
  56 openlock_appdata *lockapp_data = NULL;
  57
  58 /* ***************************************************
  59  **
  60  **basic func
  61  **
  62  ****************************************************/
  63
  64 static int __get_lockapp_index_from_appname(char *app_name)
  65 {
  66         SETTING_TRACE_BEGIN;
  67         if(app_name == NULL)
  68                 return SETTING_RETURN_FAIL;
  69
  70         openlock_appdata *item = lockapp_data;
  71         for(; item != NULL; item = item->next)
  72         {
  73                 if(safeStrCmp(item->app_name, app_name) == 0)
  74                         return item->index;
  75         }
  76         return SETTING_RETURN_FAIL;
  77 }
  78 static char* __get_lockapp_pkgname_from_appname(char *app_name)
  79 {
  80         SETTING_TRACE_BEGIN;
  81         if(app_name == NULL)
  82                 return NULL;
  83
  84         openlock_appdata *item = lockapp_data;
  85         for(; item != NULL; item = item->next)
  86         {
  87                 if(safeStrCmp(item->app_name, app_name) == 0)
  88                         return item->pkg_name;
  89         }
  90         return NULL;
  91 }
  92
  93 int __get_appinfo_cb(pkgmgrinfo_appinfo_h appinfo, void *user_data)
  94 {
  95         SETTING_TRACE_BEGIN;
  96         if(!appinfo)
  97         {
  98                 SETTING_TRACE_DEBUG("handle is NULL");
  99                 return -1;
 100         }
 101
 102         openlock_appdata *item = lockapp_data;
 103         openlock_appdata *new_item = NULL;
 104         char *app_name = NULL;
 105         char *app_id = NULL;
 106         ail_appinfo_h handle;
 107         int ret = 0;
 108
 109         ret = pkgmgrinfo_appinfo_get_appid(appinfo, &app_id);
 110         if(ret != 0)
 111         {
 112                 SETTING_TRACE_DEBUG("pkgmgrinfo_appinfo_get_appid() returns error");
 113                 return -1;
 114         }
 115
 116         if(!app_id)
 117         {
 118                 SETTING_TRACE_DEBUG("app_id is NULL");
 119                 return -1;
 120         }
 121
 122         SETTING_TRACE_DEBUG("app_id %s", app_id);
 123
 124         ret = ail_get_appinfo(app_id, &handle);
 125         if(ret != AIL_ERROR_OK)
 126         {
 127                 SETTING_TRACE_DEBUG("ail_get_appinfo() returns error");
 128                 return -1;
 129         }
 130
 131         ail_appinfo_get_str(handle, AIL_PROP_NAME_STR, &app_name);
 132         if(!app_name)
 133         {
 134                 SETTING_TRACE_DEBUG("ail_appinfo_get_str() returns error");
 135                 ail_destroy_appinfo(handle);
 136                 return -1;
 137         }
 138
 139         SETTING_TRACE_DEBUG("app_name %s", app_name);
 140
 141         while(item->next != NULL)
 142                 item = item->next;
 143
 144         if(item->index == 0 && item->pkg_name == NULL)
 145         {
 146                 SETTING_TRACE_DEBUG("first app");
 147                 /* first app */
 148                 item->pkg_name = (char*)strdup(app_id);
 149                 item->app_name = (char*)strdup(app_name);
 150
 151                 if(app_id && app_name)
 152                         SETTING_TRACE_DEBUG("app info %d %s %s", item->index, item->pkg_name, item->app_name);
 153         }
 154         else
 155         {
 156                 SETTING_TRACE_DEBUG("create new");
 157                 /* create new */
 158                 new_item = (openlock_appdata*)malloc(sizeof(openlock_appdata));
 159                 if(new_item != NULL)
 160                 {
 161                         memset(new_item, 0x00, sizeof(openlock_appdata));
 162                         new_item->pkg_name = (char*)strdup(app_id);
 163                         new_item->app_name = (char*)strdup(app_name);
 164                         new_item->index = item->index + 1;
 165                         new_item->prev = item;
 166                         item->next = new_item;
 167
 168                         if(app_id && app_name)
 169                                 SETTING_TRACE_DEBUG("app info %d %s %s", new_item->index, new_item->pkg_name, new_item->app_name);
 170                 }
 171                 else
 172                 {
 173                         SETTING_TRACE_DEBUG("malloc() failed");
 174                 }
 175         }
 176         //FREE(app_id);
 177         //FREE(app_name);
 178         SETTING_TRACE_END;
 179         return 0;
 180 }
 181
 182 static int __add_3rd_party_lock(void *data)
 183 {
 184         SETTING_TRACE_BEGIN;
 185         retv_if(data == NULL, -1);
 186
 187         int ret_index = -1;
 188         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;
 189
 190         /* Get info from AIL */
 191         pkgmgrinfo_appinfo_filter_h filter = NULL;
 192         int ret = 0;
 193         int count = -1;
 194
 195         ret = pkgmgrinfo_appinfo_filter_create(&filter);
 196         if(ret > 0)
 197         {
 198                 SETTING_TRACE_DEBUG("pkgmgrinfo_appinfo_filter_create() failed");
 199                 return ret_index;
 200         }
 201         ret = pkgmgrinfo_appinfo_filter_add_string(filter, PMINFO_APPINFO_PROP_APP_CATEGORY, "http://tizen.org/category/lockapp");
 202         ret = pkgmgrinfo_appinfo_filter_count(filter, &count);
 203         SETTING_TRACE_DEBUG("There is/are %d 3rd lock app(s)", count);
 204         if(count <= 0)
 205         {
 206                 SETTING_TRACE_DEBUG("No 3rd lock app");
 207                 pkgmgrinfo_appinfo_filter_destroy(filter);
 208                 filter = NULL;
 209                 return ret_index;
 210         }
 211
 212         // delete if already exist.
 213         if(lockapp_data)
 214         {
 215                 openlock_appdata *list = lockapp_data;
 216                 while(list != NULL)
 217                 {
 218                         openlock_appdata *cur = list;
 219                         FREE(list->app_name);
 220                         FREE(list->pkg_name);
 221                         list = list->next;
 222                         FREE(cur);
 223                 }
 224                 lockapp_data = NULL;
 225         }
 226
 227         lockapp_data = (openlock_appdata*)malloc(sizeof(openlock_appdata));
 228         if(lockapp_data == NULL)
 229         {
 230                 SETTING_TRACE_DEBUG("malloc() failed");
 231                 FREE(filter);
 232                 return ret_index;
 233         }
 234         memset(lockapp_data, 0x00, sizeof(openlock_appdata));
 235         lockapp_data->prev = NULL;
 236         lockapp_data->next = NULL;
 237         lockapp_data->pkg_name = NULL;
 238         lockapp_data->app_name = NULL;
 239         lockapp_data->index = 0;
 240
 241         ret = pkgmgrinfo_appinfo_filter_foreach_appinfo(filter, __get_appinfo_cb, NULL);
 242         SETTING_TRACE("ret:%d", ret);
 243         pkgmgrinfo_appinfo_filter_destroy(filter);
 244         filter = NULL;
 245
 246         /* Add to genlist */
 247         openlock_appdata *list = lockapp_data;
 248         int index = 0;
 249         for(index = 0; index < count; index++)
 250         {
 251                 ad->data_locktype_3rd[index] = setting_create_Gendial_field_1radio(ad->genlist,
 252                                                 &(itc_1text_1icon_3),
 253                                                 setting_locktype_main_mouse_up_Gendial_list_cb, /*add to sel_cb */
 254                                                 ad,     /* sel data */
 255                                                 SWALLOW_Type_1RADIO,
 256                                                 ad->lock_type_rd, SETTING_SCREEN_LOCK_TYPE_OTHER + index,
 257                                                 list->app_name,
 258                                                 NULL);
 259                 if (ad->data_locktype_3rd[index]) {
 260                         ad->data_locktype_3rd[index]->userdata = ad;
 261                 } else {
 262                         SETTING_TRACE_ERROR("item_data is NULL");
 263                 }
 264
 265                 char *open_lock_name = NULL;
 266                 open_lock_name = vconf_get_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR);
 267                 if(safeStrCmp(open_lock_name, list->app_name) == 0)
 268                         ret_index = index;
 269                 FREE(open_lock_name);
 270
 271                 list = list->next;
 272         }
 273         SETTING_TRACE_END;
 274         FREE(filter);
 275         return ret_index;
 276 }
 277
 278 static void __change_simple_password_cb(void *data, Evas_Object *obj, void *event_info)
 279 {
 280         retm_if(data == NULL, "Data parameter is NULL");
 281         Setting_GenGroupItem_Data *list_item =
 282             (Setting_GenGroupItem_Data *) data;
 283         /*  for update */
 284
 285         SettingLocktypeUG *ad = (SettingLocktypeUG *)list_item->userdata;
 286         if(ad == NULL)
 287                 return;
 288
 289         ad->pw_type = SETTING_LOCKTYPE_PW_CHANGE_SIMPLE_PASSWD;
 290         setting_locktype_create_password_sg(ad);
 291 }
 292
 293 static void __change_password_cb(void *data, Evas_Object *obj, void *event_info)
 294 {
 295         retm_if(data == NULL, "Data parameter is NULL");
 296         Setting_GenGroupItem_Data *list_item =
 297             (Setting_GenGroupItem_Data *) data;
 298         /*  for update */
 299
 300         SettingLocktypeUG *ad = (SettingLocktypeUG *)list_item->userdata;
 301         if(ad == NULL)
 302                 return;
 303
 304         ad->pw_type = SETTING_LOCKTYPE_PW_CHANGE_PASSWD;
 305         setting_locktype_create_password_sg(ad);
 306 }
 307
 308 void __add_locktype_items(void *data)
 309 {
 310         SETTING_TRACE_BEGIN;
 311         ret_if(data == NULL);
 312
 313         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;
 314
 315         Elm_Object_Item *item = NULL;
 316         Evas_Object *radio;
 317
 318         int index = -1;
 319         int locktype = 0;
 320         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &locktype);
 321         SETTING_TRACE("locktype is %d", locktype);
 322
 323         radio = elm_radio_add(ad->genlist);
 324         if(radio)
 325         {
 326                 elm_radio_state_value_set(radio, -1);
 327                 ad->lock_type_rd = radio;
 328         }
 329         /* separator */
 330         ADD_GL_SEPARATOR(ad->genlist)
 331
 332         evas_object_smart_callback_add(ad->genlist, "realized", __gl_realized_cb, NULL);
 333
 334         /* to do : radio menu */
 335         /* 0) None */
 336         if(!isEmulBin())
 337         {
 338                 ad->data_locktype_none =
 339                         setting_create_Gendial_field_1radio(ad->genlist,
 340                                                 &(itc_1text_1icon_3),
 341                                                 setting_locktype_main_mouse_up_Gendial_list_cb, /*add to sel_cb */
 342                                                 ad,     /* sel data */
 343                                                 SWALLOW_Type_1RADIO,
 344                                                 radio, SETTING_SCREEN_LOCK_TYPE_NONE,
 345                                                 "IDS_ST_BODY_NONE",
 346                                                 setting_locktype_main_click_radio_cb);
 347                 if (ad->data_locktype_none) {
 348                         ad->data_locktype_none->userdata = ad;
 349                         ad->data_locktype_none->group_style = SETTING_GROUP_STYLE_TOP;
 350                 } else {
 351                         SETTING_TRACE_ERROR("item_data is NULL");
 352                 }
 353         }
 354
 355         /* 1) swipe */
 356         ad->data_locktype_swipe =
 357                         setting_create_Gendial_field_1radio(ad->genlist,
 358                                                 &(itc_1text_1icon_3),
 359                                                 setting_locktype_main_mouse_up_Gendial_list_cb, /*add to sel_cb */
 360                                                 ad,     /* sel data */
 361                                                 SWALLOW_Type_1RADIO,
 362                                                 radio, SETTING_SCREEN_LOCK_TYPE_SWIPE,
 363                                                 Keystr_Swipe,
 364                                                 setting_locktype_main_click_radio_cb);
 365         if (ad->data_locktype_swipe) {
 366                 ad->data_locktype_swipe->userdata = ad;
 367                 ad->data_locktype_swipe->group_style = SETTING_GROUP_STYLE_CENTER;
 368         } else {
 369                 SETTING_TRACE_ERROR("item_data is NULL");
 370         }
 371
 372         if(!isEmulBin())
 373         {
 374                 /* 4) simple password */
 375                 if(locktype == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 376                 {
 377                         ad->data_locktype_simple =
 378                                 setting_create_Gendial_field_1radio_1button(ad->genlist,
 379                                                 &(itc_1text_2icon_2),
 380                                                 setting_locktype_main_mouse_up_Gendial_list_cb, /*add to sel_cb */
 381                                                 ad,     /* sel data */
 382                                                 SWALLOW_Type_1RADIO_1BTN,
 383                                                 "option", /* button style */
 384                                                 radio, SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD,
 385                                                 "IDS_ST_BODY_SIMPLE_PASSWORD",
 386                                                 setting_locktype_main_click_radio_cb,   /* radio callback */
 387                                                 __change_simple_password_cb);   /* button callback */
 388                 }
 389                 else
 390                 {
 391                         ad->data_locktype_simple =
 392                                 setting_create_Gendial_field_1radio(ad->genlist,
 393                                                 &(itc_1text_1icon_3),
 394                                                 setting_locktype_main_mouse_up_Gendial_list_cb, /*add to sel_cb */
 395                                                 ad,     /* sel data */
 396                                                 SWALLOW_Type_1RADIO,
 397                                                 radio, SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD,
 398                                                 "IDS_ST_BODY_SIMPLE_PASSWORD",
 399                                                 setting_locktype_main_click_radio_cb);
 400
 401                 }
 402                 if (ad->data_locktype_simple) {
 403                         ad->data_locktype_simple->userdata = ad;
 404                         ad->data_locktype_simple->group_style = SETTING_GROUP_STYLE_CENTER;
 405                 } else {
 406                         SETTING_TRACE_ERROR("item_data is NULL");
 407                 }
 408
 409                 /* 5) password */
 410                 if(locktype == SETTING_SCREEN_LOCK_TYPE_PASSWORD)
 411                 {
 412                         ad->data_locktype_password =
 413                                 setting_create_Gendial_field_1radio_1button(ad->genlist,
 414                                                 &(itc_1text_2icon_2),
 415                                                 setting_locktype_main_mouse_up_Gendial_list_cb, /*add to sel_cb */
 416                                                 ad,     /* sel data */
 417                                                 SWALLOW_Type_1RADIO_1BTN,
 418                                                 "option", /* button style */
 419                                                 radio, SETTING_SCREEN_LOCK_TYPE_PASSWORD,
 420                                                 "IDS_ST_BODY_PASSWORD",
 421                                                 setting_locktype_main_click_radio_cb,   /* radio callback */
 422                                                 __change_password_cb);  /* button callback */
 423                 }
 424                 else
 425                 {
 426                         ad->data_locktype_password =
 427                                 setting_create_Gendial_field_1radio(ad->genlist,
 428                                                 &(itc_1text_1icon_3),
 429                                                 setting_locktype_main_mouse_up_Gendial_list_cb, /*add to sel_cb */
 430                                                 ad,     /* sel data */
 431                                                 SWALLOW_Type_1RADIO,
 432                                                 radio, SETTING_SCREEN_LOCK_TYPE_PASSWORD,
 433                                                 "IDS_ST_BODY_PASSWORD",
 434                                                 setting_locktype_main_click_radio_cb);
 435                 }
 436                 if (ad->data_locktype_password) {
 437                         ad->data_locktype_password->userdata = ad;
 438                         ad->data_locktype_password->group_style = SETTING_GROUP_STYLE_BOTTOM;
 439                 } else {
 440                         SETTING_TRACE_ERROR("item_data is NULL");
 441                 }
 442         }
 443
 444         /* Add 3rd party lock apps in list. */
 445         index = __add_3rd_party_lock(ad);
 446         /* End */
 447
 448         if(index < 0)
 449                 elm_radio_value_set(radio, locktype);
 450         else
 451                 elm_radio_value_set(radio, locktype + index);
 452
 453         SETTING_TRACE_END;
 454 }
 455
 456
 457 static void __lock_type_key_changed_cb(keynode_t *key, void *data)
 458 {
 459         ret_if(data == NULL);
 460
 461         SettingLocktypeUG *ad = data;
 462
 463         char *vconf_name = vconf_keynode_get_name(key);
 464
 465         if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT)) {
 466                 //status = vconf_keynode_get_int(key);
 467                 if(ad->ug_passwd)
 468                 {
 469                         ad->ug_is_destroying = TRUE;
 470                         setting_ug_destroy(ad->ug_passwd);
 471                 }
 472
 473                 if(ad->genlist)
 474                 {
 475                         elm_genlist_clear(ad->genlist);
 476                         __add_locktype_items(ad);
 477                 }
 478         }
 479         //ug_destroy_me(ad->ug);
 480 }
 481
 482
 483 static int setting_locktype_main_create(void *cb)
 484 {
 485         SETTING_TRACE_BEGIN;
 486         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 487
 488         SettingLocktypeUG *ad = (SettingLocktypeUG *) cb;
 489
 490         /* add basic layout */
 491
 492         Evas_Object *scroller = NULL;
 493         ad->ly_main = setting_create_layout_navi_bar_genlist(ad->win_main_layout,
 494                                                            ad->win_get,
 495                                                            "IDS_ST_BODY_SCREEN_LOCK_TYPE",
 496                                                            _("IDS_COM_BODY_BACK"),
 497                                                            NULL,
 498                                                            (setting_call_back_func)setting_locktype_main_click_softkey_back_cb,
 499                                                            NULL, ad, &scroller,
 500                                                            &(ad->navi_bar));
 501         ad->screen_lock_main_item = elm_naviframe_top_item_get(ad->navi_bar);
 502
 503         ad->genlist = scroller;
 504
 505         __add_locktype_items(ad);
 506
 507         vconf_notify_key_changed(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, __lock_type_key_changed_cb, ad);
 508
 509         setting_view_locktype_main.is_create = 1;
 510         return SETTING_RETURN_SUCCESS;
 511 }
 512
 513 static int setting_locktype_main_destroy(void *cb)
 514 {
 515         SETTING_TRACE_BEGIN;
 516         /* error check */
 517         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 518
 519         SettingLocktypeUG *ad = (SettingLocktypeUG *) cb;
 520
 521         if (ad->notify)
 522         {
 523                 evas_object_del(ad->notify);
 524                 ad->notify = NULL;
 525         }
 526
 527         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, __lock_type_key_changed_cb);
 528
 529         evas_object_del(ad->ly_main);
 530         ad->screen_lock_main_item = NULL;
 531
 532         setting_view_locktype_main.is_create = 0;
 533
 534         return SETTING_RETURN_SUCCESS;
 535 }
 536
 537 static int setting_locktype_main_update(void *cb)
 538 {
 539         SETTING_TRACE_BEGIN;
 540         /* error check */
 541         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 542
 543         //__update_locktype_items_status(cb);
 544
 545         return SETTING_RETURN_SUCCESS;
 546 }
 547
 548 static int setting_locktype_main_cleanup(void *cb)
 549 {
 550         SETTING_TRACE_BEGIN;
 551         /* error check */
 552         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 553
 554         return SETTING_RETURN_SUCCESS;
 555 }
 556
 557 /* ***************************************************
 558  **
 559  **call back func
 560  **
 561  ****************************************************/
 562
 563 const char *motion_img[] = {
 564         SETTING_ICON_PATH_CFG "motions/unlock_illust_01.png",
 565         SETTING_ICON_PATH_CFG "motions/unlock_illust_02.png",
 566         NULL
 567 };
 568
 569 static void
 570 __motion_set_cb(void *data, Evas_Object *obj, void *event_info)
 571 {
 572         SETTING_TRACE_BEGIN;
 573         SETTING_TRACE("[HYEJIN] __motion_guild_ly_cb() start. ");
 574         /* error check */
 575         retm_if(data == NULL, "[Setting > Security] Data parameter is NULL");
 576         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;
 577
 578         elm_naviframe_item_pop(ad->navi_bar);
 579         ug_destroy_me(ad->ug);
 580 }
 581
 582 static void
 583 __motion_cancel_cb(void *data, Evas_Object *obj, void *event_info)
 584 {
 585         SETTING_TRACE_BEGIN;
 586         SETTING_TRACE("[HYEJIN] __motion_guild_ly_cb() start. ");
 587         /* error check */
 588         retm_if(data == NULL, "[Setting > Security] Data parameter is NULL");
 589         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;
 590
 591         elm_naviframe_item_pop(ad->navi_bar);
 592         ug_destroy_me(ad->ug);
 593 }
 594
 595
 596 static void
 597 setting_locktype_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
 598                                                void *event_info)
 599 {
 600         SETTING_TRACE_BEGIN;
 601         /* error check */
 602         setting_retm_if(data == NULL, "Data parameter is NULL");
 603
 604         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 605         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 606         elm_genlist_item_selected_set(item, 0);
 607         Setting_GenGroupItem_Data *list_item =
 608             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 609         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;
 610         int lock_type = list_item->chk_status;
 611         SETTING_TRACE("clicking item[%s - %d] ", _(list_item->keyStr), lock_type);
 612
 613         int old_type;
 614         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &old_type);
 615
 616         ad->selected_lock_type = list_item->keyStr;
 617
 618         /* If lock_type is same with old_lock_type, return. */
 619         if(lock_type == old_type)
 620         {
 621                 SETTING_TRACE_DEBUG("[Screen Lock Type] Selected same type");
 622                 return;
 623         }
 624
 625         int index = -1;
 626         char *pkg_name = NULL;
 627
 628         switch(lock_type)
 629         {
 630                 case SETTING_SCREEN_LOCK_TYPE_NONE:
 631                 case SETTING_SCREEN_LOCK_TYPE_SWIPE:
 632                         /* To do : Call security-server API. pw : 0000 */
 633                         if(old_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD
 634                                 || old_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD) {
 635                                 int result = security_server_set_pwd(ad->input_pwd, "0000", 0, 0);
 636                                 SETTING_TRACE_DEBUG("set_pwd result : %d", result);
 637
 638                                 uid_t user = 5000;
 639                                 #if 0
 640                                 int ckmc_ret = CKMC_ERROR_NONE;
 641                                 ckmc_ret = ckmc_change_user_password(user, ad->input_pwd, NULL);
 642                                 SETTING_TRACE("ckmc_change_user_password() returns %d", ckmc_ret);
 643                                 #endif
 644                         }
 645                         if(vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type) == 0)
 646                         {
 647                                 /* set radio */
 648                                 elm_radio_value_set(list_item->eo_check, lock_type);
 649                         }
 650                         //SETTING_TRACE_DEBUG("PASS #1");
 651                         ug_destroy_me(ad->ug);
 652                         break;
 653 #if 0
 654                 case SETTING_SCREEN_LOCK_TYPE_MOTION:
 655                         ad->old_type = old_type;
 656                         setting_create_guild_layout(ad->navi_bar,
 657                                      _(About_Motion_Unlock_Str),
 658                                      _("IDS_COM_SK_CANCEL"), _(SET_AS_LOCK_STR),NULL,
 659                                      __motion_cancel_cb, __motion_set_cb, NULL,
 660                                      _("IDS_LCKSCN_BODY_TAP_AND_HOLD_THE_SCREEN_THEN_TILT_THE_DEVICE_TOWARDS_YOU_TO_UNLOCK_IT_MSG"),
 661                                      (char**)motion_img,
 662                                      NULL,
 663                                      NULL,
 664                                      NULL,ad);
 665                         break;
 666 #endif
 667                 case SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD:
 668                         ad->pw_type = SETTING_LOCKTYPE_PW_SIMPLE_PASSWD;
 669                         if(old_type != SETTING_SCREEN_LOCK_TYPE_PASSWORD)
 670                         {
 671                                 FREE(ad->input_pwd);
 672                                 ad->input_pwd = (char*)strdup("0000");
 673                         }
 674                         setting_locktype_create_password_sg(ad);
 675                         break;
 676                 case SETTING_SCREEN_LOCK_TYPE_PASSWORD:
 677                         ad->pw_type = SETTING_LOCKTYPE_PW_PASSWORD;
 678                         if(old_type != SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 679                         {
 680                                 FREE(ad->input_pwd);
 681                                 ad->input_pwd = (char*)strdup("0000");
 682                         }
 683                         setting_locktype_create_password_sg(ad);
 684                         break;
 685                 case SETTING_SCREEN_LOCK_TYPE_OTHER:
 686                         if(old_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD
 687                                 || old_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD) {
 688                                 int result = security_server_set_pwd(ad->input_pwd, "0000", 0, 0);
 689                                 SETTING_TRACE_DEBUG("set_pwd result : %d", result);
 690                                 uid_t user = 5000;
 691                                 #if 0
 692                                 int ckmc_ret = CKMC_ERROR_NONE;
 693                                 ckmc_ret = ckmc_change_user_password(user, ad->input_pwd, NULL);
 694                                 SETTING_TRACE("ckmc_change_user_password() returns %d", ckmc_ret);
 695                                 #endif
 696                         }
 697                         index = __get_lockapp_index_from_appname(list_item->keyStr);
 698                         pkg_name = __get_lockapp_pkgname_from_appname(list_item->keyStr);
 699                         SETTING_TRACE_DEBUG("3rd lock selected. index[%d] pkg_name[%s]", index, pkg_name);
 700                         vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, pkg_name);
 701                         vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type);
 702                         /* set radio */
 703                         elm_radio_value_set(list_item->eo_check, lock_type + index);
 704                         ug_destroy_me(ad->ug);
 705                         break;
 706                 default:
 707                         break;
 708         }
 709 }
 710
 711 static void
 712 setting_locktype_main_click_radio_cb(void *data, Evas_Object *obj, void *event_info)
 713 {
 714         SETTING_TRACE_BEGIN;
 715         setting_retm_if(data == NULL, "Data parameter is NULL");
 716         Setting_GenGroupItem_Data *list_item =
 717             (Setting_GenGroupItem_Data *) data;
 718         SettingLocktypeUG *ad = list_item->userdata;
 719
 720         int lock_type = elm_radio_value_get(obj);
 721         int old_type = 0;
 722
 723         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &old_type);
 724
 725         if(old_type == lock_type)
 726                 return;
 727
 728         switch(lock_type)
 729         {
 730                 case SETTING_SCREEN_LOCK_TYPE_NONE:
 731                 case SETTING_SCREEN_LOCK_TYPE_SWIPE:
 732                         /* To do : Call security-server API. pw : 0000 */
 733                         if(old_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD
 734                                 || old_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD) {
 735                                 int result = security_server_set_pwd(ad->input_pwd, "0000", 0, 0);
 736                                 SETTING_TRACE_DEBUG("set_pwd result : %d", result);
 737                                 uid_t user = 5000;
 738                                 #if 0
 739                                 int ckmc_ret = CKMC_ERROR_NONE;
 740                                 ckmc_ret = ckmc_change_user_password(user, ad->input_pwd, NULL);
 741                                 SETTING_TRACE("ckmc_change_user_password() returns %d", ckmc_ret);
 742                                 #endif
 743                         }
 744                         vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type);
 745                         ug_destroy_me(ad->ug);
 746                         break;
 747 #if 0
 748                 case SETTING_SCREEN_LOCK_TYPE_MOTION:
 749                         ad->old_type = old_type;
 750                         elm_radio_value_set(obj, old_type);
 751                         setting_create_guild_layout(ad->navi_bar,
 752                                      _(About_Motion_Unlock_Str),
 753                                      _("IDS_COM_SK_CANCEL"), _(SET_AS_LOCK_STR), NULL,
 754                                      __motion_cancel_cb, __motion_set_cb, NULL,
 755                                      _("IDS_LCKSCN_BODY_TAP_AND_HOLD_THE_SCREEN_THEN_TILT_THE_DEVICE_TOWARDS_YOU_TO_UNLOCK_IT_MSG"),
 756                                      (char**)motion_img,
 757                                      NULL,
 758                                      NULL,
 759                                      NULL, ad);
 760                         break;
 761 #endif
 762                 case SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD:
 763                         elm_radio_value_set(obj, old_type);
 764                         ad->pw_type = SETTING_SEC_PW_SIMPLE_PASSWD;
 765                         if(old_type != SETTING_SCREEN_LOCK_TYPE_PASSWORD)
 766                         {
 767                                 FREE(ad->input_pwd);
 768                                 ad->input_pwd = (char*)strdup("0000");
 769                         }
 770                         setting_locktype_create_password_sg(ad);
 771                         break;
 772                 case SETTING_SCREEN_LOCK_TYPE_PASSWORD:
 773                         elm_radio_value_set(obj, old_type);
 774                         ad->pw_type = SETTING_SEC_PW_PASSWORD;
 775                         if(old_type != SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 776                         {
 777                                 FREE(ad->input_pwd);
 778                                 ad->input_pwd = (char*)strdup("0000");
 779                         }
 780                         setting_locktype_create_password_sg(ad);
 781                         break;
 782                 case SETTING_SCREEN_LOCK_TYPE_OTHER:
 783                 {
 784                         int index = -1;
 785                         char *pkg_name = NULL;
 786                         if(old_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD
 787                                 || old_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 788                         {
 789                                 int result = security_server_set_pwd(ad->input_pwd, "0000", 0, 0);
 790                                 SETTING_TRACE_DEBUG("set_pwd result : %d", result);
 791                                 uid_t user = 5000;
 792                                 #if 0
 793                                 int ckmc_ret = CKMC_ERROR_NONE;
 794                                 ckmc_ret = ckmc_change_user_password(user, ad->input_pwd, NULL);
 795                                 SETTING_TRACE("ckmc_change_user_password() returns %d", ckmc_ret);
 796                                 #endif
 797                         }
 798                         index = __get_lockapp_index_from_appname(list_item->keyStr);
 799                         pkg_name = __get_lockapp_pkgname_from_appname(list_item->keyStr);
 800                         SETTING_TRACE_DEBUG("3rd lock selected. index[%d] pkg_name[%s]", index, pkg_name);
 801                         vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, pkg_name);
 802                         vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type);
 803                         /* set radio */
 804                         elm_radio_value_set(list_item->eo_check, lock_type + index);
 805                         ug_destroy_me(ad->ug);
 806                 }
 807                         break;
 808                 default:
 809                         break;
 810         }
 811 }
 812
 813 Eina_Bool setting_locktype_main_click_softkey_back_cb(void *data, Elm_Object_Item *it)
 814 {
 815         SETTING_TRACE_BEGIN;
 816         /* error check */
 817         retvm_if(data == NULL, EINA_FALSE, "[Setting > Security] Data parameter is NULL");
 818
 819         SettingLocktypeUG *ad = (SettingLocktypeUG *) data;
 820         if(ad->ug_passwd)
 821         {
 822                 return EINA_FALSE;
 823         }
 824         /* Send destroy request */
 825         ug_destroy_me(ad->ug);
 826         SETTING_TRACE_END;
 827         return EINA_TRUE;
 828 }