setting-security/src/setting-security-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 #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-security-locktype.h>
  27 #include <setting-security.h>
  28 #include <setting-debug.h>
  29 #include <pkgmgr-info.h>
  30 #include <ail.h>
  31
  32 #define TBD 0
  33
  34 static int setting_security_locktype_create(void *cb);
  35 static int setting_security_locktype_destroy(void *cb);
  36 static int setting_security_locktype_update(void *cb);
  37 static int setting_security_locktype_cleanup(void *cb);
  38 setting_view setting_view_security_locktype = {
  39         .create = setting_security_locktype_create,
  40         .destroy = setting_security_locktype_destroy,
  41         .update = setting_security_locktype_update,
  42         .cleanup = setting_security_locktype_cleanup,
  43 };
  44
  45 openlock_appdata *lockapp_data = NULL;
  46
  47 /* ***************************************************
  48  **
  49  **basic func
  50  **
  51  ****************************************************/
  52
  53 static int __get_lockapp_index_from_pkgname(char *pkg_name)
  54 {
  55         SETTING_TRACE_BEGIN;
  56         if(pkg_name == NULL)
  57                 return SETTING_RETURN_FAIL;
  58
  59         openlock_appdata *item = lockapp_data;
  60         for(; item != NULL; item = item->next)
  61         {
  62                 if(safeStrCmp(item->pkg_name, pkg_name) == 0)
  63                         return item->index;
  64         }
  65         return SETTING_RETURN_FAIL;
  66 }
  67 static int __get_lockapp_index_from_appname(char *app_name)
  68 {
  69         SETTING_TRACE_BEGIN;
  70         if(app_name == NULL)
  71                 return SETTING_RETURN_FAIL;
  72
  73         openlock_appdata *item = lockapp_data;
  74         for(; item != NULL; item = item->next)
  75         {
  76                 if(safeStrCmp(item->app_name, app_name) == 0)
  77                         return item->index;
  78         }
  79         return SETTING_RETURN_FAIL;
  80 }
  81 static char* __get_lockapp_pkgname_from_appname(char *app_name)
  82 {
  83         SETTING_TRACE_BEGIN;
  84         if(app_name == NULL)
  85                 return NULL;
  86
  87         openlock_appdata *item = lockapp_data;
  88         for(; item != NULL; item = item->next)
  89         {
  90                 if(safeStrCmp(item->app_name, app_name) == 0)
  91                         //return item->app_name;
  92                         return item->pkg_name;
  93         }
  94         return NULL;
  95 }
  96
  97 int __get_appinfo_cb(pkgmgrinfo_appinfo_h appinfo, void *user_data)
  98 {
  99         SETTING_TRACE_BEGIN;
 100
 101         if(!appinfo)
 102         {
 103                 SETTING_TRACE_DEBUG("handle is NULL");
 104                 return -1;
 105         }
 106
 107         openlock_appdata *item = lockapp_data;
 108         openlock_appdata *new_item = NULL;
 109         char *app_name = NULL;
 110         char *app_id = NULL;
 111         ail_appinfo_h handle;
 112         int ret = 0;
 113
 114         ret = pkgmgrinfo_appinfo_get_appid(appinfo, &app_id);
 115         if(ret != 0 || !app_id)
 116         {
 117                 SETTING_TRACE_DEBUG("pkgmgrinfo_appinfo_get_appid returns error");
 118                 return -1;
 119         }
 120
 121         ret = ail_get_appinfo(app_id, &handle);
 122         if(ret != AIL_ERROR_OK)
 123         {
 124                 SETTING_TRACE_DEBUG("ail_get_appinfo() returns error");
 125                 return -1;
 126         }
 127         ail_appinfo_get_str(handle, AIL_PROP_NAME_STR, &app_name);
 128
 129         if(!app_name)
 130         {
 131                 SETTING_TRACE_DEBUG("ail_appinfo_get_str() returns error");
 132                 ail_destroy_appinfo(handle);
 133                 return -1;
 134         }
 135         SETTING_TRACE_DEBUG("app_name %s", app_name);
 136         SETTING_TRACE_DEBUG("app_id %s", app_id);// format : 1234567890.AppName
 137
 138
 139         while(item->next != NULL)
 140                 item = item->next;
 141
 142         if(item->index == 0 && item->pkg_name == NULL)
 143         {
 144                 SETTING_TRACE_DEBUG("first app");
 145                 /* first app */
 146                 item->app_name = (char*)strdup(app_name);               // for display
 147                 item->pkg_name = (char*)strdup(app_id);                 // for vconf
 148
 149                 if(!app_id && !app_name)
 150                         SETTING_TRACE_DEBUG("app info %d %s %s", item->index, item->pkg_name, item->app_name);
 151         }
 152         else
 153         {
 154                 SETTING_TRACE_DEBUG("create new");
 155                 /* create new */
 156                 new_item = (openlock_appdata*)malloc(sizeof(openlock_appdata));
 157                 if(new_item != NULL)
 158                 {
 159                         memset(new_item, 0x00, sizeof(openlock_appdata));
 160                         new_item->app_name = (char*)strdup(app_name);           // for display
 161                         new_item->pkg_name = (char*)strdup(app_id);                     // for vconf
 162                         new_item->index = item->index + 1;
 163                         new_item->prev = item;
 164                         item->next = new_item;
 165
 166                         if(!app_id && !app_name)
 167                                 SETTING_TRACE_DEBUG("app info %d %s %s", new_item->index, new_item->pkg_name, new_item->app_name);
 168                 }
 169                 else
 170                 {
 171                         SETTING_TRACE_DEBUG("malloc() failed");
 172                 }
 173         }
 174         return 0;
 175 }
 176
 177 static int __add_3rd_party_lock(void *data)
 178 {
 179         SETTING_TRACE_BEGIN;
 180         ret_if(data == NULL);
 181
 182         int ret_index = -1;
 183         SettingSecurityUG *ad = (SettingSecurityUG *) data;
 184
 185         /* Get info from AIL */
 186         pkgmgrinfo_appinfo_filter_h filter;
 187         int ret = 0;
 188         int count = -1;
 189
 190         ret = pkgmgrinfo_appinfo_filter_create(&filter);
 191         if(ret > 0)
 192         {
 193                 SETTING_TRACE_DEBUG("pkgmgrinfo_appinfo_filter_create() failed");
 194                 return;
 195         }
 196         ret = pkgmgrinfo_appinfo_filter_add_string(filter, PMINFO_APPINFO_PROP_APP_CATEGORY, "http://tizen.org/category/lockapp");
 197         ret = pkgmgrinfo_appinfo_filter_count(filter, &count);
 198         SETTING_TRACE_DEBUG("There is/are %d 3rd lock app(s)", count);
 199         if(count <= 0)
 200         {
 201                 SETTING_TRACE_DEBUG("No 3rd lock app");
 202                 pkgmgrinfo_appinfo_filter_destroy(filter);
 203                 return;
 204
 205         }
 206
 207         lockapp_data = (openlock_appdata*)malloc(sizeof(openlock_appdata));
 208         if(lockapp_data == NULL)
 209         {
 210                 SETTING_TRACE_DEBUG("malloc() failed");
 211                 return;
 212         }
 213         memset(lockapp_data, 0x00, sizeof(openlock_appdata));
 214         lockapp_data->prev = NULL;
 215         lockapp_data->next = NULL;
 216         lockapp_data->pkg_name = NULL;
 217         lockapp_data->app_name = NULL;
 218         lockapp_data->index = 0;
 219
 220         pkgmgrinfo_appinfo_filter_foreach_appinfo(filter, __get_appinfo_cb, NULL);
 221         pkgmgrinfo_appinfo_filter_destroy(filter);
 222
 223         /* Add to genlist */
 224         openlock_appdata *list = lockapp_data;
 225         Setting_GenGroupItem_Data *item_data = NULL;
 226         int index = 0;
 227         for(index = 0; index < count; index++)
 228         {
 229                 SETTING_TRACE_DEBUG("add item [%d]", index);
 230                 ad->data_locktype_3rd[index] = setting_create_Gendial_field_1radio(ad->sl_scroller,
 231                                                 &(itc_1text_1icon_2),
 232                                                 setting_security_locktype_mouse_up_Gendial_list_cb,     /*add to sel_cb */
 233                                                 ad,     /* sel data */
 234                                                 SWALLOW_Type_1RADIO,
 235                                                 ad->lock_type_rd, SETTING_SCREEN_LOCK_TYPE_OTHER + index,
 236                                                 list->app_name,
 237                                                 NULL);
 238                 if (ad->data_locktype_3rd[index]) {
 239                         ad->data_locktype_3rd[index]->userdata = ad;
 240                 } else {
 241                         SETTING_TRACE_ERROR("item_data is NULL");
 242                 }
 243
 244                 char *open_lock_name = NULL;
 245                 open_lock_name = vconf_get_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR);
 246                 if(safeStrCmp(open_lock_name, list->app_name) == 0)
 247                         ret_index = index;
 248                 list = list->next;
 249         }
 250         return ret_index;
 251         SETTING_TRACE_END;
 252 }
 253
 254
 255 /**
 256  * create the lock type list
 257  */
 258 void __add_locktype_items(void *data)
 259 {
 260         SETTING_TRACE_BEGIN;
 261         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 262
 263         SettingSecurityUG *ad = (SettingSecurityUG *) data;
 264
 265         Elm_Object_Item *item = NULL;
 266         Evas_Object *radio;
 267         Setting_GenGroupItem_Data *item_data = NULL;
 268
 269         int index = -1;
 270         int locktype = 0;
 271         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &locktype);
 272
 273         radio = elm_radio_add(ad->sl_scroller);
 274         elm_radio_state_value_set(radio, -1);
 275         ad->lock_type_rd = radio;
 276
 277         /* separator */
 278         item = elm_genlist_item_append(ad->sl_scroller, &(ad->itc_seperator), NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 279         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 280
 281         //evas_object_smart_callback_add(ad->sl_scroller, "realized", __gl_realized_cb, NULL);
 282
 283 #if 0
 284         // [FLOW] add default lock type
 285         /* to do : radio menu */
 286         /* 1) swipe */
 287         ad->data_locktype_swipe =
 288             setting_create_Gendial_field_1radio(ad->sl_scroller,
 289                                                 &(itc_1text_1icon_2),
 290                                                 setting_security_locktype_mouse_up_Gendial_list_cb,     /*add to sel_cb */
 291                                                 ad,     /* sel data */
 292                                                 SWALLOW_Type_1RADIO,
 293                                                 radio, SETTING_SCREEN_LOCK_TYPE_SWIPE,
 294                                                 Keystr_Swipe,
 295                                                 NULL);
 296         if (ad->data_locktype_swipe) {
 297                 ad->data_locktype_swipe->userdata = ad;
 298                 ad->data_locktype_swipe->group_style = SETTING_GROUP_STYLE_TOP;
 299         } else {
 300                 SETTING_TRACE_ERROR("item_data is NULL");
 301         }
 302 #endif
 303
 304         /* [FLOW] Add 3rd party lock apps in list. */
 305         index = __add_3rd_party_lock(ad);
 306
 307         /* update info */
 308         /* To do : If type is OTHER, should calculate something.*/
 309         if(locktype == SETTING_SCREEN_LOCK_TYPE_OTHER)
 310         {
 311                 char *open_lock_name = NULL;
 312                 open_lock_name = vconf_get_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR);
 313                 //index = __get_index_of_lockapp(open_lock_name);       // <-- symbol mismatch ?
 314                 index = __get_lockapp_index_from_pkgname(open_lock_name);
 315
 316                 if(open_lock_name)
 317                         FREE(open_lock_name);
 318         }
 319         /* End */
 320         if(index < 0)
 321                 elm_radio_value_set(radio, locktype);
 322         else
 323                 elm_radio_value_set(radio, locktype + index);
 324 }
 325
 326 static int setting_security_locktype_create(void *cb)
 327 {
 328         SETTING_TRACE_BEGIN;
 329         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 330
 331         SettingSecurityUG *ad = (SettingSecurityUG *) cb;
 332
 333         /* add basic layout */
 334
 335         Evas_Object *scroller = NULL;
 336
 337         setting_push_layout_navi_bar_genlist(ad->win_main_layout,
 338                                                            ad->win_get,
 339                                                            _(Keystr_ScreenLockType),
 340                                                            _("IDS_COM_BODY_BACK"), NULL,
 341                                                            setting_security_locktype_click_softkey_back_cb,
 342                                                            NULL, ad, &scroller, ad->navi_bar);
 343
 344         ad->sl_scroller = scroller;
 345
 346         __add_locktype_items(ad);
 347
 348         setting_view_security_locktype.is_create = 1;
 349
 350         return SETTING_RETURN_SUCCESS;
 351 }
 352
 353 static int setting_security_locktype_destroy(void *cb)
 354 {
 355         SETTING_TRACE_BEGIN;
 356         /* error check */
 357         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 358
 359         SettingSecurityUG *ad = (SettingSecurityUG *) cb;
 360         if (ad->notify)
 361         {
 362                 evas_object_del(ad->notify);
 363                 ad->notify = NULL;
 364         }
 365
 366         openlock_appdata *item = lockapp_data;
 367         for(; item != NULL; item = item->next)
 368         {
 369                 FREE(item->app_name);
 370                 FREE(item->pkg_name);
 371         }
 372
 373         elm_naviframe_item_pop(ad->navi_bar);
 374
 375         setting_view_security_locktype.is_create = 0;
 376
 377         return SETTING_RETURN_SUCCESS;
 378 }
 379
 380 static int setting_security_locktype_update(void *cb)
 381 {
 382         SETTING_TRACE_BEGIN;
 383         /* error check */
 384         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 385
 386         return SETTING_RETURN_SUCCESS;
 387 }
 388
 389 static int setting_security_locktype_cleanup(void *cb)
 390 {
 391         SETTING_TRACE_BEGIN;
 392         /* error check */
 393         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 394
 395         SettingSecurityUG *ad = (SettingSecurityUG *) cb;
 396
 397         return setting_security_locktype_destroy(ad);
 398 }
 399
 400 /* ***************************************************
 401  **
 402  **call back func
 403  **
 404  ****************************************************/
 405
 406 /**
 407  * select each item of the list
 408  */
 409 static void
 410 setting_security_locktype_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
 411                                                void *event_info)
 412 {
 413         SETTING_TRACE_BEGIN;
 414         /* error check */
 415         setting_retm_if(data == NULL, "Data parameter is NULL");
 416
 417         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 418         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 419         elm_genlist_item_selected_set(item, 0);
 420         Setting_GenGroupItem_Data *list_item =
 421             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 422         SettingSecurityUG *ad = (SettingSecurityUG *) data;
 423         int lock_type = list_item->chk_status;
 424         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
 425         int old_type = elm_radio_value_get(list_item->eo_check);
 426
 427         ad->selected_lock_type = list_item->keyStr;
 428
 429         /* If lock_type is same with old_lock_type, return. */
 430         if(lock_type == old_type)
 431         {
 432                 SETTING_TRACE_DEBUG("[Screen Lock Type] Selected same type");
 433                 return;
 434         }
 435
 436         int index = -1;
 437         char *pkg_name = NULL;
 438
 439
 440         index = __get_lockapp_index_from_appname(list_item->keyStr);
 441
 442         SETTING_TRACE(" lock type : %d ---%d --- %d ", lock_type, SETTING_SCREEN_LOCK_TYPE_OTHER, index);
 443
 444         pkg_name = __get_lockapp_pkgname_from_appname(list_item->keyStr);
 445         SETTING_TRACE_DEBUG("3rd lock selected. index[%d] pkg_name[%s]", index, pkg_name);
 446         vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, pkg_name);
 447         vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type - index);
 448         /* set radio */
 449 //      elm_radio_value_set(list_item->eo_check, lock_type + index);
 450         elm_radio_value_set(list_item->eo_check, index);
 451         ug_destroy_me(ad->ug);
 452
 453 #if 0
 454         switch(lock_type)
 455         {
 456         #if 0
 457                 case SETTING_SCREEN_LOCK_TYPE_SWIPE:
 458                         if(vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type) == 0)
 459                         {
 460                                 /* set radio */
 461                                 elm_radio_value_set(list_item->eo_check, lock_type);
 462                         }
 463                         ug_destroy_me(ad->ug);
 464                         break;
 465                 case SETTING_SCREEN_LOCK_TYPE_OTHER:
 466         #endif
 467                         index = __get_lockapp_index_from_appname(list_item->keyStr);
 468                         pkg_name = __get_lockapp_pkgname_from_appname(list_item->keyStr);
 469                         SETTING_TRACE_DEBUG("3rd lock selected. index[%d] pkg_name[%s]", index, pkg_name);
 470                         vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, pkg_name);
 471                         vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, lock_type);
 472                         /* set radio */
 473                         elm_radio_value_set(list_item->eo_check, lock_type + index);
 474                         ug_destroy_me(ad->ug);
 475                         break;
 476                 default:
 477                         break;
 478         }
 479 #endif
 480 }
 481
 482 static void
 483 setting_security_locktype_click_softkey_back_cb(void *data, Evas_Object *obj,
 484                                             void *event_info)
 485 {
 486         SETTING_TRACE_BEGIN;
 487         /* error check */
 488         retm_if(data == NULL, "[Setting > Security] Data parameter is NULL");
 489
 490         SettingSecurityUG *ad = (SettingSecurityUG *) data;
 491         setting_view_change(&setting_view_security_locktype, &setting_view_security_main, ad);
 492         SETTING_TRACE_END;
 493 }