setting-appmgr/src/setting-appmgr-utils.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19 #include <appsvc.h>
  20 /*#include <resourced.h> */
  21 /*#include <data_usage.h> */
  22 #include <app_manager.h>
  23
  24 #include "setting-appmgr-main.h"
  25 #include "setting-appmgr-runinfo.h"
  26 #include "setting-appmgr-pkginfo-utils.h"
  27 #include "setting-appmgr-async-worker.h"
  28 #include "setting-appmgr-utils.h"
  29
  30 extern void appmgrUg_pkg_uninstall_click(void *data, Evas_Object *obj, void *event_info);
  31 extern void appmgrUg_pkg_clear_cache_click(void *data, Evas_Object *obj, void *event_info);
  32 extern void appmgrUg_pkg_moveto_cb(void *data, Evas_Object *obj, void *event_info);
  33 extern Evas_Object *appmgrUg_run_gl_stop_btn(void *data, Evas_Object *obj, const char *part);
  34 extern void appmgrUg_run_stop_click(void *data, Evas_Object *obj, void *event_info);
  35
  36 static void appmgrUg_free_listinfo(gpointer data);
  37
  38 void _free_GSList(GSList *list)
  39 {
  40         g_slist_foreach(list, (GFunc)g_free, NULL);
  41         g_slist_free(list);
  42 }
  43
  44 /*
  45 resourced_cb_ret _reset_all_restrict_apps_cb(const resourced_restriction_info *info, void *user_data) {
  46         GSList** appid_list = (GSList**)user_data;
  47         *appid_list = g_slist_prepend(*appid_list, g_strdup(info->app_id));
  48         return 1;
  49 }
  50
  51 void _reset_restrict_cb(char *app_id){
  52         resourced_ret_c ret = remove_restriction_by_iftype(app_id, RESOURCED_IFACE_DATACALL);
  53         if(RESOURCED_ERROR_OK != ret){
  54                 SETTING_TRACE_ERROR("reset restrict app: %s failed with %d", app_id, ret);
  55         }
  56 } */
  57
  58 void appmgrUg_size_to_str(int size, char *desc, int desc_size)
  59 {
  60         double tmp_size = 0.0;
  61         const int KILOBYTE_VALUE = 1024;
  62         const int MEGABYTE_VALUE = 1048576;
  63         const int GIGABYTE_VALUE = 1073741824;
  64
  65         if (size < MEGABYTE_VALUE) {    /* size < 1MB: show x.xKB */
  66                 tmp_size = (double)size / KILOBYTE_VALUE;
  67                 snprintf(desc, desc_size, "%4.2lf%s", tmp_size, _(MGRAPP_STR_KB));
  68         } else if (size < GIGABYTE_VALUE) {     /* size < 1GB: show x.xMB */
  69                 tmp_size = (double)size / MEGABYTE_VALUE;
  70                 snprintf(desc, desc_size, "%4.2lf%s", tmp_size, _(MGRAPP_STR_MB));
  71         } else { /* 1G <= size: show x.xGB */
  72                 tmp_size = (double)size / GIGABYTE_VALUE;
  73                 snprintf(desc, desc_size, "%4.2lf%s", tmp_size, _(MGRAPP_STR_GB));
  74         }
  75 }
  76
  77 void appmgrUg_popup_del(void *data, Evas_Object *obj, void *event_info)
  78 {
  79         SettingAppMgrUG *ad = data;
  80
  81         ret_if(data == NULL);
  82
  83         evas_object_del(ad->popup);
  84         ad->popup = NULL;
  85 }
  86
  87 void appmgrUg_fail_popup(char *str, SettingAppMgrUG *ad)
  88 {
  89         if (ad->popup) {
  90                 evas_object_del(ad->popup);
  91                 ad->popup = NULL;
  92         }
  93
  94         ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
  95                                                   str, appmgrUg_popup_del, 0, 1, MGRAPP_STR_OK);
  96 }
  97
  98 static void appmgrUg_update_listinfos(SettingAppMgrUG *ad)
  99 {
 100         SETTING_TRACE_BEGIN;
 101
 102         if (ad->list_worker)
 103                 appmgrUg_stop_async_worker(ad->list_worker);
 104         ad->list_worker = appmgrUg_start_async_worker(appmgrUg_get_listinfos,
 105                                                       appmgrUg_get_listinfos_cb, ad);
 106 }
 107
 108 static int appmgrUg_pkgmgr_changed_cb(int req_id, const char *pkg_type,
 109                                       const char *pkgid, const char *key, const char *val, const void *pmsg,
 110                                       void *data)
 111 {
 112         SettingAppMgrUG *ad = data;
 113
 114         retv_if(data == NULL, -1);
 115
 116         SETTING_TRACE_DEBUG("key:%s val:%s", key, val);
 117         SETTING_TRACE_DEBUG("pkg_type:%s, pkgid:%s, sel_pkgid:%s", pkg_type, pkgid,
 118                             ad->sel_pkgid);
 119
 120         /*
 121            if (!safeStrCmp(key, "start") && safeStrCmp(val, "uninstall"))
 122            if (!safeStrCmp(key, "start") && !safeStrCmp(val, "install"))
 123            if (!safeStrCmp(key, "start") && !safeStrCmp(val, "move"))
 124            if (!safeStrCmp(key, "start") && !safeStrCmp(val, "update"))
 125            */
 126
 127         if (!safeStrCmp(key, "error")) {
 128                 SETTING_TRACE_ERROR("uninstall() Fail(key:%s val:%s)", key, val);
 129         } else if (!safeStrCmp(key, "end") && !safeStrCmp(val, "fail")) {
 130                 if (0 == safeStrCmp(ad->sel_pkgid, pkgid)) {
 131                         if (APPMGRUG_PKG_REQUEST_UNINSTALL == ad->pkg_request) {
 132                                 SETTING_TRACE_ERROR("uninstall() Fail");
 133                                 appmgrUg_fail_popup(MGRAPP_STR_UNINSTALL_FAILED, ad);
 134                                 ad->pkg_request = APPMGRUG_PKG_REQUEST_NONE;
 135                         } else if (APPMGRUG_PKG_REQUEST_MOVE == ad->pkg_request) {
 136                                 appmgrUg_pkg_moveto_worker_finish(ad);
 137                         }
 138                 }
 139         } else if (!safeStrCmp(key, "end") && !safeStrCmp(val, "ok")) {
 140                 if (0 == safeStrCmp(ad->sel_pkgid, pkgid)) {
 141                         if (APPMGRUG_PKG_REQUEST_UNINSTALL == ad->pkg_request) {
 142                                 if (APPMGRUG_TAB_NONE == ad->tabtype)
 143                                         ug_destroy_me(ad->ug);
 144                                 else
 145                                         elm_naviframe_item_pop(ad->navi);
 146
 147                                 if (ad->popup)
 148                                         evas_object_del(ad->popup);
 149                                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 150                                                                           MGRAPP_STR_UNINSTALL_COMPLETE, appmgrUg_popup_del, 0,
 151                                                                           1, MGRAPP_STR_OK);
 152
 153                                 ad->pkg_request = APPMGRUG_PKG_REQUEST_NONE;
 154                         } else if (APPMGRUG_PKG_REQUEST_MOVE == ad->pkg_request) {
 155                                 appmgrUg_pkg_moveto_worker_finish(ad);
 156                         } else if (APPMGRUG_PKG_REQUEST_DISABLE == ad->pkg_request) {
 157                                 ad->sel_is_disabled = EINA_TRUE;
 158                                 ad->pkg_request = APPMGRUG_PKG_REQUEST_NONE;
 159                                 if (ad->pkginfo_view->is_create)
 160                                         setting_view_update(ad->pkginfo_view, ad);
 161                         } else if (APPMGRUG_PKG_REQUEST_ENABLE == ad->pkg_request) {
 162                                 ad->sel_is_disabled = EINA_FALSE;
 163                                 ad->pkg_request = APPMGRUG_PKG_REQUEST_NONE;
 164                                 if (ad->pkginfo_view->is_create)
 165                                         setting_view_update(ad->pkginfo_view, ad);
 166                         } else {
 167                                 if (ad->pkginfo_view->is_create)
 168                                         setting_view_update(ad->pkginfo_view, ad);
 169                         }
 170                 }
 171
 172                 if (ad->main_view->is_create)
 173                         appmgrUg_update_listinfos(ad);
 174         }
 175
 176         return 0;
 177 }
 178
 179 Evas_Object *appmgrUg_no_item(Evas_Object *parent, const char *text,
 180                               const char *help)
 181 {
 182         Evas_Object *layout, *icon;
 183
 184         layout = elm_layout_add(parent);
 185         elm_layout_theme_set(layout, "layout", "nocontents", "default");
 186         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 187         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 188
 189         icon = elm_image_add(layout);
 190         elm_image_file_set(icon, SETTING_ICON_PATH_CFG "/00_nocontents_text_new.png", NULL);
 191         elm_object_part_content_set(layout, "nocontents.image", icon);
 192
 193         elm_object_part_text_set(layout, "elm.text", _(text));
 194         elm_layout_signal_emit(layout, "text,disabled", "");
 195
 196         if (help) {
 197                 elm_object_part_text_set(layout, "elm.help.text", _(help));
 198                 elm_layout_signal_emit(layout, "align.center", "elm");
 199         }
 200
 201         return layout;
 202 }
 203
 204 void
 205 progressbar_pulse_add(char *style_name, char *container_name, Evas_Object *layout)
 206 {
 207         Evas_Object *progressbar = elm_progressbar_add(layout);
 208
 209         elm_object_style_set(progressbar, style_name);
 210         elm_progressbar_pulse(progressbar, EINA_TRUE);
 211         elm_object_part_content_set(layout, container_name, progressbar);
 212
 213         evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL, 0.5);
 214         evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 215
 216         evas_object_show(progressbar);
 217 }
 218
 219 Evas_Object *appmgrUg_loading_item(Evas_Object *parent, const char *text,
 220                                    const char *help)
 221 {
 222         Evas_Object *layout;
 223
 224         layout = elm_layout_add(parent);
 225         elm_layout_theme_set(layout, "layout", "nocontents_loading", "default");
 226         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 227         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 228
 229         progressbar_pulse_add("process_Xlarge", "nocontents.image", layout);
 230
 231         elm_object_part_text_set(layout, "elm.text", _(text));
 232         elm_layout_signal_emit(layout, "text,disabled", "");
 233
 234         if (help) {
 235                 elm_object_part_text_set(layout, "elm.help.text", _(help));
 236                 elm_layout_signal_emit(layout, "align.center", "elm");
 237         }
 238
 239         return layout;
 240 }
 241
 242 Elm_Object_Item *appmgrUg_append_separator(Evas_Object *genlist,
 243                                            SettingAppMgrUG *ad)
 244 {
 245         Elm_Object_Item *item = NULL;
 246
 247         item = elm_genlist_item_append(genlist, &ad->itc_sep, NULL, NULL,
 248                                        ELM_GENLIST_ITEM_NONE, NULL, NULL);
 249         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 250
 251         return item;
 252 }
 253
 254 char *appmgrUg_get_defualt_icon(pkgmgrinfo_appinfo_h handle)
 255 {
 256         int ret;
 257         char *type;
 258         const char *icon;
 259         const char *svc_icon = SETTING_ICON_PATH"/default_icon_service.png";
 260         const char *app_icon = SETTING_ICON_PATH"/mainmenu.png";
 261
 262         ret = pkgmgrinfo_appinfo_get_component_type(handle, &type);
 263         if (PMINFO_R_OK == ret) {
 264                 if (0 == safeStrCmp(type, "svcapp"))
 265                         icon = svc_icon;
 266                 else
 267                         icon = app_icon;
 268         } else {
 269                 SETTING_TRACE_ERROR("pkgmgrinfo_appinfo_get_component_type() Fail(%d)", ret);
 270                 icon = app_icon;
 271         }
 272
 273         return strdup(icon);
 274 }
 275
 276 static void appmgrUg_get_listinfo(pkgmgrinfo_pkginfo_h handle,
 277                                   appmgr_listinfo *info)
 278 {
 279         int ret = 0;
 280         char *value;
 281
 282         ret_if(NULL == handle);
 283         ret_if(NULL == info);
 284
 285         value = NULL;
 286         ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &value);
 287         warn_if(ret < 0, "pkgmgrinfo_pkginfo_get_pkgid() Fail(%d)", ret);
 288         info->pkgid = SAFE_STRDUP(value);
 289
 290         value = NULL;
 291         ret = pkgmgrinfo_pkginfo_get_label(handle, &value);
 292         warn_if(ret < 0, "pkgmgrinfo_pkginfo_get_label() Fail(%d)", ret);
 293         info->pkg_label = SAFE_STRDUP(value);
 294
 295         value = NULL;
 296         ret = pkgmgrinfo_pkginfo_get_mainappid(handle, &value);
 297         warn_if(ret < 0, "pkgmgrinfo_pkginfo_get_mainappid() Fail(%d)", ret);
 298         info->mainappid = SAFE_STRDUP(value);
 299
 300         value = NULL;
 301         ret = pkgmgrinfo_pkginfo_get_icon(handle, &value);
 302         warn_if(ret < 0, "pkgmgrinfo_pkginfo_get_icon() Fail(%d)", ret);
 303         info->icon_path = appmgrUg_check_icon(value);
 304
 305         ret = pkgmgrinfo_pkginfo_is_preload(handle, &info->is_preload);
 306         warn_if(ret < 0, "pkgmgrinfo_pkginfo_is_preload() Fail(%d)", ret);
 307
 308         ret = pkgmgrinfo_pkginfo_is_update(handle, &info->is_update);
 309         warn_if(ret < 0, "pkgmgrinfo_pkginfo_is_update() Fail(%d)", ret);
 310
 311 }
 312
 313 static int appmgrUg_get_pkg_list_iter(pkgmgrinfo_pkginfo_h handle, void *data)
 314 {
 315         GList **pkg_list = data;
 316         appmgr_listinfo *info = NULL;
 317
 318         retv_if(NULL == handle, 0);
 319         retv_if(NULL == data, -1);
 320
 321         info = calloc(1, sizeof(appmgr_listinfo));
 322         if (NULL == info) {
 323                 SETTING_TRACE_ERROR("calloc() Fail");
 324                 return 0;
 325         }
 326
 327         appmgrUg_get_listinfo(handle, info);
 328
 329         *pkg_list = g_list_append(*pkg_list, info);
 330         return 0;
 331 }
 332
 333 static int appmgrUg_get_disable_pkg_list_iter(pkgmgrinfo_pkginfo_h handle, void *data)
 334 {
 335         GList **pkg_list = data;
 336         appmgr_listinfo *info = NULL;
 337
 338         retv_if(NULL == handle, 0);
 339         retv_if(NULL == data, -1);
 340
 341         info = calloc(1, sizeof(appmgr_listinfo));
 342         if (NULL == info) {
 343                 SETTING_TRACE_ERROR("calloc() Fail");
 344                 return 0;
 345         }
 346
 347         info->is_disabled = EINA_TRUE;
 348         info->valid_size = EINA_TRUE;
 349         info->total_size = 0;
 350
 351         appmgrUg_get_listinfo(handle, info);
 352
 353         *pkg_list = g_list_append(*pkg_list, info);
 354         return 0;
 355 }
 356
 357 static gint appmgrUg_sort_atoz(gconstpointer a, gconstpointer b)
 358 {
 359         int len;
 360         const appmgr_listinfo *info1 = a;
 361         const appmgr_listinfo *info2 = b;
 362
 363         retv_if(NULL == a, 0);
 364         retv_if(NULL == b, 0);
 365         retv_if(NULL == info1->pkg_label, 1);
 366         retv_if(NULL == info2->pkg_label, -1);
 367
 368         if (strlen(info1->pkg_label) < strlen(info2->pkg_label))
 369                 len = strlen(info1->pkg_label);
 370         else
 371                 len = strlen(info2->pkg_label);
 372
 373         return strncasecmp(info1->pkg_label, info2->pkg_label, len);
 374 }
 375
 376 static gint appmgrUg_sort_ztoa(gconstpointer a, gconstpointer b)
 377 {
 378         int len;
 379         const appmgr_listinfo *info1 = a;
 380         const appmgr_listinfo *info2 = b;
 381
 382         retv_if(NULL == a, 0);
 383         retv_if(NULL == b, 0);
 384         retv_if(NULL == info1->pkg_label, -1);
 385         retv_if(NULL == info2->pkg_label, 1);
 386
 387         if (strlen(info1->pkg_label) < strlen(info2->pkg_label))
 388                 len = strlen(info1->pkg_label);
 389         else
 390                 len = strlen(info2->pkg_label);
 391
 392         return strncasecmp(info2->pkg_label, info1->pkg_label, len);
 393 }
 394
 395 static gint appmgrUg_sort_size(gconstpointer a, gconstpointer b)
 396 {
 397         const appmgr_listinfo *info1 = a;
 398         const appmgr_listinfo *info2 = b;
 399
 400         retv_if(NULL == a, 0);
 401         retv_if(NULL == b, 0);
 402
 403         return info2->total_size - info1->total_size;
 404 }
 405
 406 gint appmgrUg_compare_pkgname(gconstpointer item, gconstpointer pkg_name)
 407 {
 408         const appmgr_listinfo *appinfo = item;
 409
 410         return safeStrCmp(appinfo->pkgid, pkg_name);
 411 }
 412
 413 static Eina_Bool appmgrUg_get_all_pkg_sizesort(void *data)
 414 {
 415         SettingAppMgrUG *ad = data;
 416
 417         retv_if(NULL == data, ECORE_CALLBACK_CANCEL);
 418         retv_if(APPMGRUG_SORT_SIZE != ad->sorttype, ECORE_CALLBACK_CANCEL);
 419
 420         ad->pkg_list = g_list_sort(ad->pkg_list, appmgrUg_sort_size);
 421         appmgrUg_main_genlist_append_items(ad);
 422
 423         ad->size_idler = NULL;
 424         return ECORE_CALLBACK_CANCEL;
 425 }
 426
 427 static int appmgrUg_get_all_pkg_size(int req_id, const char *pkg_type,
 428                                      const char *pkg_name, const char *key, const char *val, const void *pmsg,
 429                                      void *data)
 430 {
 431         /*If get all size finished. return directly */
 432         GList *list;
 433         SettingAppMgrUG *ad = data;
 434         retvm_if(!ad || ad->can_sizesort, 0, "return");
 435
 436         retv_if(NULL == data, 0);
 437         retv_if(NULL == val, 0);
 438
 439         if (safeStrCmp(val, "end") == 0) {
 440                 SETTING_TRACE_DEBUG("Finish size info update");
 441                 ad->can_sizesort = TRUE;
 442                 return 0;
 443         }
 444
 445         list = g_list_find_custom(ad->pkg_list, pkg_name, appmgrUg_compare_pkgname);
 446         if (list) {
 447                 appmgr_listinfo *info = list->data;
 448
 449                 info->valid_size = true;
 450                 info->total_size = atoi(val);
 451
 452                 if (APPMGRUG_SORT_SIZE == ad->sorttype) {
 453                         if (ad->size_idler)
 454                                 ecore_idler_del(ad->size_idler);
 455                         ad->size_idler = ecore_idler_add(appmgrUg_get_all_pkg_sizesort, ad);
 456                 } else {
 457                         elm_genlist_item_fields_update(info->item, "elm.text.sub.left.bottom",
 458                                                        ELM_GENLIST_ITEM_FIELD_TEXT);
 459                 }
 460         }
 461
 462         return 0;
 463 }
 464
 465 GList *appmgrUg_sort_pkg_list(int sorttype, GList *pkg_list)
 466 {
 467         if (APPMGRUG_SORT_SIZE == sorttype)
 468                 return g_list_sort(pkg_list, appmgrUg_sort_size);
 469         else if (APPMGRUG_SORT_ZTOA == sorttype)
 470                 return g_list_sort(pkg_list, appmgrUg_sort_ztoa);
 471         else
 472                 return g_list_sort(pkg_list, appmgrUg_sort_atoz);
 473 }
 474
 475 int appmgrUg_get_listinfos(SettingAppMgrUG *ad)
 476 {
 477         int ret;
 478         GList *pkg_list = NULL;
 479
 480         retv_if(ad == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 481
 482         /*init app list */
 483         ret = pkgmgrinfo_pkginfo_get_list(appmgrUg_get_pkg_list_iter, &pkg_list);
 484         if (ret < 0) {
 485                 SETTING_TRACE_ERROR("pkgmgrinfo_pkginfo_get_list() Fail(%d)", ret);
 486                 return SETTING_RETURN_FAIL;
 487         }
 488
 489         APPMGRUG_STOP_POINT;
 490
 491         /*Get disabled pkg list */
 492         pkgmgrinfo_pkginfo_filter_h filter_handle;
 493         ret = pkgmgrinfo_pkginfo_filter_create(&filter_handle);
 494
 495         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_appinfo_filter_create() Fail(%d)", ret);
 496
 497         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter_handle,
 498                                                  PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, EINA_TRUE);
 499
 500         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_appinfo_filter_add_bool() Fail(%d)", ret);
 501
 502         ret = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(filter_handle,
 503                                                         appmgrUg_get_disable_pkg_list_iter, &pkg_list);
 504         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_filter_foreach_pkginfo() Fail(%d)", ret);
 505
 506         pkgmgrinfo_pkginfo_filter_destroy(filter_handle);
 507
 508         APPMGRUG_STOP_POINT;
 509
 510         ad->old_pkg_list = ad->pkg_list;
 511         ad->pkg_list = appmgrUg_sort_pkg_list(ad->sorttype, pkg_list);
 512
 513         APPMGRUG_STOP_POINT;
 514
 515         if (ad->pc_all_size)
 516                 pkgmgr_client_free(ad->pc_all_size);
 517
 518         APPMGRUG_STOP_POINT;
 519
 520         /*request total size */
 521         ad->can_sizesort = FALSE;
 522
 523         ad->pc_all_size = pkgmgr_client_new(PC_LISTENING);
 524         if (NULL == ad->pc_all_size) {
 525                 SETTING_TRACE_ERROR("pkgmgr_client_new() Faill");
 526                 return SETTING_RETURN_FAIL;
 527         }
 528
 529         APPMGRUG_STOP_POINT;
 530
 531         ret = pkgmgr_client_set_status_type(ad->pc_all_size, PKGMGR_CLIENT_STATUS_GET_SIZE);
 532         if (ret < 0) {
 533                 SETTING_TRACE_ERROR("pkgmgr_client_set_status_type() Fail(%d)", ret);
 534                 pkgmgr_client_free(ad->pc_all_size);
 535                 ad->pc_all_size = NULL;
 536                 return SETTING_RETURN_FAIL;
 537         }
 538
 539         APPMGRUG_STOP_POINT;
 540
 541         ret = pkgmgr_client_listen_status(ad->pc_all_size, appmgrUg_get_all_pkg_size, ad);
 542         if (ret < 0) {
 543                 SETTING_TRACE_ERROR("pkgmgr_client_listen_status() Fail(%d)", ret);
 544                 pkgmgr_client_free(ad->pc_all_size);
 545                 ad->pc_all_size = NULL;
 546                 return SETTING_RETURN_FAIL;
 547         }
 548
 549         APPMGRUG_STOP_POINT;
 550
 551         ret = pkgmgr_client_request_size_info();
 552         warn_if(ret < 0, "pkgmgr_client_request_size_info() Fail", ret);
 553
 554         return SETTING_RETURN_SUCCESS;
 555 }
 556
 557 void appmgrUg_get_listinfos_cb(int fn_result, SettingAppMgrUG *ad)
 558 {
 559         ret_if(NULL == ad);
 560
 561         if (SETTING_RETURN_SUCCESS != fn_result) {
 562                 SETTING_TRACE_ERROR("appmgrUg_get_listinfos() Fail(%d)", fn_result);
 563         } else {
 564                 setting_view_update(ad->main_view, ad);
 565
 566                 /*after listinfos & genlist updated, free old listinfos */
 567                 if (ad->old_pkg_list) {
 568                         g_list_free_full(ad->old_pkg_list, appmgrUg_free_listinfo);
 569                         ad->old_pkg_list = NULL;
 570                 }
 571         }
 572         ad->list_worker = NULL;
 573 }
 574
 575 void appmgrUg_get_runlistinfos_cb(int fn_result, SettingAppMgrUG *ad)
 576 {
 577         ret_if(NULL == ad);
 578
 579         if (SETTING_RETURN_SUCCESS != fn_result) {
 580                 SETTING_TRACE_ERROR("appmgrUg_get_listinfos() Fail(%d)", fn_result);
 581         } else {
 582                 setting_view_update(ad->main_view, ad);
 583         }
 584         ad->running_list_worker = NULL;
 585 }
 586
 587 void appmgrUg_pkgmgr_subscribe(SettingAppMgrUG *ad)
 588 {
 589         int ret;
 590
 591         ret_if(NULL == ad);
 592
 593         ad->pc_main = pkgmgr_client_new(PC_LISTENING);
 594         if (NULL == ad->pc_main) {
 595                 SETTING_TRACE_ERROR("pkgmgr_client_new() Fail");
 596                 return;
 597         }
 598
 599         ret = pkgmgr_client_listen_status(ad->pc_main, appmgrUg_pkgmgr_changed_cb, ad);
 600         if (ret < 0) {
 601                 SETTING_TRACE_ERROR("pkgmgr_client_listen_status() Fail(%d)", ret);
 602                 pkgmgr_client_free(ad->pc_main);
 603                 ad->pc_main = NULL;
 604                 return;
 605         }
 606 }
 607
 608 void appmgrUg_pkgmgr_deinit(SettingAppMgrUG *ad)
 609 {
 610         if (ad->pc_main) {
 611                 pkgmgr_client_free(ad->pc_main);
 612                 ad->pc_main = NULL;
 613         }
 614         if (ad->pc_all_size) {
 615                 pkgmgr_client_free(ad->pc_all_size);
 616                 ad->pc_all_size = NULL;
 617         }
 618         if (ad->size_idler) {
 619                 ecore_idler_del(ad->size_idler);
 620                 ad->size_idler = NULL;
 621         }
 622 }
 623
 624 static void appmgrUg_del_def_list(gpointer data, gpointer user_data)
 625 {
 626         appmgr_listinfo *info = data;
 627
 628         ret_if(NULL == data);
 629
 630         g_list_free_full(info->def_appids, free);
 631         info->def_appids = NULL;
 632 }
 633
 634 static int appmgrUg_get_default_list_iter(const char *appid, void *data)
 635 {
 636         int ret;
 637         GList *list;
 638         char *pkgid = NULL;
 639         pkgmgrinfo_appinfo_h handle;
 640         SettingAppMgrUG *ad = data;
 641
 642         retv_if(NULL == ad, 0);
 643         retv_if(NULL == appid, 0);
 644
 645         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
 646         if (PMINFO_R_OK != ret) {
 647                 SETTING_TRACE_ERROR("pkgmgrinfo_appinfo_get_appinfo() Fail(%d)", ret);
 648                 return 0;
 649         }
 650
 651         ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
 652         if (PMINFO_R_OK != ret) {
 653                 SETTING_TRACE_ERROR("pkgmgrinfo_appinfo_get_pkgid() Fail(%d)", ret);
 654                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
 655                 return 0;
 656         }
 657
 658         list = g_list_find_custom(ad->pkg_list, pkgid, appmgrUg_compare_pkgname);
 659         if (list) {
 660                 appmgr_listinfo *info = list->data;
 661                 info->def_appids = g_list_append(info->def_appids, strdup(appid));
 662         }
 663
 664         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 665
 666         return 0;
 667 }
 668
 669 void appmgrUg_get_default_list(SettingAppMgrUG *ad)
 670 {
 671         int ret;
 672
 673         ret_if(ad == NULL);
 674
 675         g_list_foreach(ad->pkg_list, appmgrUg_del_def_list, NULL);
 676
 677         ret = appsvc_get_all_defapps(appmgrUg_get_default_list_iter, ad);
 678         warn_if(AUL_R_OK != ret, "aul_app_get_running_app_info() Fail", ret);
 679 }
 680
 681 static void appmgrUg_free_listinfo(gpointer data)
 682 {
 683         appmgr_listinfo *info = data;
 684
 685         ret_if(NULL == data);
 686
 687         free(info->pkgid);
 688         free(info->icon_path);
 689         free(info->pkg_label);
 690
 691         g_list_free_full(info->runinfos, appmgrUg_free_runinfo);
 692         g_list_free_full(info->def_appids, free);
 693         free(info);
 694 }
 695
 696 void appmgrUg_free_listinfos(SettingAppMgrUG *ad)
 697 {
 698         g_list_free_full(ad->pkg_list, appmgrUg_free_listinfo);
 699         ad->pkg_list = NULL;
 700 }
 701
 702 Evas_Object *appmgrUg_info_title_gl_icon_get(void *data, Evas_Object *obj,
 703                                              const char *part)
 704 {
 705         Evas_Object *icon = NULL;
 706         Evas_Object *lay = NULL;
 707         SettingAppMgrUG *ad = data;
 708
 709         retv_if(data == NULL, NULL);
 710         if (safeStrCmp(part, "elm.icon.1"))
 711                 return NULL;
 712
 713         /* icon for 'elm.icon' part */
 714         icon = elm_icon_add(obj);
 715
 716         elm_image_file_set(icon, ad->sel_icon, NULL);
 717         evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 718         evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 719
 720         lay = elm_layout_add(obj);
 721         elm_layout_theme_set(lay, "layout", "list/B/type.2", "default");
 722         elm_layout_content_set(lay, "elm.swallow.content", icon);
 723
 724         evas_object_show(icon);
 725
 726         return lay;
 727 }
 728
 729 void appmgrUg_pkg_disable_enable_cb(void *data, Evas_Object *obj,
 730                                     void *event_info)
 731 {
 732         SETTING_TRACE_BEGIN;
 733         setting_retm_if(data == NULL, "Data parameter is NULL");
 734         SettingAppMgrUG *ad = data;
 735         ret_if(NULL == ad->pkginfo);
 736         appmgr_pkginfo *info = ad->pkginfo;
 737
 738         if (info->pc_request)
 739                 pkgmgr_client_free(info->pc_request);
 740         info->pc_request = pkgmgr_client_new(PC_REQUEST);
 741         if (NULL == info->pc_request) {
 742                 SETTING_TRACE_ERROR("pkgmgr_client_new() Fail");
 743                 return;
 744         }
 745
 746         if (info->is_disable) {
 747                 pkgmgr_client_activate(info->pc_request, info->pkg_type, info->pkgid);
 748                 ad->pkg_request = APPMGRUG_PKG_REQUEST_ENABLE;
 749         } else {
 750                 pkgmgr_client_deactivate(info->pc_request, info->pkg_type, info->pkgid);
 751                 ad->pkg_request = APPMGRUG_PKG_REQUEST_DISABLE;
 752         }
 753 }
 754
 755 void appmgrUg_pkg_stop_cb(void *data, Evas_Object *obj, void *event_info)
 756 {
 757         SETTING_TRACE_BEGIN;
 758         setting_retm_if(data == NULL, "Data parameter is NULL");
 759         SettingAppMgrUG *ad = data;
 760         ret_if(NULL == ad->pkginfo);
 761         appmgr_pkginfo *info = ad->pkginfo;
 762
 763         GList *cur = info->appids;
 764         while (cur) {
 765                 int ret;
 766                 bool running_flag = 0;
 767                 char *appid = cur->data;
 768                 cur = cur->next;
 769                 if (NULL == appid)
 770                         continue;
 771                 ret = app_manager_is_running(appid, &running_flag);
 772                 warn_if(APP_MANAGER_ERROR_NONE != ret, "app_manager_is_running Fail(%d)", ret);
 773                 if (0 == running_flag)
 774                         continue;
 775
 776                 app_context_h app_context;
 777
 778                 ret = app_manager_get_app_context(appid, &app_context);
 779                 if (APP_MANAGER_ERROR_NONE != ret) {
 780                         SETTING_TRACE_ERROR("app_manager_get_app_context Fail(%d)", ret);
 781                         return;
 782                 }
 783
 784                 ret = app_manager_terminate_app(app_context);
 785                 if (APP_MANAGER_ERROR_NONE != ret) {
 786                         SETTING_TRACE_ERROR("app_manager_terminate_app() Fail(%d)", ret);
 787                         app_context_destroy(app_context);
 788                         return;
 789                 }
 790
 791                 app_context_destroy(app_context);
 792         }
 793         elm_object_disabled_set(obj, EINA_TRUE);
 794 }
 795
 796 Evas_Object *appmgrUg_info_2button1_gl_icon_get(void *data, Evas_Object *obj,
 797                                                 const char *part)
 798 {
 799         SETTING_TRACE_BEGIN;
 800         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 801         if (0 != safeStrCmp(part, "elm.icon"))
 802                 return NULL;
 803         SettingAppMgrUG *ad = data;
 804         retv_if(NULL == ad->pkginfo, NULL);
 805         appmgr_pkginfo *info = ad->pkginfo;
 806
 807         Evas_Object *box = elm_box_add(obj);
 808         elm_box_horizontal_set(box, 1);
 809         elm_box_align_set(box, 0.0, 0.5);
 810         elm_box_padding_set(box, 10, 0);
 811
 812         /* Force stop button */
 813         /*check if have running app */
 814         bool running_flag = 0;
 815         GList *cur = info->appids;
 816         while (cur) {
 817                 int ret;
 818                 char *appid = cur->data;
 819
 820                 cur = cur->next;
 821
 822                 if (NULL == appid)
 823                         continue;
 824
 825                 ret = app_manager_is_running(appid, &running_flag);
 826                 warn_if(APP_MANAGER_ERROR_NONE != ret, "app_manager_is_running Fail(%d)", ret);
 827                 if (running_flag) {
 828                         break;
 829                 }
 830         }
 831
 832         Evas_Object *button1 =
 833             setting_create_button(box, MGRAPP_STR_FORCE_STOP, NULL, appmgrUg_pkg_stop_cb, ad);
 834         if (!running_flag)
 835                 elm_object_disabled_set(button1, EINA_TRUE);
 836
 837         /* Disable/Enable button */
 838         Evas_Object *button2 =
 839             setting_create_button(box, MGRAPP_STR_DISABLE, NULL, appmgrUg_pkg_disable_enable_cb, ad);
 840         if (!info->is_support_disable) {
 841                 elm_object_disabled_set(button2, EINA_TRUE);
 842         } else if (info->is_disable) {
 843                 elm_object_disabled_set(button2, EINA_FALSE);
 844                 elm_object_text_set(button2, _(MGRAPP_STR_ENABLE));
 845         }
 846
 847         elm_box_pack_end(box, button1);
 848         elm_box_pack_end(box, button2);
 849
 850         evas_object_show(button1);
 851         evas_object_show(button2);
 852         evas_object_show(box);
 853         return box;
 854 }
 855
 856 Evas_Object *appmgrUg_info_2button2_gl_icon_get(void *data, Evas_Object *obj,
 857                                                 const char *part)
 858 {
 859         SETTING_TRACE_BEGIN;
 860         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 861         if (0 != safeStrCmp(part, "elm.icon"))
 862                 return NULL;
 863         SettingAppMgrUG *ad = data;
 864
 865         Evas_Object *box = elm_box_add(obj);
 866         elm_box_horizontal_set(box, 1);
 867         elm_box_align_set(box, 0.0, 0.5);
 868         elm_box_padding_set(box, 8, 0);
 869
 870         int ret, mmc;
 871         char *btn_str;
 872         appmgr_pkginfo *info;
 873         const char *mmc_key = VCONFKEY_SYSMAN_MMC_STATUS;
 874
 875         retv_if(NULL == ad->pkginfo, NULL);
 876
 877         info = ad->pkginfo;
 878
 879         /* Move to */
 880         mmc = VCONFKEY_SYSMAN_MMC_REMOVED;
 881         ret = vconf_get_int(mmc_key, &mmc);
 882         warn_if(ret, "vconf_get_int(%s) Fail", mmc_key);
 883
 884         if (PMINFO_INTERNAL_STORAGE == info->storage)
 885                 btn_str = MGRAPP_STR_MOVE_TO_SD;
 886         else
 887                 btn_str = MGRAPP_STR_MOVE_TO_PHONE;
 888
 889         Evas_Object *button1 =
 890             setting_create_button(box, btn_str, NULL, appmgrUg_pkg_moveto_cb, ad);
 891
 892         if (VCONFKEY_SYSMAN_MMC_MOUNTED != mmc || !info->is_movable || info->is_preload)
 893                 elm_object_disabled_set(button1, EINA_TRUE);
 894
 895         /* Uninstall */
 896         if (info->is_preload && info->is_updated)
 897                 btn_str = MGRAPP_STR_UNINSTALL_UPDATES;
 898         else
 899                 btn_str = MGRAPP_STR_UNINSTALL;
 900
 901         Evas_Object *button2 =
 902             setting_create_button(box, btn_str, NULL, appmgrUg_pkg_uninstall_click, ad);
 903
 904         if (!info->removable)
 905                 elm_object_disabled_set(button2, EINA_TRUE);
 906
 907         elm_box_pack_end(box, button1);
 908         elm_box_pack_end(box, button2);
 909
 910         evas_object_show(button1);
 911         evas_object_show(button2);
 912         evas_object_show(box);
 913         return box;
 914 }
 915
 916 Evas_Object *appmgrUg_info_1button_gl_icon_get(void *data, Evas_Object *obj,
 917                                                const char *part)
 918 {
 919         SETTING_TRACE_BEGIN;
 920         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 921         if (0 != safeStrCmp(part, "elm.icon"))
 922                 return NULL;
 923
 924         Setting_GenGroupItem_Data *item_data = data;
 925         SettingAppMgrUG *ad = item_data->userdata;
 926         setting_retvm_if(ad == NULL, NULL, "ad is NULL");
 927
 928         Evas_Object *box = elm_box_add(obj);
 929         elm_box_horizontal_set(box, 1);
 930         elm_box_align_set(box, 0.0, 0.5);
 931         elm_box_padding_set(box, 8, 0);
 932
 933         appmgr_pkginfo *info;
 934
 935         retv_if(NULL == ad->pkginfo, NULL);
 936
 937         info = ad->pkginfo;
 938
 939         Evas_Object *button1 =
 940             setting_create_button(box, "BLANK", NULL, NULL, NULL);
 941
 942         evas_object_hide(button1);
 943
 944         /* Clear cache */
 945
 946         Evas_Object *button2 =
 947             setting_create_button(box, MGRAPP_STR_CLEAR_CACHE, NULL, appmgrUg_pkg_clear_cache_click, ad);
 948
 949         if (info->sz_cache <= 0) {
 950                 elm_object_disabled_set(button2, EINA_TRUE);
 951         }
 952         elm_box_pack_end(box, button1);
 953         elm_box_pack_end(box, button2);
 954
 955         /*evas_object_show(button1); */
 956         evas_object_show(button2);
 957         evas_object_show(box);
 958
 959         SETTING_TRACE_END;
 960         return box;
 961 }
 962
 963 char *appmgrUg_info_title_gl_label_get(void *data, Evas_Object *obj,
 964                                        const char *part)
 965 {
 966         char *label = NULL;
 967         SettingAppMgrUG *ad = data;
 968
 969         retv_if(data == NULL, NULL);
 970
 971         if (0 == strcmp(part, "elm.text.main.left.top")) {
 972                 label = SAFE_STRDUP(ad->sel_label);
 973         } else if (0 == strcmp(part, "elm.text.sub.left.bottom")) {
 974                 char desc[APPMGRUG_MAX_STR_LEN] = {0};
 975
 976                 if (APPMGRUG_TAB_RUNNING == ad->tabtype) {
 977                         snprintf(desc, sizeof(desc), _(MGRAPP_STR_ACTIVE_APPS_N),
 978                                  g_list_length(ad->runinfos));
 979                 } else {
 980                         snprintf(desc, sizeof(desc), _(MGRAPP_STR_VERSION_STR),
 981                                  ad->pkginfo->pkg_version);
 982                 }
 983
 984                 label = strdup(desc);
 985         }
 986
 987         return label;
 988 }
 989 /*
 990 void reset_all_restrict_apps() {
 991         GSList *appid_list = NULL;
 992         resourced_ret_c ret = restrictions_foreach(_reset_all_restrict_apps_cb, &appid_list);
 993         if(RESOURCED_ERROR_OK != ret){
 994                 SETTING_TRACE_ERROR("unset all restrict apps fail with %d",ret);
 995         }
 996         g_slist_foreach(appid_list, (GFunc)_reset_restrict_cb, NULL);
 997         _free_GSList(appid_list);
 998 } */
 999
1000 static void _reset_app_settings_cb(int fn_result, SettingAppMgrUG *ad)
1001 {
1002         ret_if(NULL == ad);
1003
1004         ad->pkg_request = APPMGRUG_PKG_REQUEST_NONE;
1005
1006         if (ad->popup) {
1007                 evas_object_del(ad->popup);
1008                 ad->popup = NULL;
1009         }
1010
1011         if (fn_result) {
1012                 SETTING_TRACE_ERROR("_reset_app_setting_fn() Fail(%d)", fn_result);
1013                 appmgrUg_fail_popup(MGRAPP_STR_ERROR, ad);
1014         } else {
1015                 if (APPMGRUG_TAB_DEFAULT == ad->tabtype)
1016                         setting_view_update(ad->main_view, ad);
1017         }
1018         ad->reset_worker = NULL;
1019 }
1020
1021 static int _reset_app_setting_fn(SettingAppMgrUG *ad)
1022 {
1023         int ret;
1024
1025         retv_if(NULL == ad, -1);
1026
1027         ret = appsvc_unset_all_defapps();
1028         warn_if(APPSVC_RET_OK != ret, "appsvc_unset_all_defapps() Fail(%d)", ret);
1029
1030         APPMGRUG_STOP_POINT;
1031
1032         /*reset_all_restrict_apps(); */
1033
1034         return 0;
1035 }
1036
1037 int appmgrUg_reset_app_settings(SettingAppMgrUG *ad)
1038 {
1039         if (ad->popup)
1040                 evas_object_del(ad->popup);
1041         /* do not show popup
1042         ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
1043                         NULL, NULL, appmgrUg_popup_del, 0, TRUE, TRUE);
1044         */
1045         ad->pkg_request = APPMGRUG_PKG_REQUEST_RESET;
1046
1047         ad->reset_worker = appmgrUg_start_async_worker(_reset_app_setting_fn,
1048                                                        _reset_app_settings_cb, ad);
1049
1050         return 0;
1051 }