setting-appmgr/src/setting-appmgr-pkginfo-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 <privilege_info.h>
  21 #include <app2ext_interface.h>
  22
  23 #include "setting-appmgr-utils.h"
  24 #include "setting-appmgr-pkginfo-utils.h"
  25
  26 static int appmgrUg_pkg_get_privileges_help(const char *privilege,
  27                 void *user_data)
  28 {
  29         int ret;
  30         gchar *desc;
  31         appmgr_pkginfo *info;
  32         SettingAppMgrUG *ad = user_data;
  33         char *name = NULL, *help = NULL;
  34
  35         retv_if(NULL == user_data, -1);
  36         retv_if(NULL == ad->pkginfo, -1);
  37         retv_if(NULL == privilege, 0);
  38
  39         info = ad->pkginfo;
  40
  41         ret = privilege_info_get_privilege_display_name(privilege, &name);
  42         if(PRVMGR_ERR_NONE != ret)
  43         {
  44                 SETTING_TRACE_ERROR("privilege_info_get_privilege_display_name() Fail(%d)", ret);
  45                 return 0;
  46         }
  47
  48         ret = privilege_info_get_privilege_description(privilege, &help);
  49         if(PRVMGR_ERR_NONE != ret)
  50         {
  51                 SETTING_TRACE_ERROR("privilege_info_get_privilege_description() Fail(%d)", ret);
  52                 free(name);
  53                 return 0;
  54         }
  55
  56         desc = g_strconcat("<font_size=28><B>", name, "</B></font_size><br>",
  57                         help, "<br>", NULL);
  58         free(help);
  59         free(name);
  60
  61         appmgrUg_append_separator(info->gl_prv, ad);
  62
  63         setting_create_Gendial_field_titleItem(info->gl_prv, &ad->itc_multiline, desc, NULL);
  64
  65         g_free(desc);
  66         return 0;
  67 }
  68
  69 static void appmgrUg_pkg_privilege_info_view(void *data, Evas_Object *obj,
  70                 void *event_info)
  71 {
  72         char *grp = data;
  73         SettingAppMgrUG *ad;
  74         appmgr_pkginfo *info;
  75         char *grp_name = NULL;
  76         Setting_GenGroupItem_Data *d_item;
  77         Elm_Object_Item *item = event_info;
  78
  79         ret_if(data == NULL);
  80         ret_if(event_info == NULL);
  81
  82         elm_genlist_item_selected_set(item, EINA_FALSE);
  83
  84         d_item = elm_object_item_data_get(item);
  85         ret_if(NULL == d_item);
  86
  87         ad = d_item->userdata;
  88         info = ad->pkginfo;
  89
  90         privilege_info_get_privilege_group_display_name(grp, &grp_name);
  91
  92         setting_push_layout_navi_bar_genlist(ad->lo_parent, ad->win, grp_name,
  93                         NULL, NULL, NULL, NULL, NULL, &info->gl_prv, ad->navi);
  94         elm_genlist_mode_set(info->gl_prv, ELM_LIST_COMPRESS);
  95
  96         privilege_info_foreach_privilege_list_by_pkgid_and_privilege_group(info->pkgid, grp,
  97                         appmgrUg_pkg_get_privileges_help, ad);
  98 }
  99
 100 static int appmgrUg_pkg_get_privileges_iter(const char *privilege, void *user_data)
 101 {
 102         int ret;
 103         gchar **str = user_data;
 104         char *old_str, *name = NULL;
 105
 106         retv_if(NULL == user_data, -1);
 107         retv_if(NULL == privilege, 0);
 108
 109         ret = privilege_info_get_privilege_display_name(privilege, &name);
 110         if(PRVMGR_ERR_NONE != ret)
 111         {
 112                 SETTING_TRACE_ERROR("privilege_info_get_privilege_display_name() Fail(%d)", ret);
 113                 return 0;
 114         }
 115
 116         old_str = *str;
 117         *str = g_strconcat(*str, name, "<br>", NULL);
 118         g_free(old_str);
 119         free(name);
 120
 121         return 0;
 122 }
 123
 124 int appmgrUg_pkg_get_privileges_grp_iter(const char *grp, void *user_data)
 125 {
 126         int ret;
 127         appmgr_pkginfo *info;
 128         char *grp_name = NULL;
 129         gchar *prv_desc;
 130         SettingAppMgrUG *ad = user_data;
 131
 132         retv_if(NULL == user_data, -1);
 133         retv_if(NULL == ad->pkginfo, -1);
 134
 135         info = ad->pkginfo;
 136
 137         ret = privilege_info_get_privilege_group_display_name(grp, &grp_name);
 138         if(PRVMGR_ERR_NONE != ret)
 139         {
 140                 SETTING_TRACE_ERROR(
 141                                 "privilege_info_get_privilege_group_display_name() Fail(%d)", ret);
 142                 return 0;
 143         }
 144
 145         prv_desc = g_strdup("");
 146         ret = privilege_info_foreach_privilege_list_by_pkgid_and_privilege_group(info->pkgid,
 147                         grp, appmgrUg_pkg_get_privileges_iter, &prv_desc);
 148         if(PRVMGR_ERR_NONE != ret || '\0' == *prv_desc)
 149         {
 150                 SETTING_TRACE_ERROR(
 151                                 "privilege_info_foreach_privilege_list_by_pkgid_and_privilege_group()"
 152                                 " Fail(%d), prv_desc(%p)", ret, prv_desc);
 153                 G_FREE(prv_desc);
 154                 FREE(grp_name);
 155                 return 0;
 156         }
 157
 158
 159         /* remove the last <br> */
 160         char *p = strrchr(prv_desc, '<');
 161         if (p)
 162                 *p = '\0';
 163
 164         info->last_prv = setting_create_Gendial_field_def(ad->gl_pkg, &ad->itc_multiline_2txt,
 165                         appmgrUg_pkg_privilege_info_view, (void *)grp, SWALLOW_Type_INVALID, NULL,
 166                         NULL, 0, grp_name, prv_desc, NULL);
 167         if (info->last_prv)
 168         {
 169                 info->last_prv->userdata = ad;
 170
 171                 if (NULL == info->first_prv)
 172                 {
 173                         info->first_prv = info->last_prv;
 174                         info->first_prv->group_style = SETTING_GROUP_STYLE_TOP;
 175                 }
 176                 else
 177                 {
 178                         info->last_prv->group_style = SETTING_GROUP_STYLE_CENTER;
 179                 }
 180         }
 181
 182         FREE(grp_name);
 183         G_FREE(prv_desc);
 184
 185         return 0;
 186 }
 187
 188 void appmgrUg_pkg_free_pkginfo(appmgr_pkginfo *info)
 189 {
 190         ret_if(NULL == info);
 191
 192         free(info->pkgid);
 193         free(info->pkg_label);
 194         free(info->icon_path);
 195         free(info->pkg_type);
 196         free(info->pkg_version);
 197         free(info->main_appid);
 198         g_list_free_full(info->appids, free);
 199
 200         if (info->pc_size)
 201         {
 202                 pkgmgr_client_free(info->pc_size);
 203                 info->pc_size = NULL;
 204         }
 205         if (info->pc_request)
 206         {
 207                 pkgmgr_client_free(info->pc_request);
 208                 info->pc_request = NULL;
 209         }
 210
 211         free(info);
 212 }
 213
 214 static int appmgrUg_pkg_get_appinfo_iter(pkgmgrinfo_appinfo_h handle, void *data)
 215 {
 216         int ret;
 217         char *appid, *label;
 218         appmgr_pkginfo *pkginfo;
 219         SettingAppMgrUG *ad = data;
 220
 221         retv_if(data == NULL, -1);
 222
 223         pkginfo = ad->pkginfo;
 224
 225         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 226         if (PMINFO_R_OK != ret || NULL == appid)
 227         {
 228                 SETTING_TRACE_ERROR("pkgmgrinfo_appinfo_get_appid() Fail(%d)", ret);
 229                 return 0;
 230         }
 231
 232         ret = pkgmgrinfo_appinfo_get_label(handle, &label);
 233         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_appinfo_get_label() Fail(%d)", ret);
 234
 235         if (NULL == pkginfo->icon_path && safeStrCmp(appid, pkginfo->main_appid))
 236                 pkginfo->icon_path = appmgrUg_get_defualt_icon(handle);
 237
 238         pkginfo->appids = g_list_append(pkginfo->appids, strdup(appid));
 239
 240         return 0;
 241 }
 242
 243 static inline void appmgrUg_pkg_update_size(appmgr_pkginfo *info)
 244 {
 245         SETTING_TRACE_BEGIN;
 246         char desc[APPMGRUG_MAX_STR_LEN] = {0};
 247
 248         appmgrUg_size_to_str(info->sz_total, desc, sizeof(desc));
 249         g_free(info->total_size->sub_desc);
 250         info->total_size->sub_desc = (char *)g_strdup(desc);
 251         elm_genlist_item_fields_update(info->total_size->item, "elm.text.sub.left.bottom",
 252                         ELM_GENLIST_ITEM_FIELD_TEXT);
 253
 254         appmgrUg_size_to_str(info->sz_data, desc, sizeof(desc));
 255         g_free(info->data_size->sub_desc);
 256         info->data_size->sub_desc = (char *)g_strdup(desc);
 257         elm_genlist_item_fields_update(info->data_size->item, "elm.text.sub.left.bottom",
 258                         ELM_GENLIST_ITEM_FIELD_TEXT);
 259
 260         appmgrUg_size_to_str(info->sz_total - info->sz_data, desc, sizeof(desc));
 261         g_free(info->app_size->sub_desc);
 262         info->app_size->sub_desc = (char *)g_strdup(desc);
 263         elm_genlist_item_fields_update(info->app_size->item, "elm.text.sub.left.bottom",
 264                         ELM_GENLIST_ITEM_FIELD_TEXT);
 265 }
 266
 267 void appmgrUg_pkg_update_cache_size(void *data)
 268 {
 269         SETTING_TRACE_BEGIN;
 270         retm_if(data == NULL, "Data parameter is NULL");
 271         SettingAppMgrUG *ad = data;
 272         appmgr_pkginfo *info = ad->pkginfo;
 273         retm_if(info == NULL, "info is NULL");
 274
 275         char desc[APPMGRUG_MAX_STR_LEN] = {0};
 276
 277         appmgrUg_size_to_str(info->sz_cache, desc, sizeof(desc));
 278
 279         if (ad->cache_size && ad->cache_size->item) {
 280                 ad->cache_size->sub_desc = (char *)g_strdup(desc);
 281                 elm_genlist_item_fields_update(ad->cache_size->item, "elm.text.sub.left.bottom",
 282                                 ELM_GENLIST_ITEM_FIELD_TEXT);
 283         }
 284
 285         if (ad->clear_cache && ad->clear_cache->item) {
 286                 elm_genlist_item_update(ad->clear_cache->item);
 287         }
 288 }
 289
 290 static int _appmgrUg_pkg_get_pkg_size(int req_id, const char *pkg_type,
 291                 const char *pkgid, const char *key, const char *val, const void *pmsg, void *data)
 292 {
 293         appmgr_pkginfo *info = data;
 294
 295         retv_if(NULL == data, 0);
 296         retv_if(NULL == key, 0);
 297         retv_if(NULL == val, 0);
 298
 299         info->sz_total = atoi(val);
 300         info->sz_data = atoi(key);
 301
 302         appmgrUg_pkg_update_size(info);
 303
 304         return 0;
 305 }
 306
 307 static inline void appmgrUg_pkg_get_pkg_size(appmgr_pkginfo *info)
 308 {
 309         int ret;
 310
 311         ret_if(NULL == info);
 312
 313         if (info->pc_size)
 314                 pkgmgr_client_free(info->pc_size);
 315
 316         info->pc_size = pkgmgr_client_new(PC_REQUEST);
 317         if (NULL == info->pc_size)
 318         {
 319                 SETTING_TRACE_ERROR("pkgmgr_client_new() Fail");
 320                 return;
 321         }
 322
 323         ret = pkgmgr_client_get_size(info->pc_size, info->pkgid, PM_GET_TOTAL_SIZE,
 324                         _appmgrUg_pkg_get_pkg_size, info);
 325         warn_if(ret, "pkgmgr_client_get_size(%s) Fail(%d)", info->pkgid, ret);
 326 }
 327
 328 static void _get_cache_cb(const char *package_id, const pkg_size_info_t *size_info, void *data){
 329         SETTING_TRACE_BEGIN;
 330         retm_if(data == NULL, "data == NULL");
 331         SettingAppMgrUG *ad = data;
 332         appmgr_pkginfo *info = ad->pkginfo;
 333         retm_if(info == NULL, "info == NULL");
 334
 335         info->sz_cache = (int)size_info->cache_size;
 336         SETTING_TRACE("cache size: %lld", size_info->cache_size);
 337         appmgrUg_pkg_update_cache_size(ad);
 338 }
 339
 340 static Eina_Bool __get_pkg_size_on_time(void *data){
 341         SETTING_TRACE_BEGIN;
 342         retvm_if(data == NULL, EINA_FALSE, "Data parameter is NULL");
 343         SettingAppMgrUG *ad = data;
 344         appmgr_pkginfo *info = ad->pkginfo;
 345         retv_if(info == NULL, 0);
 346
 347         //get cache size
 348         if (info->is_disable) {
 349                 //if pkg is disabled, size = 0
 350                 info->sz_cache= 0;
 351                 appmgrUg_pkg_update_cache_size(ad);
 352         } else {
 353                 int ret = package_manager_get_package_size_info(info->pkgid,
 354                                                 _get_cache_cb, ad);
 355                 if (ret != 0) {
 356                         SETTING_TRACE_ERROR("failed to invoke ret = %d", ret);
 357                 }
 358         }
 359
 360         //get pkg total & data size
 361         if (ad->sel_total < 0 || ad->sel_data_size < 0) {
 362                 appmgrUg_pkg_get_pkg_size(info);
 363         } else {
 364                 info->sz_total = ad->sel_total;
 365                 info->sz_data = ad->sel_data_size;
 366                 appmgrUg_pkg_update_size(info);
 367         }
 368
 369         ad->pkginfo_getsize_timer = NULL;
 370         return EINA_FALSE;
 371 }
 372
 373 static int _appmgrUg_pkg_get_info(pkgmgrinfo_pkginfo_h handle, void *data){
 374         retv_if(data == NULL, 0);
 375         SettingAppMgrUG *ad = data;
 376         appmgr_pkginfo *info = ad->pkginfo;
 377         retv_if(info == NULL, 0);
 378
 379         int ret = 0;
 380         char *value = NULL;
 381
 382         //get pkgsize info in timer to avoid block UI
 383         info->sz_cache= -1;
 384         info->sz_total = -1;
 385         info->sz_data = -1;
 386         if (ad->pkginfo_getsize_timer) {
 387                 ecore_timer_del(ad->pkginfo_getsize_timer);
 388                 ad->pkginfo_getsize_timer = NULL;
 389         }
 390         ad->pkginfo_getsize_timer = ecore_timer_add(0.6,
 391                                 (Ecore_Task_Cb) __get_pkg_size_on_time, ad);
 392
 393         //get other info
 394         if (ad->sel_icon) {
 395                 info->icon_path = strdup(ad->sel_icon);
 396         } else {
 397                 value = NULL;
 398                 ret = pkgmgrinfo_pkginfo_get_icon(handle, &value);
 399                 warn_if(ret < 0, "pkgmgrinfo_pkginfo_get_icon() Fail(%d)", ret);
 400                 info->icon_path = appmgrUg_check_icon(value);
 401                 ad->sel_icon = SAFE_STRDUP(info->icon_path);
 402         }
 403
 404         SETTING_TRACE("icon_path : %s", info->icon_path);
 405
 406         value = NULL;
 407         ret = pkgmgrinfo_pkginfo_get_mainappid(handle, &value);
 408         warn_if(ret < 0, "pkgmgrinfo_pkginfo_get_mainappid() Fail(%d)", ret);
 409         info->main_appid = SAFE_STRDUP(value);
 410
 411         ret = pkgmgrinfo_appinfo_get_list(handle, PMINFO_ALL_APP,
 412                         appmgrUg_pkg_get_appinfo_iter, ad);
 413         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_appinfo_get_list() Fail(%d)", ret);
 414
 415         ret = pkgmgrinfo_pkginfo_is_movable(handle, &info->is_movable);
 416         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_is_movable() Fail(%d)", ret);
 417
 418         ret = pkgmgrinfo_pkginfo_is_preload(handle, &info->is_preload);
 419         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_is_preload() Fail(%d)", ret);
 420
 421         ret = pkgmgrinfo_pkginfo_is_update(handle, &info->is_updated);
 422         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_is_update() Fail(%d)", ret);
 423
 424         ret = pkgmgrinfo_pkginfo_get_installed_storage(handle, &info->storage);
 425         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_get_installed_storage() Fail(%d)", ret);
 426
 427         ret = pkgmgrinfo_pkginfo_is_removable(handle, &info->removable);
 428         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_is_removable() Fail(%d)", ret);
 429
 430         value = NULL;
 431         ret = pkgmgrinfo_pkginfo_get_type(handle, &value);
 432         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_get_type() Fail(%d)", ret);
 433         info->pkg_type = SAFE_STRDUP(value);
 434
 435         value = NULL;
 436         ret = pkgmgrinfo_pkginfo_get_version(handle, &value);
 437         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_get_version() Fail(%d)", ret);
 438         info->pkg_version = SAFE_STRDUP(value);
 439
 440         if (ad->sel_label)
 441         {
 442                 info->pkg_label = strdup(ad->sel_label);
 443         }
 444         else
 445         {
 446                 value = NULL;
 447                 ret = pkgmgrinfo_pkginfo_get_label(handle, &value);
 448                 warn_if(ret < 0, "pkgmgrinfo_pkginfo_get_label() Fail(%d)", ret);
 449                 info->pkg_label = SAFE_STRDUP(value);
 450                 ad->sel_label = SAFE_STRDUP(info->pkg_label);
 451         }
 452
 453         ret = pkgmgrinfo_pkginfo_is_support_disable(handle, &info->is_support_disable);
 454         warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_appinfo_is_support_disable() Fail(%d)", ret);
 455
 456         return 0;
 457 }
 458
 459 int appmgrUg_pkg_get_info(SettingAppMgrUG *ad)
 460 {
 461         SETTING_TRACE_BEGIN;
 462         int ret;
 463         appmgr_pkginfo *info;
 464
 465         retv_if(NULL == ad, -1);
 466         retv_if(NULL == ad->sel_pkgid, -1);
 467
 468         info = calloc(1, sizeof(appmgr_pkginfo));
 469         if (NULL == info)
 470         {
 471                 SETTING_TRACE_ERROR("calloc() Fail");
 472                 return -1;
 473         }
 474         ad->pkginfo = info;
 475         info->is_disable = ad->sel_is_disabled;
 476         info->pkgid = strdup(ad->sel_pkgid);
 477
 478         if (info->is_disable) {
 479                 SETTING_TRACE("Get disabled app[%s] info", info->pkgid);
 480                 pkgmgrinfo_pkginfo_filter_h filter_handle;
 481                 int ret = pkgmgrinfo_pkginfo_filter_create(&filter_handle);
 482
 483                 warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_appinfo_filter_create() Fail(%d)", ret);
 484
 485                 ret = pkgmgrinfo_pkginfo_filter_add_bool(filter_handle,
 486                                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, EINA_TRUE);
 487
 488                 warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_appinfo_filter_add_bool() Fail(%d)", ret);
 489
 490                 ret = pkgmgrinfo_pkginfo_filter_add_string(filter_handle,
 491                                                 PMINFO_PKGINFO_PROP_PACKAGE_ID, info->pkgid);
 492
 493                 warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_filter_add_string() Fail(%d)", ret);
 494
 495                 ret = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(filter_handle,
 496                                                 _appmgrUg_pkg_get_info, ad);
 497                 warn_if(PMINFO_R_OK != ret, "pkgmgrinfo_pkginfo_filter_foreach_pkginfo() Fail(%d)", ret);
 498
 499                 pkgmgrinfo_pkginfo_filter_destroy(filter_handle);
 500
 501         } else {
 502                 pkgmgrinfo_pkginfo_h handle;
 503                 ret = pkgmgrinfo_pkginfo_get_pkginfo(info->pkgid, &handle);
 504                 if (PMINFO_R_OK != ret)
 505                 {
 506                         SETTING_TRACE_ERROR("pkgmgrinfo_pkginfo_get_pkginfo() Fail(%d)", ret);
 507                         appmgrUg_pkg_free_pkginfo(info);
 508                         ad->pkginfo = NULL;
 509                         return -1;
 510                 }
 511                 _appmgrUg_pkg_get_info(handle, ad);
 512                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 513         }
 514
 515         return 0;
 516 }
 517
 518 void appmgrUg_pkg_moveto_worker_finish(SettingAppMgrUG *ad)
 519 {
 520         int ret;
 521         void *ret_val;
 522
 523         ret = pthread_join(ad->pkginfo->tid, &ret_val);
 524         if (ret)
 525         {
 526                 SETTING_TRACE_ERROR("pthread_join() Fail(%d)", ret);
 527                 ret = -1;
 528         }
 529         else
 530         {
 531                 ret = (int)ret_val;
 532         }
 533
 534         switch (ret)
 535         {
 536         case PKGMGR_R_OK:
 537                 if (ad->popup)
 538                         evas_object_del(ad->popup);
 539
 540                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 541                                 MGRAPP_STR_MOVE_COMPLETED, appmgrUg_popup_del, 0, 1, MGRAPP_STR_OK);
 542                 setting_view_update(ad->pkginfo_view, ad);
 543                 break;
 544         case APP2EXT_ERROR_MMC_STATUS:
 545         case APP2EXT_ERROR_MMC_INSUFFICIENT_MEMORY:
 546                 SETTING_TRACE_ERROR("moveto() SD_FULL Fail(%d)", ret);
 547                 appmgrUg_fail_popup(MGRAPP_STR_SD_FULL, ad);
 548                 break;
 549         case APP2EXT_ERROR_INVALID_CASE:
 550                 if (PMINFO_INTERNAL_STORAGE == ad->pkginfo->storage)
 551                 {
 552                         SETTING_TRACE_ERROR("moveto() NO_MEM Fail(%d)", ret);
 553                         appmgrUg_fail_popup(MGRAPP_STR_NO_MEM, ad);
 554                         break;
 555                 }
 556         default:
 557                 SETTING_TRACE_ERROR("moveto() Fail(%d)", ret);
 558                 appmgrUg_fail_popup(MGRAPP_STR_MOVE_FAIL, ad);
 559                 break;
 560         }
 561
 562         ad->pkg_request = APPMGRUG_PKG_REQUEST_NONE;
 563 }
 564
 565 void* appmgrUg_pkg_moveto_worker(void *data)
 566 {
 567         int ret;
 568         pkgmgr_client *pc;
 569         appmgr_pkginfo *info;
 570         SettingAppMgrUG *ad = data;
 571         pkgmgr_move_type move_type;
 572
 573         retv_if(NULL == data, NULL);
 574         retv_if(NULL == ad->pkginfo, NULL);
 575
 576         info = ad->pkginfo;
 577
 578         if (PMINFO_INTERNAL_STORAGE == info->storage)
 579                 move_type = PM_MOVE_TO_SDCARD;
 580         else
 581                 move_type = PM_MOVE_TO_INTERNAL;
 582
 583         pc = pkgmgr_client_new(PC_REQUEST);
 584         ret = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type, pc, info->pkg_type,
 585                         info->pkgid, NULL, NULL, NULL);
 586
 587         pkgmgr_client_free(pc);
 588
 589         pthread_exit((void*)ret);
 590 }
 591
 592 static void appmgrUg_pkg_ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 593 {
 594         Evas_Object *base = NULL;
 595
 596         ret_if(priv == NULL);
 597
 598         base = ug_get_layout(ug);
 599         if (base == NULL)
 600         {
 601                 SETTING_TRACE_ERROR("ug_get_layout() Fail");
 602                 return;
 603         }
 604
 605         switch (mode) {
 606         case UG_MODE_FULLVIEW:
 607                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 608                 evas_object_show(base);
 609                 break;
 610         default:
 611                 /* do nothing */
 612                 break;
 613         }
 614 }
 615
 616 static void appmgrUg_pkg_ug_destroy_cb(ui_gadget_h ug, void *priv)
 617 {
 618         SettingAppMgrUG *ad = priv;
 619
 620         ret_if(priv == NULL);
 621
 622         if (ug)
 623                 setting_ug_destroy(ug);
 624
 625         elm_object_tree_focus_allow_set(ad->lo_main, EINA_TRUE);
 626 }
 627
 628 void appmgrUg_pkg_webapp_ug(void *data, Evas_Object *obj, void *event_info)
 629 {
 630         SETTING_TRACE_BEGIN;
 631         app_control_h svc;
 632         ui_gadget_h ug;
 633         struct ug_cbs cbs;
 634         SettingAppMgrUG *ad = data;
 635         Elm_Object_Item *item = event_info;
 636
 637         ret_if(NULL == data);
 638         ret_if(NULL == event_info);
 639
 640         elm_genlist_item_selected_set(item, EINA_FALSE);
 641
 642         if (app_control_create(&svc))
 643                 return;
 644
 645         app_control_add_extra_data(svc, "pkg_name", ad->pkginfo->pkgid);
 646
 647         memset(&cbs, 0, sizeof(struct ug_cbs));
 648         cbs.layout_cb = appmgrUg_pkg_ug_layout_cb;
 649         cbs.result_cb = NULL;
 650         cbs.destroy_cb = appmgrUg_pkg_ug_destroy_cb;
 651         cbs.priv = (void *)ad;
 652
 653         elm_object_tree_focus_allow_set(ad->lo_main, EINA_FALSE);
 654         ug = setting_ug_create(ad->ug, "webapp-detail-efl", UG_MODE_FULLVIEW, svc, &cbs);
 655         warn_if(NULL == ug, "setting_ug_create() Fail");
 656
 657         app_control_destroy(svc);
 658         SETTING_TRACE_END;
 659 }
 660
 661 void appmgrUg_pkg_clear_default(void *data, Evas_Object *obj, void *event_info)
 662 {
 663         GList *cur;
 664         appmgr_pkginfo *info;
 665         SettingAppMgrUG *ad = data;
 666         Elm_Object_Item *next;
 667         Elm_Object_Item *item = event_info;
 668
 669         ret_if(NULL == data);
 670         ret_if(NULL == ad->pkginfo);
 671         ret_if(NULL == event_info);
 672
 673         info = ad->pkginfo;
 674
 675         elm_genlist_item_selected_set(item, EINA_FALSE);
 676
 677         cur = info->appids;
 678         while (cur)
 679         {
 680                 int ret;
 681                 char *appid = cur->data;
 682
 683                 cur = cur->next;
 684
 685                 if (NULL == appid)
 686                         continue;
 687
 688                 ret = appsvc_unset_defapp(appid);
 689                 warn_if(APPSVC_RET_OK != ret, "appsvc_unset_defapp() Fail(%d)", ret);
 690         }
 691
 692         /* clear default separator */
 693         next = elm_genlist_item_next_get(info->def_sep);
 694         elm_object_item_del(info->def_sep);
 695         info->def_sep = NULL;
 696
 697         /* clear default title */
 698         item = next;
 699         next = elm_genlist_item_next_get(next);
 700         elm_object_item_del(item);
 701
 702         /* clear default button */
 703         item = next;
 704         next = elm_genlist_item_next_get(next);
 705         elm_object_item_del(item);
 706
 707         /* clear default notice */
 708         elm_object_item_del(next);
 709
 710         setting_view_update(ad->main_view, ad);
 711 }
 712
 713 char* appmgrUg_pkg_size_gl_label_get(void *data, Evas_Object *obj,
 714                 const char *part)
 715 {
 716         char *label = NULL;
 717         Evas_Object *ao = NULL;
 718         char desc[APPMGRUG_MAX_STR_LEN] = {0};
 719         Setting_GenGroupItem_Data *item_data = data;
 720
 721         retv_if(data == NULL, NULL);
 722
 723         if (0 == strcmp(part, "elm.text.sub.left.bottom"))
 724                 label = SAFE_STRDUP(_(item_data->sub_desc));
 725         else if (0 == strcmp(part, "elm.text.main.left.top"))
 726                 label = SAFE_STRDUP(_(item_data->keyStr));
 727
 728         if (item_data->keyStr && item_data->sub_desc)
 729                 snprintf(desc, sizeof(desc), "%s,%s", _(item_data->keyStr), _(item_data->sub_desc));
 730
 731         ao = elm_object_item_access_object_get(item_data->item);
 732         setting_set_tts_info(ao, desc, "", "", "");
 733
 734         return label;
 735 }