2 * Copyright (c) 2019 Samsung Electronics Co., Ltd. All rights reserved.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include <pkgmgr-info.h>
26 #include <aul_comp_info.h>
29 #include "rua_private.h"
31 #include "rua_info_internal.h"
33 #define RUA_INFO_START 0
36 RUA_INFO_APP_ID = RUA_INFO_START,
41 RUA_INFO_INSTANCE_NAME,
45 RUA_INFO_COMPONENT_ID,
52 char *value[RUA_INFO_MAX];
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);
61 typedef struct _rua_info_vft {
63 rua_info_remove_cb dtor;
64 rua_info_clone_cb clnr;
67 static int __rua_info_add_app_id(struct rua_rec *rec,
68 struct rua_info_s *info)
70 info->value[RUA_INFO_APP_ID] = strdup(rec->pkg_name);
71 if (!info->value[RUA_INFO_APP_ID]) {
73 return RUA_ERROR_OUT_OF_MEMORY;
76 return RUA_ERROR_NONE;
79 static int __rua_info_add_app_path(struct rua_rec *rec,
80 struct rua_info_s *info)
82 info->value[RUA_INFO_APP_PATH] = strdup(rec->app_path);
83 if (!info->value[RUA_INFO_APP_PATH]) {
85 return RUA_ERROR_OUT_OF_MEMORY;
88 return RUA_ERROR_NONE;
91 static int __rua_info_add_args(struct rua_rec *rec,
92 struct rua_info_s *info)
94 info->value[RUA_INFO_ARGS] = strdup(rec->arg);
95 if (!info->value[RUA_INFO_ARGS]) {
97 return RUA_ERROR_OUT_OF_MEMORY;
100 return RUA_ERROR_NONE;
103 static int __rua_info_add_launch_time(struct rua_rec *rec,
104 struct rua_info_s *info)
106 info->value[RUA_INFO_LAUNCH_TIME] = GINT_TO_POINTER(rec->launch_time);
108 return RUA_ERROR_NONE;
111 static int __rua_info_add_instance_id(struct rua_rec *rec,
112 struct rua_info_s *info)
114 if (!rec->instance_id)
115 return RUA_ERROR_NONE;
117 info->value[RUA_INFO_INSTANCE_ID] = strdup(rec->instance_id);
118 if (!info->value[RUA_INFO_INSTANCE_ID]) {
120 return RUA_ERROR_OUT_OF_MEMORY;
123 return RUA_ERROR_NONE;
126 static int __rua_info_add_instance_name(struct rua_rec *rec,
127 struct rua_info_s *info)
129 if (!rec->instance_name)
130 return RUA_ERROR_NONE;
132 info->value[RUA_INFO_INSTANCE_NAME] = strdup(rec->instance_name);
133 if (!info->value[RUA_INFO_INSTANCE_NAME]) {
135 return RUA_ERROR_OUT_OF_MEMORY;
138 return RUA_ERROR_NONE;
141 static int __rua_info_add_icon(struct rua_rec *rec, struct rua_info_s *info)
144 return RUA_ERROR_NONE;
146 info->value[RUA_INFO_ICON] = strdup(rec->icon);
147 if (!info->value[RUA_INFO_ICON]) {
149 return RUA_ERROR_OUT_OF_MEMORY;
152 return RUA_ERROR_NONE;
155 static int __rua_info_add_uri(struct rua_rec *rec, struct rua_info_s *info)
158 return RUA_ERROR_NONE;
160 info->value[RUA_INFO_URI] = strdup(rec->uri);
161 if (!info->value[RUA_INFO_URI]) {
163 return RUA_ERROR_OUT_OF_MEMORY;
166 return RUA_ERROR_NONE;
169 static int __rua_info_add_image(struct rua_rec *rec, struct rua_info_s *info)
172 return RUA_ERROR_NONE;
174 info->value[RUA_INFO_IMAGE] = strdup(rec->image);
175 if (!info->value[RUA_INFO_IMAGE]) {
177 return RUA_ERROR_OUT_OF_MEMORY;
180 return RUA_ERROR_NONE;
183 static int __rua_info_add_component_id(struct rua_rec *rec,
184 struct rua_info_s *info)
187 return RUA_ERROR_NONE;
189 info->value[RUA_INFO_COMPONENT_ID] = strdup(rec->comp_id);
190 if (!info->value[RUA_INFO_COMPONENT_ID]) {
192 return RUA_ERROR_OUT_OF_MEMORY;
195 return RUA_ERROR_NONE;
198 static int __rua_info_add_app_info(struct rua_rec *rec,
199 struct rua_info_s *info)
201 pkgmgrinfo_appinfo_h app_info;
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;
210 info->value[RUA_INFO_APP_INFO] = app_info;
212 return RUA_ERROR_NONE;
215 static int __rua_info_add_comp_info(struct rua_rec *rec,
216 struct rua_info_s *info)
218 aul_comp_info_h comp_info;
222 return RUA_ERROR_NONE;
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;
230 info->value[RUA_INFO_COMP_INFO] = comp_info;
232 return RUA_ERROR_NONE;
235 static void __rua_info_remove_app_info(void *data)
237 pkgmgrinfo_appinfo_h app_info;
239 app_info = (pkgmgrinfo_appinfo_h)data;
240 pkgmgrinfo_appinfo_destroy_appinfo(app_info);
243 static void __rua_info_remove_comp_info(void *data)
245 aul_comp_info_h comp_info;
250 comp_info = (aul_comp_info_h)data;
251 aul_comp_info_destroy(comp_info);
254 static int __rua_info_clone_app_id(struct rua_info_s *info,
255 struct rua_info_s *clone)
257 clone->value[RUA_INFO_APP_ID] = strdup(info->value[RUA_INFO_APP_ID]);
258 if (!clone->value[RUA_INFO_APP_ID]) {
260 return RUA_ERROR_OUT_OF_MEMORY;
263 return RUA_ERROR_NONE;
266 static int __rua_info_clone_app_path(struct rua_info_s *info,
267 struct rua_info_s *clone)
269 clone->value[RUA_INFO_APP_PATH] =
270 strdup(info->value[RUA_INFO_APP_PATH]);
271 if (!clone->value[RUA_INFO_APP_PATH]) {
273 return RUA_ERROR_OUT_OF_MEMORY;
276 return RUA_ERROR_NONE;
279 static int __rua_info_clone_args(struct rua_info_s *info,
280 struct rua_info_s *clone)
282 clone->value[RUA_INFO_ARGS] = strdup(info->value[RUA_INFO_ARGS]);
283 if (!clone->value[RUA_INFO_ARGS]) {
285 return RUA_ERROR_OUT_OF_MEMORY;
288 return RUA_ERROR_NONE;
291 static int __rua_info_clone_launch_time(struct rua_info_s *info,
292 struct rua_info_s *clone)
294 clone->value[RUA_INFO_LAUNCH_TIME] = info->value[RUA_INFO_LAUNCH_TIME];
296 return RUA_ERROR_NONE;
299 static int __rua_info_clone_instance_id(struct rua_info_s *info,
300 struct rua_info_s *clone)
302 if (!info->value[RUA_INFO_INSTANCE_ID])
303 return RUA_ERROR_NONE;
305 clone->value[RUA_INFO_INSTANCE_ID] =
306 strdup(info->value[RUA_INFO_INSTANCE_ID]);
307 if (!clone->value[RUA_INFO_INSTANCE_ID]) {
309 return RUA_ERROR_OUT_OF_MEMORY;
312 return RUA_ERROR_NONE;
315 static int __rua_info_clone_instance_name(struct rua_info_s *info,
316 struct rua_info_s *clone)
318 if (!info->value[RUA_INFO_INSTANCE_NAME])
319 return RUA_ERROR_NONE;
321 clone->value[RUA_INFO_INSTANCE_NAME] =
322 strdup(info->value[RUA_INFO_INSTANCE_NAME]);
323 if (!clone->value[RUA_INFO_INSTANCE_NAME]) {
325 return RUA_ERROR_OUT_OF_MEMORY;
328 return RUA_ERROR_NONE;
331 static int __rua_info_clone_icon(struct rua_info_s *info,
332 struct rua_info_s *clone)
334 if (!info->value[RUA_INFO_ICON])
335 return RUA_ERROR_NONE;
337 clone->value[RUA_INFO_ICON] = strdup(info->value[RUA_INFO_ICON]);
338 if (!clone->value[RUA_INFO_ICON]) {
340 return RUA_ERROR_OUT_OF_MEMORY;
343 return RUA_ERROR_NONE;
346 static int __rua_info_clone_uri(struct rua_info_s *info,
347 struct rua_info_s *clone)
349 if (!info->value[RUA_INFO_URI])
350 return RUA_ERROR_NONE;
352 clone->value[RUA_INFO_URI] = strdup(info->value[RUA_INFO_URI]);
353 if (!clone->value[RUA_INFO_URI]) {
355 return RUA_ERROR_OUT_OF_MEMORY;
358 return RUA_ERROR_NONE;
361 static int __rua_info_clone_image(struct rua_info_s *info,
362 struct rua_info_s *clone)
364 if (!info->value[RUA_INFO_IMAGE])
365 return RUA_ERROR_NONE;
367 clone->value[RUA_INFO_IMAGE] = strdup(info->value[RUA_INFO_IMAGE]);
368 if (!clone->value[RUA_INFO_IMAGE]) {
370 return RUA_ERROR_OUT_OF_MEMORY;
373 return RUA_ERROR_NONE;
376 static int __rua_info_clone_component_id(struct rua_info_s *info,
377 struct rua_info_s *clone)
379 if (!info->value[RUA_INFO_COMPONENT_ID])
380 return RUA_ERROR_NONE;
382 clone->value[RUA_INFO_COMPONENT_ID] =
383 strdup(info->value[RUA_INFO_COMPONENT_ID]);
384 if (!clone->value[RUA_INFO_COMPONENT_ID]) {
386 return RUA_ERROR_OUT_OF_MEMORY;
389 return RUA_ERROR_NONE;
392 static int __rua_info_clone_app_info(struct rua_info_s *info,
393 struct rua_info_s *clone)
395 pkgmgrinfo_appinfo_h app_info;
398 ret = pkgmgrinfo_appinfo_clone_appinfo(
399 info->value[RUA_INFO_APP_INFO],
401 if (ret != RUA_ERROR_NONE) {
402 _E("Failed to clone app info");
403 return RUA_ERROR_OUT_OF_MEMORY;
406 clone->value[RUA_INFO_APP_INFO] = app_info;
408 return RUA_ERROR_NONE;
411 static int __rua_info_clone_comp_info(struct rua_info_s *info,
412 struct rua_info_s *clone)
414 aul_comp_info_h comp_info;
417 if (!info->value[RUA_INFO_COMP_INFO])
418 return RUA_ERROR_NONE;
420 ret = aul_comp_info_clone(info->value[RUA_INFO_COMP_INFO],
422 if (ret != RUA_ERROR_NONE) {
423 _E("Failed to clone comp info");
424 return RUA_ERROR_OUT_OF_MEMORY;
427 clone->value[RUA_INFO_COMP_INFO] = comp_info;
429 return RUA_ERROR_NONE;
432 static rua_info_vft __rua_table[] = {
433 [RUA_INFO_APP_ID] = {
434 .ctor = __rua_info_add_app_id,
436 .clnr = __rua_info_clone_app_id
438 [RUA_INFO_APP_PATH] = {
439 .ctor = __rua_info_add_app_path,
441 .clnr = __rua_info_clone_app_path
444 .ctor = __rua_info_add_args,
446 .clnr = __rua_info_clone_args
448 [RUA_INFO_LAUNCH_TIME] = {
449 .ctor = __rua_info_add_launch_time,
451 .clnr = __rua_info_clone_launch_time
453 [RUA_INFO_INSTANCE_ID] = {
454 .ctor = __rua_info_add_instance_id,
456 .clnr = __rua_info_clone_instance_id
458 [RUA_INFO_INSTANCE_NAME] = {
459 .ctor = __rua_info_add_instance_name,
461 .clnr = __rua_info_clone_instance_name
464 .ctor = __rua_info_add_icon,
466 .clnr = __rua_info_clone_icon
469 .ctor = __rua_info_add_uri,
471 .clnr = __rua_info_clone_uri
474 .ctor = __rua_info_add_image,
476 .clnr = __rua_info_clone_image
478 [RUA_INFO_COMPONENT_ID] = {
479 .ctor = __rua_info_add_component_id,
481 .clnr = __rua_info_clone_component_id
483 [RUA_INFO_APP_INFO] = {
484 .ctor = __rua_info_add_app_info,
485 .dtor = __rua_info_remove_app_info,
486 .clnr = __rua_info_clone_app_info
488 [RUA_INFO_COMP_INFO] = {
489 .ctor = __rua_info_add_comp_info,
490 .dtor = __rua_info_remove_comp_info,
491 .clnr = __rua_info_clone_comp_info
495 static void __destroy_rua_info(gpointer data)
497 struct rua_info_s *info = (struct rua_info_s *)data;
503 for (i = RUA_INFO_START; i < RUA_INFO_MAX; ++i) {
504 if (!__rua_table[i].dtor)
507 __rua_table[i].dtor(info->value[i]);
513 static struct rua_info_s *__create_rua_info(struct rua_rec *rec)
515 struct rua_info_s *info;
519 info = calloc(1, sizeof(struct rua_info_s));
525 for (i = RUA_INFO_START; i < RUA_INFO_MAX; ++i) {
526 if (!__rua_table[i].ctor)
529 ret = __rua_table[i].ctor(rec, info);
530 if (ret != RUA_ERROR_NONE) {
531 __destroy_rua_info(info);
539 static struct rua_info_s *__clone_rua_info(struct rua_info_s *info)
541 struct rua_info_s *clone;
545 clone = calloc(1, sizeof(struct rua_info_s));
551 for (i = RUA_INFO_START; i < RUA_INFO_MAX; ++i) {
552 if (!__rua_table[i].clnr)
555 ret = __rua_table[i].clnr(info, clone);
556 if (ret != RUA_ERROR_NONE) {
557 __destroy_rua_info(clone);
565 int rua_info_foreach(rua_manager_rua_info_cb callback, void *user_data)
567 return rua_info_usr_foreach(getuid(), callback, user_data);
570 int rua_info_usr_foreach(uid_t uid, rua_manager_rua_info_cb callback,
573 struct rua_info_s *info;
584 _E("Invalid parameter");
585 return RUA_ERROR_INVALID_PARAMETER;
588 ret = rua_history_load_db_for_uid(&table, &nrows, &ncols, uid);
590 _E("Failed to load rua history");
591 return RUA_ERROR_IO_ERROR;
594 for (row = 0; row < nrows; ++row) {
595 rua_history_get_rec(&rec, table, nrows, ncols, row);
596 info = __create_rua_info(&rec);
598 list = g_list_append(list, info);
601 rua_history_unload_db(&table);
605 info = (struct rua_info_s *)iter->data;
606 if (!callback(info, user_data))
609 iter = g_list_next(iter);
612 g_list_free_full(list, __destroy_rua_info);
614 return RUA_ERROR_NONE;
617 API int rua_info_get_app_id(rua_info_h info, char **app_id)
619 if (!info || !app_id) {
620 _E("Invalid parameter");
621 return RUA_ERROR_INVALID_PARAMETER;
624 *app_id = strdup(info->value[RUA_INFO_APP_ID]);
625 if (*app_id == NULL) {
627 return RUA_ERROR_OUT_OF_MEMORY;
630 return RUA_ERROR_NONE;
633 API int rua_info_get_app_path(rua_info_h info, char **app_path)
635 if (!info || !app_path) {
636 _E("Invalid parameter");
637 return RUA_ERROR_INVALID_PARAMETER;
640 *app_path = strdup(info->value[RUA_INFO_APP_PATH]);
641 if (*app_path == NULL) {
643 return RUA_ERROR_OUT_OF_MEMORY;
646 return RUA_ERROR_NONE;
649 API int rua_info_get_args(rua_info_h info, char **args)
651 if (!info || !args) {
652 _E("Invalid parameter");
653 return RUA_ERROR_INVALID_PARAMETER;
656 *args = strdup(info->value[RUA_INFO_ARGS]);
659 return RUA_ERROR_OUT_OF_MEMORY;
662 return RUA_ERROR_NONE;
665 API int rua_info_get_launch_time(rua_info_h info, time_t *launch_time)
667 if (!info || !launch_time) {
668 _E("Invalid parameter");
669 return RUA_ERROR_INVALID_PARAMETER;
672 *launch_time = GPOINTER_TO_INT(info->value[RUA_INFO_LAUNCH_TIME]);
674 return RUA_ERROR_NONE;
677 API int rua_info_get_instance_id(rua_info_h info, char **instance_id)
679 if (!info || !instance_id) {
680 _E("Invalid parameter");
681 return RUA_ERROR_INVALID_PARAMETER;
684 if (info->value[RUA_INFO_INSTANCE_ID]) {
685 *instance_id = strdup(info->value[RUA_INFO_INSTANCE_ID]);
686 if (*instance_id == NULL) {
688 return RUA_ERROR_OUT_OF_MEMORY;
694 return RUA_ERROR_NONE;
697 API int rua_info_get_instance_name(rua_info_h info, char **instance_name)
699 if (!info || !instance_name) {
700 _E("Invalid parameter");
701 return RUA_ERROR_INVALID_PARAMETER;
704 if (info->value[RUA_INFO_INSTANCE_NAME]) {
705 *instance_name = strdup(info->value[RUA_INFO_INSTANCE_NAME]);
706 if (*instance_name == NULL) {
708 return RUA_ERROR_OUT_OF_MEMORY;
711 *instance_name = NULL;
714 return RUA_ERROR_NONE;
717 static char *__get_icon(rua_info_h info)
719 pkgmgrinfo_appinfo_h app_info;
720 aul_comp_info_h comp_info;
724 if (info->value[RUA_INFO_COMP_INFO]) {
725 comp_info = (aul_comp_info_h)info->value[RUA_INFO_COMP_INFO];
726 ret = aul_comp_info_get_icon(comp_info, (const char **)&icon);
727 if (ret != AUL_R_OK) {
728 _E("Failed to get icon");
732 app_info = (pkgmgrinfo_appinfo_h)info->value[RUA_INFO_APP_INFO];
733 ret = pkgmgrinfo_appinfo_get_icon(app_info, &icon);
734 if (ret != PMINFO_R_OK) {
735 _E("Failed to get icon");
740 if (icon && icon[0] != '\0')
746 API int rua_info_get_icon(rua_info_h info, char **icon)
748 if (!info || !icon) {
749 _E("Invalid parameter");
750 return RUA_ERROR_INVALID_PARAMETER;
753 if (info->value[RUA_INFO_ICON]) {
754 *icon = strdup(info->value[RUA_INFO_ICON]);
757 return RUA_ERROR_OUT_OF_MEMORY;
760 *icon = __get_icon(info);
763 return RUA_ERROR_NONE;
766 API int rua_info_get_uri(rua_info_h info, char **uri)
769 _E("Invalid parameter");
770 return RUA_ERROR_INVALID_PARAMETER;
773 if (info->value[RUA_INFO_URI]) {
774 *uri = strdup(info->value[RUA_INFO_URI]);
777 return RUA_ERROR_OUT_OF_MEMORY;
783 return RUA_ERROR_NONE;
786 API int rua_info_get_image(rua_info_h info, char **image)
788 if (!info || !image) {
789 _E("Invalid parameter");
790 return RUA_ERROR_INVALID_PARAMETER;
793 if (info->value[RUA_INFO_IMAGE]) {
794 *image = strdup(info->value[RUA_INFO_IMAGE]);
795 if (*image == NULL) {
797 return RUA_ERROR_OUT_OF_MEMORY;
803 return RUA_ERROR_NONE;
806 API int rua_info_get_component_id(rua_info_h info, char **component_id)
808 if (!info || !component_id) {
809 _E("Invalid parameter");
810 return RUA_ERROR_INVALID_PARAMETER;
813 if (info->value[RUA_INFO_COMPONENT_ID]) {
814 *component_id = strdup(info->value[RUA_INFO_COMPONENT_ID]);
815 if (*component_id == NULL) {
817 return RUA_ERROR_OUT_OF_MEMORY;
820 *component_id = NULL;
823 return RUA_ERROR_NONE;
827 API int rua_info_is_managed_by_task_manager(rua_info_h info, bool *managed)
829 pkgmgrinfo_appinfo_h app_info;
830 aul_comp_info_h comp_info;
833 if (!info || !managed) {
834 _E("Invalid parameter");
835 return RUA_ERROR_INVALID_PARAMETER;
838 if (info->value[RUA_INFO_COMP_INFO]) {
839 comp_info = (aul_comp_info_h)info->value[RUA_INFO_COMP_INFO];
840 ret = aul_comp_info_is_taskmanage(comp_info, managed);
841 if (ret != AUL_R_OK) {
842 _E("Failed to check taskmanage");
843 return RUA_ERROR_INVALID_PARAMETER;
846 app_info = (pkgmgrinfo_appinfo_h)info->value[RUA_INFO_APP_INFO];
847 ret = pkgmgrinfo_appinfo_is_taskmanage(app_info, managed);
848 if (ret != PMINFO_R_OK) {
849 _E("Failed to check taskmanage");
850 return RUA_ERROR_INVALID_PARAMETER;
854 return RUA_ERROR_NONE;
857 static char *__get_label(rua_info_h info)
859 pkgmgrinfo_appinfo_h app_info;
860 aul_comp_info_h comp_info;
864 if (info->value[RUA_INFO_COMP_INFO]) {
865 comp_info = (aul_comp_info_h)info->value[RUA_INFO_COMP_INFO];
866 ret = aul_comp_info_get_label(comp_info, (const char **)&label);
867 if (ret != AUL_R_OK) {
868 _E("Failed to get label");
872 app_info = (pkgmgrinfo_appinfo_h)info->value[RUA_INFO_APP_INFO];
873 ret = pkgmgrinfo_appinfo_get_label(app_info, &label);
874 if (ret != PMINFO_R_OK) {
875 _E("Failed to get label");
880 if (label && label[0] != '\0')
881 return strdup(label);
886 API int rua_info_get_label(rua_info_h info, char **label)
888 if (!info || !label) {
889 _E("Invalid parameter");
890 return RUA_ERROR_INVALID_PARAMETER;
893 *label = __get_label(info);
895 return RUA_ERROR_NONE;
898 API int rua_info_destroy(rua_info_h info)
901 _E("Invalid parameter");
902 return RUA_ERROR_INVALID_PARAMETER;
905 __destroy_rua_info(info);
907 return RUA_ERROR_NONE;
910 API int rua_info_clone(rua_info_h info, rua_info_h *clone)
912 if (!info || !clone) {
913 _E("Invalid parameter");
914 return RUA_ERROR_INVALID_PARAMETER;
917 *clone = __clone_rua_info(info);
918 if (*clone == NULL) {
919 _E("Failed to clone rua info");
920 return RUA_ERROR_OUT_OF_MEMORY;
923 return RUA_ERROR_NONE;