src/app_info.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22
  23 #include <pkgmgr-info.h>
  24 #include <package-manager.h>
  25 #include <dlog.h>
  26
  27 #include "app_info.h"
  28 #include "app_manager.h"
  29 #include "app_manager_internal.h"
  30
  31 #ifdef LOG_TAG
  32 #undef LOG_TAG
  33 #endif
  34
  35 #define LOG_TAG "TIZEN_N_APP_MANAGER"
  36
  37 struct app_info_s {
  38         char *app_id;
  39         pkgmgrinfo_appinfo_h pkg_app_info;
  40 };
  41
  42 struct app_info_filter_s {
  43         pkgmgrinfo_appinfo_filter_h pkg_app_info_filter;
  44 };
  45
  46 struct app_info_metadata_filter_s {
  47         pkgmgrinfo_appinfo_metadata_filter_h pkg_app_info_metadata_filter;
  48 };
  49
  50 typedef struct _foreach_context_ {
  51         app_manager_app_info_cb callback;
  52         void *user_data;
  53 } foreach_context_s;
  54
  55 typedef struct _foreach_metada_context_ {
  56         app_info_metadata_cb callback;
  57         void *user_data;
  58 } foreach_metadata_context_s;
  59
  60 static int app_info_convert_str_property(const char *property, char **converted_property)
  61 {
  62         if (property == NULL)
  63                 return -1;
  64
  65         if (strcmp(property, PACKAGE_INFO_PROP_APP_ID) == 0)
  66                 *converted_property = PMINFO_APPINFO_PROP_APP_ID;
  67
  68         else if (strcmp(property, PACKAGE_INFO_PROP_APP_TYPE) == 0)
  69                 *converted_property = PMINFO_APPINFO_PROP_APP_TYPE;
  70
  71         else if (strcmp(property, PACKAGE_INFO_PROP_APP_CATEGORY) == 0)
  72                 *converted_property = PMINFO_APPINFO_PROP_APP_CATEGORY;
  73
  74         else
  75                 return -1;
  76
  77         return 0;
  78 }
  79
  80 static int app_info_convert_bool_property(const char *property, char **converted_property)
  81 {
  82         if (property == NULL)
  83                 return -1;
  84
  85         if (strcmp(property, PACKAGE_INFO_PROP_APP_NODISPLAY) == 0)
  86                 *converted_property = PMINFO_APPINFO_PROP_APP_NODISPLAY;
  87
  88         else if (strcmp(property, PACKAGE_INFO_PROP_APP_TASKMANAGE) == 0)
  89                 *converted_property = PMINFO_APPINFO_PROP_APP_TASKMANAGE;
  90
  91         else
  92                 return -1;
  93
  94         return 0;
  95 }
  96
  97 static int app_info_foreach_app_filter_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
  98 {
  99         int retval = 0;
 100         char *appid = NULL;
 101         app_info_h info = NULL;
 102
 103         info = calloc(1, sizeof(struct app_info_s));
 104         if (info == NULL)
 105                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 106
 107         foreach_context_s *foreach_context = user_data;
 108         if (handle == NULL || foreach_context == NULL) {
 109                 free(info);
 110                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 111         }
 112
 113         retval = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 114         if (retval < 0) {
 115                 free(info);
 116                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 117         }
 118
 119         info->app_id = strdup(appid);
 120         info->pkg_app_info = handle;
 121
 122         foreach_context->callback(info, foreach_context->user_data);
 123
 124         return APP_MANAGER_ERROR_NONE;
 125 }
 126
 127 static int app_info_foreach_app_metadata_cb(const char *metadata_key, const char *metadata_value, void *user_data)
 128 {
 129         foreach_metadata_context_s *foreach_context = user_data;
 130
 131         if (metadata_value == NULL || foreach_context == NULL)
 132                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 133
 134         foreach_context->callback(metadata_key, metadata_value, foreach_context->user_data);
 135
 136         return APP_MANAGER_ERROR_NONE;
 137 }
 138
 139 static int app_info_foreach_app_info_cb(pkgmgrinfo_appinfo_h handle, void *cb_data)
 140 {
 141         foreach_context_s *foreach_context = cb_data;
 142         app_info_h app_info = NULL;
 143         char *appid = NULL;
 144         int ret = 0;
 145         bool iteration_next = true;
 146
 147         if (handle == NULL || foreach_context == NULL) {
 148                 app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 149                 return PMINFO_R_ERROR;
 150         }
 151
 152         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 153         if (ret != PMINFO_R_OK) {
 154                 app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 155                 return PMINFO_R_ERROR;
 156         }
 157
 158         if (app_info_create(appid, &app_info) == APP_MANAGER_ERROR_NONE) {
 159                 iteration_next = foreach_context->callback(app_info, foreach_context->user_data);
 160                 app_info_destroy(app_info);
 161         }
 162
 163         if (iteration_next == true)
 164                 return PMINFO_R_OK;
 165         else
 166                 return PMINFO_R_ERROR;
 167 }
 168
 169 int app_info_foreach_app_info(app_manager_app_info_cb callback, void *user_data)
 170 {
 171         foreach_context_s foreach_context = {
 172                 .callback = callback,
 173                 .user_data = user_data,
 174         };
 175
 176         if (callback == NULL)
 177                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 178
 179         pkgmgrinfo_appinfo_get_usr_installed_list(app_info_foreach_app_info_cb, getuid(), &foreach_context);
 180
 181         return APP_MANAGER_ERROR_NONE;
 182 }
 183
 184 API int app_info_create(const char *app_id, app_info_h *app_info)
 185 {
 186         pkgmgrinfo_pkginfo_h pkginfo = NULL;
 187         pkgmgrinfo_appinfo_h appinfo = NULL;
 188         app_info_h info = NULL;
 189         int retval = 0;
 190         char *main_appid = NULL;
 191
 192         if (app_id == NULL || app_info == NULL)
 193                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 194
 195         info = calloc(1, sizeof(struct app_info_s));
 196         if (info == NULL)
 197                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 198
 199         retval = pkgmgrinfo_pkginfo_get_usr_pkginfo(app_id, getuid(), &pkginfo);
 200         if (retval < 0) {
 201                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, getuid(), &appinfo)) {
 202                         free(info);
 203                         return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 204                 }
 205
 206                 info->app_id = strdup(app_id);
 207                 info->pkg_app_info = appinfo;
 208                 *app_info = info;
 209                 return APP_MANAGER_ERROR_NONE;
 210         }
 211
 212         retval = pkgmgrinfo_pkginfo_get_mainappid(pkginfo, &main_appid);
 213         if (retval < 0)
 214                 app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 215
 216         if (pkgmgrinfo_appinfo_get_usr_appinfo(main_appid, getuid(), &appinfo)) {
 217                 free(info);
 218                 return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 219         }
 220
 221         info->app_id = strdup(main_appid);
 222         info->pkg_app_info = appinfo;
 223         *app_info = info;
 224
 225         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
 226
 227         return APP_MANAGER_ERROR_NONE;
 228 }
 229
 230 API int app_info_destroy(app_info_h app_info)
 231 {
 232         if (app_info == NULL)
 233                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 234
 235         if (app_info->app_id) {
 236                 free(app_info->app_id);
 237                 app_info->app_id = NULL;
 238         }
 239
 240         pkgmgrinfo_appinfo_destroy_appinfo(app_info->pkg_app_info);
 241         free(app_info);
 242         return APP_MANAGER_ERROR_NONE;
 243 }
 244
 245 API int app_info_get_app_id(app_info_h app_info, char **app_id)
 246 {
 247         char *app_id_dup;
 248
 249         if (app_info == NULL || app_id == NULL)
 250                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 251
 252         app_id_dup = strdup(app_info->app_id);
 253         if (app_id_dup == NULL)
 254                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 255
 256         *app_id = app_id_dup;
 257
 258         return APP_MANAGER_ERROR_NONE;
 259 }
 260
 261 API int app_info_get_exec(app_info_h app_info, char **exec)
 262 {
 263         char *val;
 264         char *app_exec_dup;
 265
 266         if (app_info == NULL || exec == NULL)
 267                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 268
 269         pkgmgrinfo_appinfo_get_exec(app_info->pkg_app_info, &val);
 270         if (val == NULL)
 271                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 272
 273         app_exec_dup = strdup(val);
 274         if (app_exec_dup == NULL)
 275                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 276
 277         *exec = app_exec_dup;
 278
 279         return APP_MANAGER_ERROR_NONE;
 280 }
 281
 282 API int app_info_get_label(app_info_h app_info, char **label)
 283 {
 284         char *val;
 285         char *app_label_dup;
 286
 287         if (app_info == NULL || label == NULL)
 288                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 289
 290         pkgmgrinfo_appinfo_get_label(app_info->pkg_app_info, &val);
 291         if (val == NULL)
 292                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 293
 294         app_label_dup = strdup(val);
 295         if (app_label_dup == NULL)
 296                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 297
 298         *label = app_label_dup;
 299
 300         return APP_MANAGER_ERROR_NONE;
 301 }
 302
 303 API int app_info_get_localed_label(const char *app_id, const char *locale, char **label)
 304 {
 305         char *val;
 306         char *app_label_dup;
 307
 308         if (app_id == NULL || locale == NULL || label == NULL)
 309                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 310
 311         if (pkgmgrinfo_appinfo_usr_get_localed_label(app_id, locale, getuid(), &val))
 312                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 313
 314         app_label_dup = strdup(val);
 315         if (app_label_dup == NULL)
 316                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 317
 318         *label = app_label_dup;
 319         free(val);
 320
 321         return APP_MANAGER_ERROR_NONE;
 322 }
 323
 324 API int app_info_get_icon(app_info_h app_info, char **path)
 325 {
 326         char *val;
 327         char *app_icon_dup;
 328
 329         if (app_info == NULL || path == NULL)
 330                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 331
 332         pkgmgrinfo_appinfo_get_icon(app_info->pkg_app_info, &val);
 333         if (val == NULL)
 334                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 335
 336         app_icon_dup = strdup(val);
 337         if (app_icon_dup == NULL)
 338                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 339
 340         *path = app_icon_dup;
 341
 342         return APP_MANAGER_ERROR_NONE;
 343 }
 344
 345 API int app_info_get_package(app_info_h app_info, char **package)
 346 {
 347         char *val;
 348         char *app_package_dup;
 349
 350         if (app_info == NULL || package == NULL)
 351                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 352
 353         pkgmgrinfo_appinfo_get_pkgname(app_info->pkg_app_info, &val);
 354
 355         app_package_dup = strdup(val);
 356         if (app_package_dup == NULL)
 357                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 358
 359         *package = app_package_dup;
 360
 361         return APP_MANAGER_ERROR_NONE;
 362 }
 363
 364 API int app_info_get_type(app_info_h app_info, char **type)
 365 {
 366         char *val;
 367         char *app_type_dup;
 368
 369         if (app_info == NULL || type == NULL)
 370                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 371
 372         pkgmgrinfo_appinfo_get_apptype(app_info->pkg_app_info, &val);
 373
 374         app_type_dup = strdup(val);
 375         if (app_type_dup == NULL)
 376                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 377
 378         *type = app_type_dup;
 379
 380         return APP_MANAGER_ERROR_NONE;
 381 }
 382
 383 API int app_info_foreach_metadata(app_info_h app_info, app_info_metadata_cb callback, void *user_data)
 384 {
 385         int retval = 0;
 386
 387         if (app_info == NULL || callback == NULL)
 388                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 389
 390         foreach_metadata_context_s foreach_context = {
 391                 .callback = callback,
 392                 .user_data = user_data,
 393         };
 394
 395         retval = pkgmgrinfo_appinfo_foreach_metadata(app_info->pkg_app_info, app_info_foreach_app_metadata_cb, &foreach_context);
 396         if (retval < 0)
 397                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 398
 399         return APP_MANAGER_ERROR_NONE;
 400 }
 401
 402 API int app_info_is_nodisplay(app_info_h app_info, bool *nodisplay)
 403 {
 404         bool val;
 405
 406         if (app_info == NULL || nodisplay == NULL)
 407                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 408
 409         if (pkgmgrinfo_appinfo_is_nodisplay(app_info->pkg_app_info, &val) < 0)
 410                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 411
 412         *nodisplay = val;
 413         return APP_MANAGER_ERROR_NONE;
 414 }
 415
 416 API int app_info_is_enabled(app_info_h app_info, bool *enabled)
 417 {
 418         bool val;
 419
 420         if (app_info == NULL || enabled == NULL)
 421                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 422
 423         if (pkgmgrinfo_appinfo_is_enabled(app_info->pkg_app_info, &val) < 0)
 424                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 425
 426         *enabled = val;
 427         return APP_MANAGER_ERROR_NONE;
 428
 429 }
 430
 431 API int app_info_is_equal(app_info_h lhs, app_info_h rhs, bool *equal)
 432 {
 433         if (lhs == NULL || rhs == NULL || equal == NULL)
 434                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 435
 436         if (!strcmp(lhs->app_id, rhs->app_id))
 437                 *equal = true;
 438         else
 439                 *equal = false;
 440
 441         return APP_MANAGER_ERROR_NONE;
 442 }
 443
 444 API int app_info_is_onboot(app_info_h app_info, bool *onboot)
 445 {
 446         bool val;
 447
 448         if (app_info == NULL || onboot == NULL)
 449                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 450
 451         if (pkgmgrinfo_appinfo_is_onboot(app_info->pkg_app_info, &val) < 0)
 452                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 453
 454         *onboot = val;
 455         return APP_MANAGER_ERROR_NONE;
 456 }
 457
 458 API int app_info_is_preload(app_info_h app_info, bool *preload)
 459 {
 460         bool val;
 461
 462         if (app_info == NULL || preload == NULL)
 463                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 464
 465         if (pkgmgrinfo_appinfo_is_preload(app_info->pkg_app_info, &val) < 0)
 466                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 467
 468         *preload = val;
 469         return APP_MANAGER_ERROR_NONE;
 470 }
 471
 472 API int app_info_clone(app_info_h *clone, app_info_h app_info)
 473 {
 474         int retval;
 475
 476         if (clone == NULL || app_info == NULL)
 477                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 478
 479         retval = app_info_create(app_info->app_id, clone);
 480
 481         if (retval != APP_MANAGER_ERROR_NONE)
 482                 return app_manager_error(retval, __FUNCTION__, NULL);
 483
 484         return APP_MANAGER_ERROR_NONE;
 485 }
 486
 487 API int app_info_filter_create(app_info_filter_h *handle)
 488 {
 489         int retval = 0;
 490         app_info_filter_h filter_created = NULL;
 491         pkgmgrinfo_appinfo_filter_h filter_h = NULL;
 492
 493         if (handle == NULL)
 494                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 495
 496         retval = pkgmgrinfo_appinfo_filter_create(&filter_h);
 497         if (retval < 0)
 498                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 499
 500         filter_created = calloc(1, sizeof(struct app_info_filter_s));
 501         if (filter_created == NULL) {
 502                 free(filter_h);
 503                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 504         }
 505
 506         filter_created->pkg_app_info_filter = filter_h;
 507
 508         *handle = filter_created;
 509
 510         return APP_MANAGER_ERROR_NONE;
 511 }
 512
 513 API int app_info_filter_destroy(app_info_filter_h handle)
 514 {
 515         int retval = 0;
 516
 517         if (handle == NULL)
 518                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 519
 520         retval = pkgmgrinfo_appinfo_filter_destroy(handle->pkg_app_info_filter);
 521         if (retval < 0)
 522                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 523
 524         free(handle);
 525         return APP_MANAGER_ERROR_NONE;
 526 }
 527
 528 API int app_info_filter_add_bool(app_info_filter_h handle, const char *property, const bool value)
 529 {
 530         int retval = 0;
 531         char *converted_property = NULL;
 532
 533         if ((handle == NULL) || (property == NULL))
 534                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 535
 536         retval = app_info_convert_bool_property(property, &converted_property);
 537         if (retval < 0)
 538                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 539
 540         retval = pkgmgrinfo_appinfo_filter_add_bool(handle->pkg_app_info_filter, converted_property, value);
 541         if (retval < 0)
 542                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 543
 544         return APP_MANAGER_ERROR_NONE;
 545 }
 546
 547 API int app_info_filter_add_string(app_info_filter_h handle, const char *property, const char *value)
 548 {
 549         int retval = 0;
 550         char *converted_property = NULL;
 551
 552         if ((handle == NULL) || (property == NULL))
 553                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 554
 555         retval = app_info_convert_str_property(property, &converted_property);
 556         if (retval < 0)
 557                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 558
 559         retval = pkgmgrinfo_appinfo_filter_add_string(handle->pkg_app_info_filter, converted_property, value);
 560         if (retval < 0)
 561                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 562
 563         return APP_MANAGER_ERROR_NONE;
 564 }
 565
 566 API int app_info_filter_count_appinfo(app_info_filter_h handle, int *count)
 567 {
 568         int retval = 0;
 569
 570         if ((handle == NULL) || (count == NULL))
 571                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 572
 573         retval = pkgmgrinfo_appinfo_filter_count(handle->pkg_app_info_filter, count);
 574         if (retval < 0)
 575                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 576
 577         return APP_MANAGER_ERROR_NONE;
 578 }
 579
 580 API int app_info_filter_foreach_appinfo(app_info_filter_h handle, app_info_filter_cb callback, void * user_data)
 581 {
 582         int retval = 0;
 583
 584         foreach_context_s foreach_context = {
 585                 .callback = callback,
 586                 .user_data = user_data,
 587         };
 588
 589         if ((handle == NULL) || (callback == NULL))
 590                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 591
 592         retval = pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(handle->pkg_app_info_filter, app_info_foreach_app_filter_cb, &foreach_context, getuid());
 593         if (retval < 0)
 594                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 595
 596         return APP_MANAGER_ERROR_NONE;
 597 }
 598
 599 API int app_info_metadata_filter_create(app_info_metadata_filter_h *handle)
 600 {
 601         int retval = 0;
 602         app_info_metadata_filter_h filter_created = NULL;
 603         pkgmgrinfo_appinfo_metadata_filter_h filter_h = NULL;
 604
 605         if (handle == NULL)
 606                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 607
 608         filter_created = calloc(1, sizeof(struct app_info_metadata_filter_s));
 609         if (filter_created == NULL)
 610                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 611
 612         retval = pkgmgrinfo_appinfo_metadata_filter_create(&filter_h);
 613         if (retval < 0) {
 614                 free(filter_created);
 615                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 616         }
 617
 618         filter_created->pkg_app_info_metadata_filter = filter_h;
 619
 620         *handle = filter_created;
 621
 622         return APP_MANAGER_ERROR_NONE;
 623 }
 624
 625 API int app_info_metadata_filter_destroy(app_info_metadata_filter_h handle)
 626 {
 627         int retval = 0;
 628
 629         if (handle == NULL)
 630                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 631
 632         retval = pkgmgrinfo_appinfo_metadata_filter_destroy(handle->pkg_app_info_metadata_filter);
 633         if (retval < 0)
 634                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 635
 636         free(handle);
 637         return APP_MANAGER_ERROR_NONE;
 638 }
 639
 640 API int app_info_metadata_filter_add(app_info_metadata_filter_h handle, const char *key, const char *value)
 641 {
 642         int retval = 0;
 643
 644         if ((handle == NULL) || (key == NULL))
 645                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 646
 647         retval = pkgmgrinfo_appinfo_metadata_filter_add(handle->pkg_app_info_metadata_filter, key, value);
 648         if (retval < 0)
 649                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 650
 651         return APP_MANAGER_ERROR_NONE;
 652 }
 653
 654 API int app_info_metadata_filter_foreach(app_info_metadata_filter_h handle, app_info_filter_cb callback, void *user_data)
 655 {
 656         int retval = 0;
 657
 658         foreach_context_s foreach_context = {
 659                 .callback = callback,
 660                 .user_data = user_data,
 661         };
 662
 663         if (handle == NULL)
 664                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 665
 666         if (callback == NULL)
 667                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 668
 669         retval = pkgmgrinfo_appinfo_usr_metadata_filter_foreach(handle->pkg_app_info_metadata_filter, app_info_foreach_app_filter_cb, &foreach_context, getuid());
 670         if (retval < 0)
 671                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 672
 673         return APP_MANAGER_ERROR_NONE;
 674 }