src/rua_info.c

   1 /*
   2  * Copyright (c) 2019 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 #define _GNU_SOURCE
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22
  23 #include <glib.h>
  24 #include <pkgmgr-info.h>
  25 #include <aul.h>
  26 #include <aul_comp_info.h>
  27
  28 #include "rua.h"
  29 #include "rua_private.h"
  30 #include "rua_info.h"
  31 #include "rua_info_internal.h"
  32
  33 #define RUA_INFO_START 0
  34
  35 enum rua_info_e {
  36         RUA_INFO_APP_ID = RUA_INFO_START,
  37         RUA_INFO_APP_PATH,
  38         RUA_INFO_ARGS,
  39         RUA_INFO_LAUNCH_TIME,
  40         RUA_INFO_INSTANCE_ID,
  41         RUA_INFO_INSTANCE_NAME,
  42         RUA_INFO_ICON,
  43         RUA_INFO_URI,
  44         RUA_INFO_IMAGE,
  45         RUA_INFO_COMPONENT_ID,
  46         RUA_INFO_APP_INFO,
  47         RUA_INFO_COMP_INFO,
  48         RUA_INFO_MAX,
  49 };
  50
  51 struct rua_info_s {
  52         char *value[RUA_INFO_MAX];
  53 };
  54
  55 typedef int (*rua_info_add_cb)(struct rua_rec *rec,
  56                 struct rua_info_s *info);
  57 typedef void (*rua_info_remove_cb)(void *data);
  58 typedef int (*rua_info_clone_cb)(struct rua_info_s *info,
  59                 struct rua_info_s *clone);
  60
  61 typedef struct _rua_info_vft {
  62         rua_info_add_cb ctor;
  63         rua_info_remove_cb dtor;
  64         rua_info_clone_cb clnr;
  65 } rua_info_vft;
  66
  67 static int __rua_info_add_app_id(struct rua_rec *rec,
  68                 struct rua_info_s *info)
  69 {
  70         info->value[RUA_INFO_APP_ID] = strdup(rec->pkg_name);
  71         if (!info->value[RUA_INFO_APP_ID]) {
  72                 _E("Out of memory");
  73                 return RUA_ERROR_OUT_OF_MEMORY;
  74         }
  75
  76         return RUA_ERROR_NONE;
  77 }
  78
  79 static int __rua_info_add_app_path(struct rua_rec *rec,
  80                 struct rua_info_s *info)
  81 {
  82         info->value[RUA_INFO_APP_PATH] = strdup(rec->app_path);
  83         if (!info->value[RUA_INFO_APP_PATH]) {
  84                 _E("Out of memory");
  85                 return RUA_ERROR_OUT_OF_MEMORY;
  86         }
  87
  88         return RUA_ERROR_NONE;
  89 }
  90
  91 static int __rua_info_add_args(struct rua_rec *rec,
  92                 struct rua_info_s *info)
  93 {
  94         info->value[RUA_INFO_ARGS] = strdup(rec->arg);
  95         if (!info->value[RUA_INFO_ARGS]) {
  96                 _E("Out of memory");
  97                 return RUA_ERROR_OUT_OF_MEMORY;
  98         }
  99
 100         return RUA_ERROR_NONE;
 101 }
 102
 103 static int __rua_info_add_launch_time(struct rua_rec *rec,
 104                 struct rua_info_s *info)
 105 {
 106         info->value[RUA_INFO_LAUNCH_TIME] = GINT_TO_POINTER(rec->launch_time);
 107
 108         return RUA_ERROR_NONE;
 109 }
 110
 111 static int __rua_info_add_instance_id(struct rua_rec *rec,
 112                 struct rua_info_s *info)
 113 {
 114         if (!rec->instance_id)
 115                 return RUA_ERROR_NONE;
 116
 117         info->value[RUA_INFO_INSTANCE_ID] = strdup(rec->instance_id);
 118         if (!info->value[RUA_INFO_INSTANCE_ID]) {
 119                 _E("Out of memory");
 120                 return RUA_ERROR_OUT_OF_MEMORY;
 121         }
 122
 123         return RUA_ERROR_NONE;
 124 }
 125
 126 static int __rua_info_add_instance_name(struct rua_rec *rec,
 127                 struct rua_info_s *info)
 128 {
 129         if (!rec->instance_name)
 130                 return RUA_ERROR_NONE;
 131
 132         info->value[RUA_INFO_INSTANCE_NAME] = strdup(rec->instance_name);
 133         if (!info->value[RUA_INFO_INSTANCE_NAME]) {
 134                 _E("Out of memory");
 135                 return RUA_ERROR_OUT_OF_MEMORY;
 136         }
 137
 138         return RUA_ERROR_NONE;
 139 }
 140
 141 static int __rua_info_add_icon(struct rua_rec *rec, struct rua_info_s *info)
 142 {
 143         if (!rec->icon)
 144                 return RUA_ERROR_NONE;
 145
 146         info->value[RUA_INFO_ICON] = strdup(rec->icon);
 147         if (!info->value[RUA_INFO_ICON]) {
 148                 _E("Out of memory");
 149                 return RUA_ERROR_OUT_OF_MEMORY;
 150         }
 151
 152         return RUA_ERROR_NONE;
 153 }
 154
 155 static int __rua_info_add_uri(struct rua_rec *rec, struct rua_info_s *info)
 156 {
 157         if (!rec->uri)
 158                 return RUA_ERROR_NONE;
 159
 160         info->value[RUA_INFO_URI] = strdup(rec->uri);
 161         if (!info->value[RUA_INFO_URI]) {
 162                 _E("Ouf of memory");
 163                 return RUA_ERROR_OUT_OF_MEMORY;
 164         }
 165
 166         return RUA_ERROR_NONE;
 167 }
 168
 169 static int __rua_info_add_image(struct rua_rec *rec, struct rua_info_s *info)
 170 {
 171         if (!rec->image)
 172                 return RUA_ERROR_NONE;
 173
 174         info->value[RUA_INFO_IMAGE] = strdup(rec->image);
 175         if (!info->value[RUA_INFO_IMAGE]) {
 176                 _E("Out of memory");
 177                 return RUA_ERROR_OUT_OF_MEMORY;
 178         }
 179
 180         return RUA_ERROR_NONE;
 181 }
 182
 183 static int __rua_info_add_component_id(struct rua_rec *rec,
 184                 struct rua_info_s *info)
 185 {
 186         if (!rec->comp_id)
 187                 return RUA_ERROR_NONE;
 188
 189         info->value[RUA_INFO_COMPONENT_ID] = strdup(rec->comp_id);
 190         if (!info->value[RUA_INFO_COMPONENT_ID]) {
 191                 _E("Out of memory");
 192                 return RUA_ERROR_OUT_OF_MEMORY;
 193         }
 194
 195         return RUA_ERROR_NONE;
 196 }
 197
 198 static int __rua_info_add_app_info(struct rua_rec *rec,
 199                 struct rua_info_s *info)
 200 {
 201         pkgmgrinfo_appinfo_h app_info;
 202         int ret;
 203
 204         ret = pkgmgrinfo_appinfo_get_appinfo(rec->pkg_name, &app_info);
 205         if (ret != PMINFO_R_OK) {
 206                 _E("Failed to get appinfo");
 207                 return RUA_ERROR_IO_ERROR;
 208         }
 209
 210         info->value[RUA_INFO_APP_INFO] = app_info;
 211
 212         return RUA_ERROR_NONE;
 213 }
 214
 215 static int __rua_info_add_comp_info(struct rua_rec *rec,
 216                 struct rua_info_s *info)
 217 {
 218         aul_comp_info_h comp_info;
 219         int ret;
 220
 221         if (!rec->comp_id)
 222                 return RUA_ERROR_NONE;
 223
 224         ret = aul_comp_info_create(rec->comp_id, &comp_info);
 225         if (ret != AUL_R_OK) {
 226                 _E("Failed to create comp info");
 227                 return RUA_ERROR_IO_ERROR;
 228         }
 229
 230         info->value[RUA_INFO_COMP_INFO] = comp_info;
 231
 232         return RUA_ERROR_NONE;
 233 }
 234
 235 static void __rua_info_remove_app_info(void *data)
 236 {
 237         pkgmgrinfo_appinfo_h app_info;
 238
 239         app_info = (pkgmgrinfo_appinfo_h)data;
 240         pkgmgrinfo_appinfo_destroy_appinfo(app_info);
 241 }
 242
 243 static void __rua_info_remove_comp_info(void *data)
 244 {
 245         aul_comp_info_h comp_info;
 246
 247         comp_info = (aul_comp_info_h)data;
 248         aul_comp_info_destroy(comp_info);
 249 }
 250
 251 static int __rua_info_clone_app_id(struct rua_info_s *info,
 252                 struct rua_info_s *clone)
 253 {
 254         clone->value[RUA_INFO_APP_ID] = strdup(info->value[RUA_INFO_APP_ID]);
 255         if (!clone->value[RUA_INFO_APP_ID]) {
 256                 _E("Out of memory");
 257                 return RUA_ERROR_OUT_OF_MEMORY;
 258         }
 259
 260         return RUA_ERROR_NONE;
 261 }
 262
 263 static int __rua_info_clone_app_path(struct rua_info_s *info,
 264                 struct rua_info_s *clone)
 265 {
 266         clone->value[RUA_INFO_APP_PATH] =
 267                 strdup(info->value[RUA_INFO_APP_PATH]);
 268         if (!clone->value[RUA_INFO_APP_PATH]) {
 269                 _E("Out of memory");
 270                 return RUA_ERROR_OUT_OF_MEMORY;
 271         }
 272
 273         return RUA_ERROR_NONE;
 274 }
 275
 276 static int __rua_info_clone_args(struct rua_info_s *info,
 277                 struct rua_info_s *clone)
 278 {
 279         clone->value[RUA_INFO_ARGS] = strdup(info->value[RUA_INFO_ARGS]);
 280         if (!clone->value[RUA_INFO_ARGS]) {
 281                 _E("Out of memory");
 282                 return RUA_ERROR_OUT_OF_MEMORY;
 283         }
 284
 285         return RUA_ERROR_NONE;
 286 }
 287
 288 static int __rua_info_clone_launch_time(struct rua_info_s *info,
 289                 struct rua_info_s *clone)
 290 {
 291         clone->value[RUA_INFO_LAUNCH_TIME] = info->value[RUA_INFO_LAUNCH_TIME];
 292
 293         return RUA_ERROR_NONE;
 294 }
 295
 296 static int __rua_info_clone_instance_id(struct rua_info_s *info,
 297                 struct rua_info_s *clone)
 298 {
 299         if (!info->value[RUA_INFO_INSTANCE_ID])
 300                 return RUA_ERROR_NONE;
 301
 302         clone->value[RUA_INFO_INSTANCE_ID] =
 303                 strdup(info->value[RUA_INFO_INSTANCE_ID]);
 304         if (!clone->value[RUA_INFO_INSTANCE_ID]) {
 305                 _E("Out of memory");
 306                 return RUA_ERROR_OUT_OF_MEMORY;
 307         }
 308
 309         return RUA_ERROR_NONE;
 310 }
 311
 312 static int __rua_info_clone_instance_name(struct rua_info_s *info,
 313                 struct rua_info_s *clone)
 314 {
 315         if (!info->value[RUA_INFO_INSTANCE_NAME])
 316                 return RUA_ERROR_NONE;
 317
 318         clone->value[RUA_INFO_INSTANCE_NAME] =
 319                 strdup(info->value[RUA_INFO_INSTANCE_NAME]);
 320         if (!clone->value[RUA_INFO_INSTANCE_NAME]) {
 321                 _E("Out of memory");
 322                 return RUA_ERROR_OUT_OF_MEMORY;
 323         }
 324
 325         return RUA_ERROR_NONE;
 326 }
 327
 328 static int __rua_info_clone_icon(struct rua_info_s *info,
 329                 struct rua_info_s *clone)
 330 {
 331         if (!info->value[RUA_INFO_ICON])
 332                 return RUA_ERROR_NONE;
 333
 334         clone->value[RUA_INFO_ICON] = strdup(info->value[RUA_INFO_ICON]);
 335         if (!clone->value[RUA_INFO_ICON]) {
 336                 _E("Out of memory");
 337                 return RUA_ERROR_OUT_OF_MEMORY;
 338         }
 339
 340         return RUA_ERROR_NONE;
 341 }
 342
 343 static int __rua_info_clone_uri(struct rua_info_s *info,
 344                 struct rua_info_s *clone)
 345 {
 346         if (!info->value[RUA_INFO_URI])
 347                 return RUA_ERROR_NONE;
 348
 349         clone->value[RUA_INFO_URI] = strdup(info->value[RUA_INFO_URI]);
 350         if (!clone->value[RUA_INFO_URI]) {
 351                 _E("Out of memory");
 352                 return RUA_ERROR_OUT_OF_MEMORY;
 353         }
 354
 355         return RUA_ERROR_NONE;
 356 }
 357
 358 static int __rua_info_clone_image(struct rua_info_s *info,
 359                 struct rua_info_s *clone)
 360 {
 361         if (!info->value[RUA_INFO_IMAGE])
 362                 return RUA_ERROR_NONE;
 363
 364         clone->value[RUA_INFO_IMAGE] = strdup(info->value[RUA_INFO_IMAGE]);
 365         if (!clone->value[RUA_INFO_IMAGE]) {
 366                 _E("Out of memory");
 367                 return RUA_ERROR_OUT_OF_MEMORY;
 368         }
 369
 370         return RUA_ERROR_NONE;
 371 }
 372
 373 static int __rua_info_clone_component_id(struct rua_info_s *info,
 374                 struct rua_info_s *clone)
 375 {
 376         if (!info->value[RUA_INFO_COMPONENT_ID])
 377                 return RUA_ERROR_NONE;
 378
 379         clone->value[RUA_INFO_COMPONENT_ID] =
 380                 strdup(info->value[RUA_INFO_COMPONENT_ID]);
 381         if (!clone->value[RUA_INFO_COMPONENT_ID]) {
 382                 _E("Out of memory");
 383                 return RUA_ERROR_OUT_OF_MEMORY;
 384         }
 385
 386         return RUA_ERROR_NONE;
 387 }
 388
 389 static int __rua_info_clone_app_info(struct rua_info_s *info,
 390                 struct rua_info_s *clone)
 391 {
 392         pkgmgrinfo_appinfo_h app_info;
 393         int ret;
 394
 395         ret = pkgmgrinfo_appinfo_clone_appinfo(
 396                         info->value[RUA_INFO_APP_INFO],
 397                         &app_info);
 398         if (ret != RUA_ERROR_NONE) {
 399                 _E("Failed to clone app info");
 400                 return RUA_ERROR_OUT_OF_MEMORY;
 401         }
 402
 403         clone->value[RUA_INFO_APP_INFO] = app_info;
 404
 405         return RUA_ERROR_NONE;
 406 }
 407
 408 static int __rua_info_clone_comp_info(struct rua_info_s *info,
 409                 struct rua_info_s *clone)
 410 {
 411         aul_comp_info_h comp_info;
 412         int ret;
 413
 414         if (!info->value[RUA_INFO_COMP_INFO])
 415                 return RUA_ERROR_NONE;
 416
 417         ret = aul_comp_info_clone(info->value[RUA_INFO_COMP_INFO],
 418                         &comp_info);
 419         if (ret != RUA_ERROR_NONE) {
 420                 _E("Failed to clone comp info");
 421                 return RUA_ERROR_OUT_OF_MEMORY;
 422         }
 423
 424         clone->value[RUA_INFO_COMP_INFO] = comp_info;
 425
 426         return RUA_ERROR_NONE;
 427 }
 428
 429 static rua_info_vft __rua_table[] = {
 430         [RUA_INFO_APP_ID] = {
 431                 .ctor = __rua_info_add_app_id,
 432                 .dtor = free,
 433                 .clnr = __rua_info_clone_app_id
 434         },
 435         [RUA_INFO_APP_PATH] = {
 436                 .ctor = __rua_info_add_app_path,
 437                 .dtor = free,
 438                 .clnr = __rua_info_clone_app_path
 439         },
 440         [RUA_INFO_ARGS] = {
 441                 .ctor = __rua_info_add_args,
 442                 .dtor = free,
 443                 .clnr = __rua_info_clone_args
 444         },
 445         [RUA_INFO_LAUNCH_TIME] = {
 446                 .ctor = __rua_info_add_launch_time,
 447                 .dtor = NULL,
 448                 .clnr = __rua_info_clone_launch_time
 449         },
 450         [RUA_INFO_INSTANCE_ID] = {
 451                 .ctor = __rua_info_add_instance_id,
 452                 .dtor = free,
 453                 .clnr = __rua_info_clone_instance_id
 454         },
 455         [RUA_INFO_INSTANCE_NAME] = {
 456                 .ctor = __rua_info_add_instance_name,
 457                 .dtor = free,
 458                 .clnr = __rua_info_clone_instance_name
 459         },
 460         [RUA_INFO_ICON] = {
 461                 .ctor = __rua_info_add_icon,
 462                 .dtor = free,
 463                 .clnr = __rua_info_clone_icon
 464         },
 465         [RUA_INFO_URI] = {
 466                 .ctor = __rua_info_add_uri,
 467                 .dtor = free,
 468                 .clnr = __rua_info_clone_uri
 469         },
 470         [RUA_INFO_IMAGE] = {
 471                 .ctor = __rua_info_add_image,
 472                 .dtor = free,
 473                 .clnr = __rua_info_clone_image
 474         },
 475         [RUA_INFO_COMPONENT_ID] = {
 476                 .ctor = __rua_info_add_component_id,
 477                 .dtor = free,
 478                 .clnr = __rua_info_clone_component_id
 479         },
 480         [RUA_INFO_APP_INFO] = {
 481                 .ctor = __rua_info_add_app_info,
 482                 .dtor = __rua_info_remove_app_info,
 483                 .clnr = __rua_info_clone_app_info
 484         },
 485         [RUA_INFO_COMP_INFO] = {
 486                 .ctor = __rua_info_add_comp_info,
 487                 .dtor = __rua_info_remove_comp_info,
 488                 .clnr = __rua_info_clone_comp_info
 489         },
 490 };
 491
 492 static void __destroy_rua_info(gpointer data)
 493 {
 494         struct rua_info_s *info = (struct rua_info_s *)data;
 495         int i;
 496
 497         if (!info)
 498                 return;
 499
 500         for (i = RUA_INFO_START; i < RUA_INFO_MAX; ++i) {
 501                 if (!__rua_table[i].dtor)
 502                         continue;
 503
 504                 __rua_table[i].dtor(info->value[i]);
 505         }
 506
 507         free(info);
 508 }
 509
 510 static struct rua_info_s *__create_rua_info(struct rua_rec *rec)
 511 {
 512         struct rua_info_s *info;
 513         int ret;
 514         int i;
 515
 516         info = calloc(1, sizeof(struct rua_info_s));
 517         if (!info) {
 518                 _E("Out of memory");
 519                 return NULL;
 520         }
 521
 522         for (i = RUA_INFO_START; i < RUA_INFO_MAX; ++i) {
 523                 if (!__rua_table[i].ctor)
 524                         continue;
 525
 526                 ret = __rua_table[i].ctor(rec, info);
 527                 if (ret != RUA_ERROR_NONE) {
 528                         __destroy_rua_info(info);
 529                         return NULL;
 530                 }
 531         }
 532
 533         return info;
 534 }
 535
 536 static struct rua_info_s *__clone_rua_info(struct rua_info_s *info)
 537 {
 538         struct rua_info_s *clone;
 539         int ret;
 540         int i;
 541
 542         clone = calloc(1, sizeof(struct rua_info_s));
 543         if (!clone) {
 544                 _E("Out of memory");
 545                 return NULL;
 546         }
 547
 548         for (i = RUA_INFO_START; i < RUA_INFO_MAX; ++i) {
 549                 if (!__rua_table[i].clnr)
 550                         continue;
 551
 552                 ret = __rua_table[i].clnr(info, clone);
 553                 if (ret != RUA_ERROR_NONE) {
 554                         __destroy_rua_info(clone);
 555                         return NULL;
 556                 }
 557         }
 558
 559         return clone;
 560 }
 561
 562 int rua_info_foreach(rua_manager_rua_info_cb callback, void *user_data)
 563 {
 564         return rua_info_usr_foreach(getuid(), callback, user_data);
 565 }
 566
 567 int rua_info_usr_foreach(uid_t uid, rua_manager_rua_info_cb callback,
 568                 void *user_data)
 569 {
 570         struct rua_info_s *info;
 571         struct rua_rec rec;
 572         GList *list = NULL;
 573         GList *iter;
 574         char **table = NULL;
 575         int nrows = 0;
 576         int ncols = 0;
 577         int row;
 578         int ret;
 579
 580         if (!callback) {
 581                 _E("Invalid parameter");
 582                 return RUA_ERROR_INVALID_PARAMETER;
 583         }
 584
 585         ret = rua_history_load_db_for_uid(&table, &nrows, &ncols, uid);
 586         if (ret < 0) {
 587                 _E("Failed to load rua history");
 588                 return RUA_ERROR_IO_ERROR;
 589         }
 590
 591         for (row = 0; row < nrows; ++row) {
 592                 rua_history_get_rec(&rec, table, nrows, ncols, row);
 593                 info = __create_rua_info(&rec);
 594                 if (info)
 595                         list = g_list_append(list, info);
 596         }
 597
 598         rua_history_unload_db(&table);
 599
 600         iter = list;
 601         while (iter) {
 602                 info = (struct rua_info_s *)iter->data;
 603                 if (!callback(info, user_data))
 604                         break;
 605
 606                 iter = g_list_next(iter);
 607         }
 608
 609         g_list_free_full(list, __destroy_rua_info);
 610
 611         return RUA_ERROR_NONE;
 612 }
 613
 614 API int rua_info_get_app_id(rua_info_h info, char **app_id)
 615 {
 616         if (!info || !app_id) {
 617                 _E("Invalid parameter");
 618                 return RUA_ERROR_INVALID_PARAMETER;
 619         }
 620
 621         *app_id = strdup(info->value[RUA_INFO_APP_ID]);
 622         if (*app_id == NULL) {
 623                 _E("Out of memory");
 624                 return RUA_ERROR_OUT_OF_MEMORY;
 625         }
 626
 627         return RUA_ERROR_NONE;
 628 }
 629
 630 API int rua_info_get_app_path(rua_info_h info, char **app_path)
 631 {
 632         if (!info || !app_path) {
 633                 _E("Invalid parameter");
 634                 return RUA_ERROR_INVALID_PARAMETER;
 635         }
 636
 637         *app_path = strdup(info->value[RUA_INFO_APP_PATH]);
 638         if (*app_path == NULL) {
 639                 _E("Out of memory");
 640                 return RUA_ERROR_OUT_OF_MEMORY;
 641         }
 642
 643         return RUA_ERROR_NONE;
 644 }
 645
 646 API int rua_info_get_args(rua_info_h info, char **args)
 647 {
 648         if (!info || !args) {
 649                 _E("Invalid parameter");
 650                 return RUA_ERROR_INVALID_PARAMETER;
 651         }
 652
 653         *args = strdup(info->value[RUA_INFO_ARGS]);
 654         if (*args == NULL) {
 655                 _E("Out of memory");
 656                 return RUA_ERROR_OUT_OF_MEMORY;
 657         }
 658
 659         return RUA_ERROR_NONE;
 660 }
 661
 662 API int rua_info_get_launch_time(rua_info_h info, time_t *launch_time)
 663 {
 664         if (!info || !launch_time) {
 665                 _E("Invalid parameter");
 666                 return RUA_ERROR_INVALID_PARAMETER;
 667         }
 668
 669         *launch_time = GPOINTER_TO_INT(info->value[RUA_INFO_LAUNCH_TIME]);
 670
 671         return RUA_ERROR_NONE;
 672 }
 673
 674 API int rua_info_get_instance_id(rua_info_h info, char **instance_id)
 675 {
 676         if (!info || !instance_id) {
 677                 _E("Invalid parameter");
 678                 return RUA_ERROR_INVALID_PARAMETER;
 679         }
 680
 681         if (info->value[RUA_INFO_INSTANCE_ID]) {
 682                 *instance_id = strdup(info->value[RUA_INFO_INSTANCE_ID]);
 683                 if (*instance_id == NULL) {
 684                         _E("Out of memory");
 685                         return RUA_ERROR_OUT_OF_MEMORY;
 686                 }
 687         } else {
 688                 *instance_id = NULL;
 689         }
 690
 691         return RUA_ERROR_NONE;
 692 }
 693
 694 API int rua_info_get_instance_name(rua_info_h info, char **instance_name)
 695 {
 696         if (!info || !instance_name) {
 697                 _E("Invalid parameter");
 698                 return RUA_ERROR_INVALID_PARAMETER;
 699         }
 700
 701         if (info->value[RUA_INFO_INSTANCE_NAME]) {
 702                 *instance_name = strdup(info->value[RUA_INFO_INSTANCE_NAME]);
 703                 if (*instance_name == NULL) {
 704                         _E("Out of memory");
 705                         return RUA_ERROR_OUT_OF_MEMORY;
 706                 }
 707         } else {
 708                 *instance_name = NULL;
 709         }
 710
 711         return RUA_ERROR_NONE;
 712 }
 713
 714 static char *__get_icon(rua_info_h info)
 715 {
 716         pkgmgrinfo_appinfo_h app_info;
 717         aul_comp_info_h comp_info;
 718         char *icon;
 719         int ret;
 720
 721         if (info->value[RUA_INFO_COMP_INFO]) {
 722                 comp_info = (aul_comp_info_h)info->value[RUA_INFO_COMP_INFO];
 723                 ret = aul_comp_info_get_icon(comp_info, (const char **)&icon);
 724                 if (ret != AUL_R_OK) {
 725                         _E("Failed to get icon");
 726                         return NULL;
 727                 }
 728         } else {
 729                 app_info = (pkgmgrinfo_appinfo_h)info->value[RUA_INFO_APP_INFO];
 730                 ret = pkgmgrinfo_appinfo_get_icon(app_info, &icon);
 731                 if (ret != PMINFO_R_OK) {
 732                         _E("Failed to get icon");
 733                         return NULL;
 734                 }
 735         }
 736
 737         if (icon && icon[0] != '\0')
 738                 return strdup(icon);
 739
 740         return NULL;
 741 }
 742
 743 API int rua_info_get_icon(rua_info_h info, char **icon)
 744 {
 745         if (!info || !icon) {
 746                 _E("Invalid parameter");
 747                 return RUA_ERROR_INVALID_PARAMETER;
 748         }
 749
 750         if (info->value[RUA_INFO_ICON]) {
 751                 *icon = strdup(info->value[RUA_INFO_ICON]);
 752                 if (*icon == NULL) {
 753                         _E("Out of memory");
 754                         return RUA_ERROR_OUT_OF_MEMORY;
 755                 }
 756         } else {
 757                 *icon = __get_icon(info);
 758         }
 759
 760         return RUA_ERROR_NONE;
 761 }
 762
 763 API int rua_info_get_uri(rua_info_h info, char **uri)
 764 {
 765         if (!info || !uri) {
 766                 _E("Invalid parameter");
 767                 return RUA_ERROR_INVALID_PARAMETER;
 768         }
 769
 770         if (info->value[RUA_INFO_URI]) {
 771                 *uri = strdup(info->value[RUA_INFO_URI]);
 772                 if (*uri == NULL) {
 773                         _E("Out of memory");
 774                         return RUA_ERROR_OUT_OF_MEMORY;
 775                 }
 776         } else {
 777                 *uri = NULL;
 778         }
 779
 780         return RUA_ERROR_NONE;
 781 }
 782
 783 API int rua_info_get_image(rua_info_h info, char **image)
 784 {
 785         if (!info || !image) {
 786                 _E("Invalid parameter");
 787                 return RUA_ERROR_INVALID_PARAMETER;
 788         }
 789
 790         if (info->value[RUA_INFO_IMAGE]) {
 791                 *image = strdup(info->value[RUA_INFO_IMAGE]);
 792                 if (*image == NULL) {
 793                         _E("Out of memory");
 794                         return RUA_ERROR_OUT_OF_MEMORY;
 795                 }
 796         } else {
 797                 *image = NULL;
 798         }
 799
 800         return RUA_ERROR_NONE;
 801 }
 802
 803 API int rua_info_get_component_id(rua_info_h info, char **component_id)
 804 {
 805         if (!info || !component_id) {
 806                 _E("Invalid parameter");
 807                 return RUA_ERROR_INVALID_PARAMETER;
 808         }
 809
 810         if (info->value[RUA_INFO_COMPONENT_ID]) {
 811                 *component_id = strdup(info->value[RUA_INFO_COMPONENT_ID]);
 812                 if (*component_id == NULL) {
 813                         _E("Out of memory");
 814                         return RUA_ERROR_OUT_OF_MEMORY;
 815                 }
 816         } else {
 817                 *component_id = NULL;
 818         }
 819
 820         return RUA_ERROR_NONE;
 821 }
 822
 823
 824 API int rua_info_is_managed_by_task_manager(rua_info_h info, bool *managed)
 825 {
 826         pkgmgrinfo_appinfo_h app_info;
 827         aul_comp_info_h comp_info;
 828         int ret;
 829
 830         if (!info || !managed) {
 831                 _E("Invalid parameter");
 832                 return RUA_ERROR_INVALID_PARAMETER;
 833         }
 834
 835         if (info->value[RUA_INFO_COMP_INFO]) {
 836                 comp_info = (aul_comp_info_h)info->value[RUA_INFO_COMP_INFO];
 837                 ret = aul_comp_info_is_taskmanage(comp_info, managed);
 838                 if (ret != AUL_R_OK) {
 839                         _E("Failed to check taskmanage");
 840                         return RUA_ERROR_INVALID_PARAMETER;
 841                 }
 842         } else {
 843                 app_info = (pkgmgrinfo_appinfo_h)info->value[RUA_INFO_APP_INFO];
 844                 ret = pkgmgrinfo_appinfo_is_taskmanage(app_info, managed);
 845                 if (ret != PMINFO_R_OK) {
 846                         _E("Failed to check taskmanage");
 847                         return RUA_ERROR_INVALID_PARAMETER;
 848                 }
 849         }
 850
 851         return RUA_ERROR_NONE;
 852 }
 853
 854 static char *__get_label(rua_info_h info)
 855 {
 856         pkgmgrinfo_appinfo_h app_info;
 857         aul_comp_info_h comp_info;
 858         char *label;
 859         int ret;
 860
 861         if (info->value[RUA_INFO_COMP_INFO]) {
 862                 comp_info = (aul_comp_info_h)info->value[RUA_INFO_COMP_INFO];
 863                 ret = aul_comp_info_get_label(comp_info, (const char **)&label);
 864                 if (ret != AUL_R_OK) {
 865                         _E("Failed to get label");
 866                         return NULL;
 867                 }
 868         } else {
 869                 app_info = (pkgmgrinfo_appinfo_h)info->value[RUA_INFO_APP_INFO];
 870                 ret = pkgmgrinfo_appinfo_get_label(app_info, &label);
 871                 if (ret != PMINFO_R_OK) {
 872                         _E("Failed to get label");
 873                         return NULL;
 874                 }
 875         }
 876
 877         if (label && label[0] != '\0')
 878                 return strdup(label);
 879
 880         return NULL;
 881 }
 882
 883 API int rua_info_get_label(rua_info_h info, char **label)
 884 {
 885         if (!info || !label) {
 886                 _E("Invalid parameter");
 887                 return RUA_ERROR_INVALID_PARAMETER;
 888         }
 889
 890         *label = __get_label(info);
 891
 892         return RUA_ERROR_NONE;
 893 }
 894
 895 API int rua_info_destroy(rua_info_h info)
 896 {
 897         if (!info) {
 898                 _E("Invalid parameter");
 899                 return RUA_ERROR_INVALID_PARAMETER;
 900         }
 901
 902         __destroy_rua_info(info);
 903
 904         return RUA_ERROR_NONE;
 905 }
 906
 907 API int rua_info_clone(rua_info_h info, rua_info_h *clone)
 908 {
 909         if (!info || !clone) {
 910                 _E("Invalid parameter");
 911                 return RUA_ERROR_INVALID_PARAMETER;
 912         }
 913
 914         *clone = __clone_rua_info(info);
 915         if (*clone == NULL) {
 916                 _E("Failed to clone rua info");
 917                 return RUA_ERROR_OUT_OF_MEMORY;
 918         }
 919
 920         return RUA_ERROR_NONE;
 921 }