diff options
Diffstat (limited to 'src')
| -rwxr-xr-x | src/app_context.c | 492 | ||||
| -rwxr-xr-x | src/app_info.c | 809 | ||||
| -rwxr-xr-x | src/app_manager.c | 308 | ||||
| -rwxr-xr-x | src/app_manager_deprecated.c | 366 |
4 files changed, 1975 insertions, 0 deletions
diff --git a/src/app_context.c b/src/app_context.c new file mode 100755 index 0000000..bd2338f --- /dev/null +++ b/src/app_context.c @@ -0,0 +1,492 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <pthread.h> + +#include <glib.h> + +#include <aul.h> +#include <dlog.h> + +#include <app_context.h> +#include <app_manager.h> +#include <app_manager_private.h> + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "CAPI_APPFW_APP_MANAGER" + +#define APPID_MAX 128 + +static int app_context_create(const char *app_id, pid_t pid, app_context_h *app_context); + +static int app_context_get_app_context_by_pid(pid_t pid, app_context_h *app_context); + +struct app_context_s { + char *app_id; + pid_t pid; +}; + +typedef struct _foreach_context_ { + app_manager_app_context_cb callback; + void *user_data; + bool iteration; +} foreach_context_s; + +typedef struct _retrieval_context_{ + const char *app_id; + pid_t pid; + bool matched; +} retrieval_context_s; + +static int app_context_foreach_app_context_cb(const aul_app_info *aul_app_context, void *cb_data) +{ + foreach_context_s* foreach_context = cb_data; + + if (foreach_context == NULL) + { + app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + return 0; + } + + if (foreach_context->iteration == true) + { + app_context_h app_context = NULL; + + if (app_context_create(aul_app_context->appid, aul_app_context->pid, &app_context) == APP_MANAGER_ERROR_NONE) + { + foreach_context->iteration = foreach_context->callback(app_context, foreach_context->user_data); + app_context_destroy(app_context); + } + } + + return 0; +} + + +int app_context_foreach_app_context(app_manager_app_context_cb callback, void *user_data) +{ + foreach_context_s foreach_context = { + .callback = callback, + .user_data = user_data, + .iteration = true + }; + + if (callback == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + aul_app_get_running_app_info(app_context_foreach_app_context_cb, &foreach_context); + + return APP_MANAGER_ERROR_NONE; +} + + +static int app_context_retrieve_app_context(const aul_app_info *aul_app_context, void *cb_data) +{ + retrieval_context_s *retrieval_context = cb_data; + + if (aul_app_context != NULL && retrieval_context != NULL && retrieval_context->matched == false) + { + if (!strcmp(aul_app_context->appid, retrieval_context->app_id)) + { + retrieval_context->pid = aul_app_context->pid; + retrieval_context->matched = true; + } + } + + return 0; +} + +int app_context_get_app_context(const char *app_id, app_context_h *app_context) +{ + retrieval_context_s retrieval_context = { + .app_id = app_id, + .pid = 0, + .matched = false + }; + + if (app_id == NULL || app_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (aul_app_is_running(app_id) == 0) + { + return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL); + } + + aul_app_get_running_app_info(app_context_retrieve_app_context, &retrieval_context); + + if (retrieval_context.matched == false) + { + return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL); + } + + return app_context_create(retrieval_context.app_id, retrieval_context.pid, app_context); +} + +static int app_context_get_app_context_by_pid(pid_t pid, app_context_h *app_context) +{ + int retval; + char appid[APPID_MAX] = {0, }; + + if (pid < 0 || app_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (aul_app_get_appid_bypid(pid, appid, sizeof(appid)) != AUL_R_OK) + { + return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL); + } + + retval = app_context_get_app_context(appid, app_context); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + + return APP_MANAGER_ERROR_NONE; +} + +static int app_context_create(const char *app_id, pid_t pid, app_context_h *app_context) +{ + app_context_h app_context_created; + + if (app_id == NULL || pid <= 0 || app_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + app_context_created = calloc(1, sizeof(struct app_context_s)); + + if (app_context_created == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + app_context_created->app_id = strdup(app_id); + + if (app_context_created->app_id == NULL) + { + free(app_context_created); + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + app_context_created->pid = pid; + + *app_context = app_context_created; + + return APP_MANAGER_ERROR_NONE; +} + +int app_context_destroy(app_context_h app_context) +{ + if (app_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + free(app_context->app_id); + free(app_context); + + return APP_MANAGER_ERROR_NONE; +} + +int app_context_get_package(app_context_h app_context, char **package) +{ + // TODO: this function must be deprecated + return app_context_get_app_id(app_context, package); +} + + +int app_context_get_app_id(app_context_h app_context, char **app_id) +{ + char *app_id_dup; + + if (app_context == NULL || app_id == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + app_id_dup = strdup(app_context->app_id); + + if (app_id_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *app_id = app_id_dup; + + return APP_MANAGER_ERROR_NONE; +} + + +int app_context_get_pid(app_context_h app_context, pid_t *pid) +{ + if (app_context == NULL || pid == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + *pid = app_context->pid; + + return APP_MANAGER_ERROR_NONE; +} + +int app_context_is_terminated(app_context_h app_context, bool *terminated) +{ + if (app_context == NULL || terminated == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (aul_app_is_running(app_context->app_id) == 1) + { + *terminated = false; + } + else + { + char appid[APPID_MAX] = {0, }; + + if (aul_app_get_appid_bypid(app_context->pid, appid, sizeof(appid)) == AUL_R_OK) + { + *terminated = false; + } + else + { + *terminated = true; + } + } + + return APP_MANAGER_ERROR_NONE; +} + +int app_context_is_equal(app_context_h lhs, app_context_h rhs, bool *equal) +{ + if (lhs == NULL || rhs == NULL || equal == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (!strcmp(lhs->app_id, rhs->app_id) && lhs->pid == rhs->pid) + { + *equal = true; + } + else + { + *equal = false; + } + + return APP_MANAGER_ERROR_NONE; +} + +int app_context_clone(app_context_h *clone, app_context_h app_context) +{ + int retval; + + if (clone == NULL || app_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + retval = app_context_create(app_context->app_id, app_context->pid, clone); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + + return APP_MANAGER_ERROR_NONE; +} + +typedef struct _event_cb_context_ { + GHashTable *pid_table; + app_manager_app_context_event_cb callback; + void *user_data; +} event_cb_context_s; + +static pthread_mutex_t event_cb_context_mutex = PTHREAD_MUTEX_INITIALIZER; +static event_cb_context_s *event_cb_context = NULL; + +static void app_context_lock_event_cb_context() +{ + pthread_mutex_lock(&event_cb_context_mutex); +} + +static void app_context_unlock_event_cb_context() +{ + pthread_mutex_unlock(&event_cb_context_mutex); +} + +static bool app_context_load_all_app_context_cb_locked(app_context_h app_context, void *user_data) +{ + app_context_h app_context_cloned; + + if (app_context_clone(&app_context_cloned, app_context) == APP_MANAGER_ERROR_NONE) + { + LOGI("[%s] app_id(%s), pid(%d)", __FUNCTION__, app_context->app_id, app_context->pid); + + if (event_cb_context != NULL && event_cb_context->pid_table != NULL) + { + g_hash_table_insert(event_cb_context->pid_table, GINT_TO_POINTER(&(app_context_cloned->pid)), app_context_cloned); + } + else + { + app_context_destroy(app_context_cloned); + app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, "invalid callback context"); + } + } + + return true; +} + +static void app_context_pid_table_entry_destroyed_cb(void * data) +{ + app_context_h app_context = data; + + if (app_context != NULL) + { + char *app_id; + int pid; + app_context_get_app_id(app_context, &app_id); + app_context_get_pid(app_context, &pid); + LOGI("[%s] app_id(%s), pid(%d)", __FUNCTION__, app_context->app_id, app_context->pid); + free(app_id); + + app_context_destroy(app_context); + } +} + +static int app_context_launched_event_cb(pid_t pid, void *data) +{ + app_context_h app_context; + + app_context_lock_event_cb_context(); + + if (app_context_get_app_context_by_pid(pid, &app_context) == APP_MANAGER_ERROR_NONE) + { + if (event_cb_context != NULL && event_cb_context->pid_table != NULL) + { + g_hash_table_insert(event_cb_context->pid_table, GINT_TO_POINTER(&(app_context->pid)), app_context); + event_cb_context->callback(app_context, APP_CONTEXT_EVENT_LAUNCHED, event_cb_context->user_data); + } + else + { + app_context_destroy(app_context); + app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, "invalid callback context"); + } + } + + app_context_unlock_event_cb_context(); + + return 0; +} + +static int app_context_terminated_event_cb(pid_t pid, void *data) +{ + app_context_h app_context; + int lookup_key = pid; + + app_context_lock_event_cb_context(); + + if (event_cb_context != NULL && event_cb_context->pid_table != NULL) + { + app_context = g_hash_table_lookup(event_cb_context->pid_table, GINT_TO_POINTER(&lookup_key)); + + if (app_context != NULL) + { + event_cb_context->callback(app_context, APP_CONTEXT_EVENT_TERMINATED, event_cb_context->user_data); + g_hash_table_remove(event_cb_context->pid_table, GINT_TO_POINTER(&(app_context->pid))); + } + } + else + { + app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, "invalid callback context"); + } + + app_context_unlock_event_cb_context(); + + return 0; +} + +int app_context_set_event_cb(app_manager_app_context_event_cb callback, void *user_data) +{ + if (callback == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + app_context_lock_event_cb_context(); + + if (event_cb_context == NULL) + { + event_cb_context = calloc(1, sizeof(event_cb_context_s)); + + if (event_cb_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + event_cb_context->pid_table = g_hash_table_new_full(g_int_hash, g_int_equal, NULL, app_context_pid_table_entry_destroyed_cb); + + if (event_cb_context->pid_table == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, "failed to initialize pid-table"); + } + + app_context_foreach_app_context(app_context_load_all_app_context_cb_locked, NULL); + + aul_listen_app_dead_signal(app_context_terminated_event_cb, NULL); + aul_listen_app_launch_signal(app_context_launched_event_cb, NULL); + + } + + event_cb_context->callback = callback; + event_cb_context->user_data = user_data; + + app_context_unlock_event_cb_context(); + + return APP_MANAGER_ERROR_NONE; +} + +void app_context_unset_event_cb(void) +{ + app_context_lock_event_cb_context(); + + if (event_cb_context != NULL) + { + //aul_listen_app_dead_signal(NULL, NULL); + //aul_listen_app_launch_signal(NULL, NULL); + + g_hash_table_destroy(event_cb_context->pid_table); + free(event_cb_context); + event_cb_context = NULL; + } + + app_context_unlock_event_cb_context(); +} + diff --git a/src/app_info.c b/src/app_info.c new file mode 100755 index 0000000..5b9b06d --- /dev/null +++ b/src/app_info.c @@ -0,0 +1,809 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <ail.h> +#include <pkgmgr-info.h> +#include <package-manager.h> +#include <dlog.h> + +#include <app_info.h> +#include <app_manager.h> +#include <app_manager_private.h> + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "TIZEN_N_APP_MANAGER" + + +static int app_info_create(const char *app_id, app_info_h *app_info); + + +struct app_info_s { + char *app_id; + pkgmgrinfo_appinfo_h pkg_app_info; +}; + +typedef struct _foreach_context_{ + app_manager_app_info_cb callback; + void *user_data; +} foreach_context_s; + + +static ail_cb_ret_e app_info_foreach_app_info_cb(const ail_appinfo_h ail_app_info, void *cb_data) +{ + foreach_context_s *foreach_context = cb_data; + app_info_h app_info = NULL; + char *app_id; + bool iteration_next = true; + + if (ail_app_info == NULL || foreach_context == NULL) + { + app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + return AIL_CB_RET_CANCEL; + } + + ail_appinfo_get_str(ail_app_info, AIL_PROP_PACKAGE_STR, &app_id); + + if (app_info_create(app_id, &app_info) == APP_MANAGER_ERROR_NONE) + { + iteration_next = foreach_context->callback(app_info, foreach_context->user_data); + app_info_destroy(app_info); + } + + if (iteration_next == true) + { + return AIL_CB_RET_CONTINUE; + } + else + { + return AIL_CB_RET_CANCEL; + } +} + +int app_info_foreach_app_info(app_manager_app_info_cb callback, void *user_data) +{ + foreach_context_s foreach_context = { + .callback = callback, + .user_data = user_data, + }; + + if (callback == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + ail_filter_list_appinfo_foreach(NULL, app_info_foreach_app_info_cb, &foreach_context); + + return APP_MANAGER_ERROR_NONE; +} + +int app_info_get_app_info(const char *app_id, app_info_h *app_info) +{ + return app_info_create(app_id, app_info); +} + +static int app_info_create(const char *app_id, app_info_h *app_info) +{ + pkgmgrinfo_appinfo_h pkg_app_info; + app_info_h info; + if (app_id == NULL || app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkg_app_info)) { + return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL); + } + info = calloc(1, sizeof(struct app_info_s)); + if (info == NULL) { + pkgmgrinfo_appinfo_destroy_appinfo(pkg_app_info); + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + info->app_id = strdup(app_id); + info->pkg_app_info = pkg_app_info; + *app_info = info; + return APP_MANAGER_ERROR_NONE; +} + +int app_info_destroy(app_info_h app_info) +{ + if (app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (app_info->app_id) { + free(app_info->app_id); + app_info->app_id = NULL; + } + pkgmgrinfo_appinfo_destroy_appinfo(app_info->pkg_app_info); + free(app_info); + return APP_MANAGER_ERROR_NONE; +} + +int app_info_get_app_id(app_info_h app_info, char **app_id) +{ + char *app_id_dup; + + if (app_info == NULL || app_id == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + app_id_dup = strdup(app_info->app_id); + + if (app_id_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *app_id = app_id_dup; + + return APP_MANAGER_ERROR_NONE; +} + +int app_info_get_name(app_info_h app_info, char **label) +{ + return app_info_get_label(app_info, label); +} + + +int app_info_get_label(app_info_h app_info, char **label) +{ + char *val; + char *app_label_dup; + + if (app_info == NULL || label == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_label(app_info->pkg_app_info, &val); + + app_label_dup = strdup(val); + if (app_label_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *label = app_label_dup; + + return APP_MANAGER_ERROR_NONE; +} + + + +int app_info_get_icon(app_info_h app_info, char **path) +{ + char *val; + char *app_icon_dup; + + if (app_info == NULL || path == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_icon(app_info->pkg_app_info, &val); + + app_icon_dup = strdup(val); + if (app_icon_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *path = app_icon_dup; + + return APP_MANAGER_ERROR_NONE; +} + + + +int app_info_is_equal(app_info_h lhs, app_info_h rhs, bool *equal) +{ + if (lhs == NULL || rhs == NULL || equal == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (!strcmp(lhs->app_id, rhs->app_id)) + { + *equal = true; + } + else + { + *equal = false; + } + + return APP_MANAGER_ERROR_NONE; +} + + +int app_info_clone(app_info_h *clone, app_info_h app_info) +{ + int retval; + + if (clone == NULL || app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + retval = app_info_create(app_info->app_id, clone); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + + return APP_MANAGER_ERROR_NONE; +} + + +int app_info_get_package(app_info_h app_info, char **package) +{ + char *val; + char *app_package_dup; + + if (app_info == NULL || package == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_pkgname(app_info->pkg_app_info, &val); + + app_package_dup = strdup(val); + if (app_package_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *package = app_package_dup; + + return APP_MANAGER_ERROR_NONE; +} + + +int app_info_get_type(app_info_h app_info, char **type) +{ + char *val; + char *app_type_dup; + + if (app_info == NULL || type == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_apptype(app_info->pkg_app_info, &val); + + app_type_dup = strdup(val); + if (app_type_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *type = app_type_dup; + + return APP_MANAGER_ERROR_NONE; +} + + +static pkgmgr_client *package_event_listener = NULL; +static app_manager_app_info_event_cb app_info_event_cb = NULL; +static void *app_info_event_cb_data = NULL; + +static app_info_event_e app_info_get_app_info_event(const char *value) +{ + if (!strcasecmp(value, "install")) + { + return APP_INFO_EVENT_INSTALLED; + } + else if (!strcasecmp(value, "uninstall")) + { + return APP_INFO_EVENT_UNINSTALLED; + } + else if (!strcasecmp(value, "update")) + { + return APP_INFO_EVENT_UPDATED; + } + else + { + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } +} + +static int app_info_package_event_listener_cb( + int id, const char *type, const char *package, const char *key, const char *val, const void *msg, void *data) +{ + static int event_id = -1; + static app_info_event_e event_type = -1; + + if (!strcasecmp(key, "start")) + { + event_id = id; + event_type = app_info_get_app_info_event(val); + } + else if (!strcasecmp(key, "end") && !strcasecmp(val, "ok") && id == event_id) + { + if (app_info_event_cb != NULL && event_type >= 0) + { + app_info_h app_info; + + if (app_info_create(package, &app_info) == APP_MANAGER_ERROR_NONE) + { + app_info_event_cb(app_info, event_type, app_info_event_cb_data); + app_info_destroy(app_info); + } + } + + event_id = -1; + event_type = -1; + } + + return APP_MANAGER_ERROR_NONE; +} + +int app_info_set_event_cb(app_manager_app_info_event_cb callback, void *user_data) +{ + if (callback == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (app_info_event_cb == NULL) + { + package_event_listener = pkgmgr_client_new(PC_LISTENING); + + if (package_event_listener == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL); + } + + pkgmgr_client_listen_status(package_event_listener, app_info_package_event_listener_cb, NULL); + } + + app_info_event_cb = callback; + app_info_event_cb_data = user_data; + + return APP_MANAGER_ERROR_NONE; +} + + +void app_info_unset_event_cb(void) +{ + if (app_info_event_cb != NULL) + { + pkgmgr_client_free(package_event_listener); + package_event_listener = NULL; + } + + app_info_event_cb = NULL; + app_info_event_cb_data = NULL; +} + + +#define __START_OF_DEPRECATED_API + +static int ui_app_info_create(const char *app_id, ui_app_info_h *ui_app_info); +static int service_app_info_create(const char *app_id, service_app_info_h *service_app_info); + +struct ui_app_info_s { + char *app_id; + pkgmgrinfo_appinfo_h ui_app_info; +}; + +struct service_app_info_s { + char *app_id; + pkgmgrinfo_appinfo_h service_app_info; +}; + + +int ui_app_info_get_app_info(const char *app_id, ui_app_info_h *ui_app_info) +{ + return ui_app_info_create(app_id, ui_app_info); +} + +int service_app_info_get_app_info(const char *app_id, service_app_info_h *service_app_info) +{ + return service_app_info_create(app_id, service_app_info); +} + +static int ui_app_info_create(const char *app_id, ui_app_info_h *ui_app_info) +{ + pkgmgrinfo_appinfo_h app_info; + ui_app_info_h info; + if (app_id == NULL || ui_app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (pkgmgrinfo_appinfo_get_appinfo(app_id, &app_info)) { + return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL); + } + info = calloc(1, sizeof(struct ui_app_info_s)); + if (info == NULL) { + pkgmgrinfo_appinfo_destroy_appinfo(app_info); + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + info->app_id = strdup(app_id); + info->ui_app_info = app_info; + *ui_app_info = info; + return APP_MANAGER_ERROR_NONE; +} + +static int service_app_info_create(const char *app_id, service_app_info_h *service_app_info) +{ + pkgmgrinfo_appinfo_h app_info; + service_app_info_h info; + if (app_id == NULL || service_app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (pkgmgrinfo_appinfo_get_appinfo(app_id, &app_info)) { + return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL); + } + info = calloc(1, sizeof(struct service_app_info_s)); + if (info == NULL) { + pkgmgrinfo_appinfo_destroy_appinfo(app_info); + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + info->app_id = strdup(app_id); + info->service_app_info = app_info; + *service_app_info = info; + return APP_MANAGER_ERROR_NONE; +} + + +int ui_app_info_destroy(ui_app_info_h ui_app_info) +{ + if (ui_app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (ui_app_info->app_id) { + free(ui_app_info->app_id); + ui_app_info->app_id = NULL; + } + pkgmgrinfo_appinfo_destroy_appinfo(ui_app_info->ui_app_info); + free(ui_app_info); + return APP_MANAGER_ERROR_NONE; +} + +int ui_app_info_get_app_id(ui_app_info_h ui_app_info, char **app_id) +{ + char *val; + char *app_id_dup; + + if (ui_app_info == NULL || app_id == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_appid(ui_app_info->ui_app_info, &val); + app_id_dup = strdup(val); + if (app_id_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *app_id = app_id_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int ui_app_info_get_label(ui_app_info_h ui_app_info, char **label) +{ + char *val; + char *app_label_dup; + + if (ui_app_info == NULL || label == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_label(ui_app_info->ui_app_info, &val); + app_label_dup = strdup(val); + if (app_label_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *label = app_label_dup; + return APP_MANAGER_ERROR_NONE; +} + +int ui_app_info_get_icon(ui_app_info_h ui_app_info, char **icon) +{ + char *val; + char *app_icon_dup; + + if (ui_app_info == NULL || icon == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_icon(ui_app_info->ui_app_info, &val); + app_icon_dup = strdup(val); + if (app_icon_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *icon = app_icon_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int ui_app_info_get_type(ui_app_info_h ui_app_info, char **type) +{ + char *val; + char *app_type_dup; + + if (ui_app_info == NULL || type == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_apptype(ui_app_info->ui_app_info, &val); + app_type_dup = strdup(val); + if (app_type_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *type = app_type_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int ui_app_info_get_package(ui_app_info_h ui_app_info, char **package) +{ + char *val; + char *package_dup; + + if (ui_app_info == NULL || package == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_pkgname(ui_app_info->ui_app_info, &val); + package_dup = strdup(val); + if (package_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *package = package_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int ui_app_info_is_equal(ui_app_info_h lhs, ui_app_info_h rhs, bool *equal) +{ + if (lhs == NULL || rhs == NULL || equal == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (!strcmp(lhs->app_id, rhs->app_id)) + { + *equal = true; + } + else + { + *equal = false; + } + return APP_MANAGER_ERROR_NONE; +} + +int ui_app_info_clone(ui_app_info_h *clone, ui_app_info_h ui_app_info) +{ + int retval; + if (clone == NULL || ui_app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + retval = ui_app_info_create(ui_app_info->app_id, clone); + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + return APP_MANAGER_ERROR_NONE; +} + +int service_app_info_destroy(service_app_info_h service_app_info) +{ + if (service_app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (service_app_info->app_id) { + free(service_app_info->app_id); + service_app_info->app_id = NULL; + } + pkgmgrinfo_appinfo_destroy_appinfo(service_app_info->service_app_info); + free(service_app_info); + return APP_MANAGER_ERROR_NONE; +} + +int service_app_info_get_app_id(service_app_info_h service_app_info, char **app_id) +{ + char *val; + char *app_id_dup; + + if (service_app_info == NULL || app_id == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_appid(service_app_info->service_app_info, &val); + app_id_dup = strdup(val); + if (app_id_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *app_id = app_id_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int service_app_info_get_label(service_app_info_h service_app_info, char **label) +{ + char *val; + char *app_label_dup; + + if (service_app_info == NULL || label == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_label(service_app_info->service_app_info, &val); + app_label_dup = strdup(val); + if (app_label_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *label = app_label_dup; + return APP_MANAGER_ERROR_NONE; +} + +int service_app_info_get_icon(service_app_info_h service_app_info, char **icon) +{ + char *val; + char *app_icon_dup; + + if (service_app_info == NULL || icon == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_icon(service_app_info->service_app_info, &val); + app_icon_dup = strdup(val); + if (app_icon_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *icon = app_icon_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int service_app_info_get_type(service_app_info_h service_app_info, char **type) +{ + char *val; + char *app_type_dup; + + if (service_app_info == NULL || type == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_apptype(service_app_info->service_app_info, &val); + app_type_dup = strdup(val); + if (app_type_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *type = app_type_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int service_app_info_get_package(service_app_info_h service_app_info, char **package) +{ + char *val; + char *package_dup; + + if (service_app_info == NULL || package == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + pkgmgrinfo_appinfo_get_pkgname(service_app_info->service_app_info, &val); + package_dup = strdup(val); + if (package_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *package = package_dup; + return APP_MANAGER_ERROR_NONE; +} + + +int service_app_info_is_equal(service_app_info_h lhs, service_app_info_h rhs, bool *equal) +{ + if (lhs == NULL || rhs == NULL || equal == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + if (!strcmp(lhs->app_id, rhs->app_id)) + { + *equal = true; + } + else + { + *equal = false; + } + return APP_MANAGER_ERROR_NONE; +} + +int service_app_info_clone(service_app_info_h *clone, service_app_info_h service_app_info) +{ + int retval; + if (clone == NULL || service_app_info == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + retval = service_app_info_create(service_app_info->app_id, clone); + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + return APP_MANAGER_ERROR_NONE; +} + +int service_app_info_is_onboot(service_app_info_h service_app_info, bool *onboot) +{ + bool val; + if (service_app_info == NULL || onboot == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + pkgmgrinfo_appinfo_is_onboot(service_app_info->service_app_info, &val); + *onboot = val; + return APP_MANAGER_ERROR_NONE; +} + +int service_app_info_is_autorestart(service_app_info_h service_app_info, bool *autorestart) +{ + bool val; + if (service_app_info == NULL || autorestart == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + pkgmgrinfo_appinfo_is_autorestart(service_app_info->service_app_info, &val); + *autorestart = val; + return APP_MANAGER_ERROR_NONE; +} + +#define __END_OF_DEPRECATED_API diff --git a/src/app_manager.c b/src/app_manager.c new file mode 100755 index 0000000..ad34612 --- /dev/null +++ b/src/app_manager.c @@ -0,0 +1,308 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <aul.h> +#include <dlog.h> + +#include <app_manager.h> +#include <app_manager_private.h> + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "CAPI_APPFW_APP_MANAGER" + + +static const char* app_manager_error_to_string(app_manager_error_e error) +{ + switch (error) + { + case APP_MANAGER_ERROR_NONE: + return "NONE"; + + case APP_MANAGER_ERROR_INVALID_PARAMETER: + return "INVALID_PARAMETER"; + + case APP_MANAGER_ERROR_OUT_OF_MEMORY: + return "OUT_OF_MEMORY"; + + case APP_MANAGER_ERROR_IO_ERROR: + return "IO_ERROR"; + + case APP_MANAGER_ERROR_NO_SUCH_APP: + return "NO_SUCH_APP"; + + case APP_MANAGER_ERROR_DB_FAILED: + return "DB_FAILED"; + + case APP_MANAGER_ERROR_INVALID_PACKAGE: + return "INVALID_PACKAGE"; + + default : + return "UNKNOWN"; + } +} + +int app_manager_error(app_manager_error_e error, const char* function, const char *description) +{ + if (description) + { + LOGE("[%s] %s(0x%08x) : %s", function, app_manager_error_to_string(error), error, description); + } + else + { + LOGE("[%s] %s(0x%08x)", function, app_manager_error_to_string(error), error); + } + + return error; +} + + +int app_manager_set_app_context_event_cb(app_manager_app_context_event_cb callback, void *user_data) +{ + int retval; + + retval = app_context_set_event_cb(callback, user_data); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +void app_manager_unset_app_context_event_cb(void) +{ + app_context_unset_event_cb(); +} + +int app_manager_foreach_app_context(app_manager_app_context_cb callback, void *user_data) +{ + int retval; + + retval = app_context_foreach_app_context(callback, user_data); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +int app_manager_get_app_context(const char *app_id, app_context_h *app_context) +{ + int retval; + + retval = app_context_get_app_context(app_id, app_context); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +int app_manager_resume_app(app_context_h app_context) +{ + char *app_id; + + if (app_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (app_context_get_app_id(app_context, &app_id) != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, "failed to get the application ID"); + } + + aul_resume_app(app_id); + + return APP_MANAGER_ERROR_NONE; +} + +int app_manager_set_app_info_event_cb(app_manager_app_info_event_cb callback, void *user_data) +{ + int retval; + + retval = app_info_set_event_cb(callback, user_data); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +void app_manager_unset_app_info_event_cb(void) +{ + app_info_unset_event_cb(); +} + + +int app_manager_foreach_app_info(app_manager_app_info_cb callback, void *user_data) +{ + int retval; + + retval = app_info_foreach_app_info(callback, user_data); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +int app_manager_get_app_info(const char *app_id, app_info_h *app_info) +{ + int retval; + + retval = app_info_get_app_info(app_id, app_info); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +int app_manager_get_ui_app_info(const char *app_id, ui_app_info_h *ui_app_info) +{ + int retval; + + retval = ui_app_info_get_app_info(app_id, ui_app_info); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +int app_manager_get_service_app_info(const char *app_id, service_app_info_h *service_app_info) +{ + int retval; + + retval = service_app_info_get_app_info(app_id, service_app_info); + + if (retval != APP_MANAGER_ERROR_NONE) + { + return app_manager_error(retval, __FUNCTION__, NULL); + } + else + { + return APP_MANAGER_ERROR_NONE; + } +} + +int app_manager_get_package(pid_t pid, char **package) +{ + // TODO: this function must be deprecated + return app_manager_get_app_id(pid, package); +} + +int app_manager_get_app_id(pid_t pid, char **app_id) +{ + char buffer[256] = {0, }; + char *app_id_dup = NULL; + + if (app_id == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (aul_app_get_appid_bypid(pid, buffer, sizeof(buffer)) != AUL_R_OK) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, "Invalid process ID"); + } + + app_id_dup = strdup(buffer); + + if (app_id_dup == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); + } + + *app_id = app_id_dup; + + return APP_MANAGER_ERROR_NONE; + +} + +int app_manager_terminate_app(app_context_h app_context) +{ + pid_t pid = 0; + + if (app_context == NULL) + { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); + } + + if (app_context_get_pid(app_context, &pid) != APP_MANAGER_ERROR_NONE) { + return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, "failed to get the process ID"); + } + + aul_terminate_pid(pid); + + return APP_MANAGER_ERROR_NONE; +} + +int app_manager_is_running(const char *app_id, bool *running) +{ + if (app_id == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid package", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + if (running == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid output param", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + *running = aul_app_is_running(app_id); + + return APP_MANAGER_ERROR_NONE; +} diff --git a/src/app_manager_deprecated.c b/src/app_manager_deprecated.c new file mode 100755 index 0000000..b13551e --- /dev/null +++ b/src/app_manager_deprecated.c @@ -0,0 +1,366 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <aul.h> +#include <aul_service.h> +#include <vconf.h> +#include <ail.h> +#include <package-manager.h> +#include <dlog.h> + +#include <app_manager.h> +#include <app_manager_private.h> + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "CAPI_APPFW_APP_MANAGER" + +typedef struct { + app_manager_app_running_cb cb; + void *user_data; + bool foreach_break; +} running_apps_foreach_cb_context; + +typedef struct { + app_manager_app_installed_cb cb; + void *user_data; +} installed_apps_foreach_cb_context; + +static pkgmgr_client *package_manager = NULL; +static app_manager_app_list_changed_cb app_list_changed_cb = NULL; +static void *app_list_changed_cb_data = NULL; + +static int foreach_running_app_cb_broker(const aul_app_info * appcore_app_info, void *appcore_user_data) +{ + ail_appinfo_h handle; + ail_error_e ret; + bool task_manage = false; + running_apps_foreach_cb_context *foreach_cb_context = NULL; + + if (appcore_app_info == NULL || appcore_user_data == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid callback context", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return 0; + } + + ret = ail_get_appinfo(appcore_app_info->pkg_name, &handle); + if (ret != AIL_ERROR_OK) + { + LOGE("[%s] DB_FAILED(0x%08x) : failed to get the app-info", __FUNCTION__, APP_MANAGER_ERROR_DB_FAILED); + return 0; + } + + // do not call callback function when X-SLP-TaskManage is set to false + ret = ail_appinfo_get_bool(handle, AIL_PROP_X_SLP_TASKMANAGE_BOOL, &task_manage); + + ail_destroy_appinfo(handle); + + if (ret != AIL_ERROR_OK || task_manage == false) + { + return 0; + } + + foreach_cb_context = (running_apps_foreach_cb_context *)appcore_user_data; + + if (foreach_cb_context->cb != NULL && foreach_cb_context->foreach_break == false) + { + if (foreach_cb_context->cb(appcore_app_info->pkg_name, foreach_cb_context->user_data) == false) + { + foreach_cb_context->foreach_break = true; + } + } + + return 0; +} + +static ail_cb_ret_e foreach_installed_app_cb_broker(const ail_appinfo_h appinfo, void *ail_user_data) +{ + installed_apps_foreach_cb_context *foreach_cb_context = NULL; + char *package; + + if (appinfo == NULL || ail_user_data == NULL) + { + return AIL_CB_RET_CANCEL; + } + + foreach_cb_context = (installed_apps_foreach_cb_context *)ail_user_data; + + ail_appinfo_get_str(appinfo, AIL_PROP_PACKAGE_STR, &package); + + if (foreach_cb_context->cb(package, foreach_cb_context->user_data) == false) + { + return AIL_CB_RET_CANCEL; + } + + return AIL_CB_RET_CONTINUE; + +} + + +static int app_manager_ail_error_handler(ail_error_e ail_error, const char *func) +{ + int error_code; + char *error_msg; + + switch(ail_error) + { + case AIL_ERROR_FAIL: + error_code = APP_MANAGER_ERROR_INVALID_PARAMETER; + error_msg = "INVALID_PARAMETER"; + break; + + case AIL_ERROR_DB_FAILED: + error_code = APP_MANAGER_ERROR_DB_FAILED; + error_msg = "DB_FAILED"; + break; + + case AIL_ERROR_OUT_OF_MEMORY: + error_code = APP_MANAGER_ERROR_OUT_OF_MEMORY; + error_msg = "OUT_OF_MEMORY"; + break; + + case AIL_ERROR_INVALID_PARAMETER: + error_code = APP_MANAGER_ERROR_INVALID_PARAMETER; + error_msg = "INVALID_PARAMETER"; + break; + + case AIL_ERROR_OK: + error_code = APP_MANAGER_ERROR_NONE; + break; + + default: + error_code = APP_MANAGER_ERROR_INVALID_PARAMETER; + error_msg = "INVALID_PARAMETER"; + } + + if (error_code != APP_MANAGER_ERROR_NONE) + { + LOGE("[%s] %s(0x%08x)", func, error_msg, error_code); + } + + return error_code; +} + + +int app_manager_foreach_app_running(app_manager_app_running_cb callback, void *user_data) +{ + running_apps_foreach_cb_context foreach_cb_context = { + .cb = callback, + .user_data = user_data, + .foreach_break = false + }; + + if (callback == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid callback", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + aul_app_get_running_app_info(foreach_running_app_cb_broker, &foreach_cb_context); + + return APP_MANAGER_ERROR_NONE; +} + + int app_manager_foreach_app_installed(app_manager_app_installed_cb callback, void *user_data) +{ + ail_filter_h filter; + ail_error_e ret; + + if (callback == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid callback", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + ret = ail_filter_new(&filter); + if (ret != AIL_ERROR_OK) + { + return app_manager_ail_error_handler(ret, __FUNCTION__); + } + + installed_apps_foreach_cb_context foreach_cb_context = { + .cb = callback, + .user_data = user_data, + }; + + ail_filter_list_appinfo_foreach(filter, foreach_installed_app_cb_broker, &foreach_cb_context); + + ail_filter_destroy(filter); + + return APP_MANAGER_ERROR_NONE; +} + +static int app_manager_get_appinfo(const char *package, const char *property, char **value) +{ + ail_error_e ail_error; + ail_appinfo_h appinfo; + char *appinfo_value; + char *appinfo_value_dup; + + ail_error = ail_get_appinfo(package, &appinfo); + if (ail_error != AIL_ERROR_OK) + { + return app_manager_ail_error_handler(ail_error, __FUNCTION__); + } + + ail_error = ail_appinfo_get_str(appinfo, property, &appinfo_value); + if (ail_error != AIL_ERROR_OK) + { + ail_destroy_appinfo(appinfo); + return app_manager_ail_error_handler(ail_error, __FUNCTION__); + } + + appinfo_value_dup = strdup(appinfo_value); + + ail_destroy_appinfo(appinfo); + + if (appinfo_value_dup == NULL) + { + LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, APP_MANAGER_ERROR_OUT_OF_MEMORY); + return APP_MANAGER_ERROR_OUT_OF_MEMORY; + } + + *value = appinfo_value_dup; + + return APP_MANAGER_ERROR_NONE; +} + +int app_manager_get_app_name(const char *package, char** name) +{ + if (package == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid package", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + return app_manager_get_appinfo(package, AIL_PROP_NAME_STR, name); +} + +int app_manager_get_app_icon_path(const char *package, char** icon_path) +{ + if (package == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid package", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + return app_manager_get_appinfo(package, AIL_PROP_ICON_STR, icon_path); +} + +int app_manager_get_app_version(const char *package, char** version) +{ + if (package == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid package", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + return app_manager_get_appinfo(package, AIL_PROP_VERSION_STR, version); +} + +static app_manger_event_type_e app_manager_app_list_pkgmgr_event(const char *value) +{ + if (!strcasecmp(value, "install")) + { + return APP_MANAGER_EVENT_INSTALLED; + } + else if (!strcasecmp(value, "uninstall")) + { + return APP_MANAGER_EVENT_UNINSTALLED; + } + else if (!strcasecmp(value, "update")) + { + return APP_MANAGER_EVENT_UPDATED; + } + else + { + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } +} + +static int app_manager_app_list_changed_cb_broker(int id, const char *type, const char *package, const char *key, const char *val, const void *msg, void *data) +{ + static int event_id = -1; + static app_manger_event_type_e event_type; + + if (!strcasecmp(key, "start")) + { + event_id = id; + event_type = app_manager_app_list_pkgmgr_event(val); + } + else if (!strcasecmp(key, "end") && !strcasecmp(val, "ok") && id == event_id) + { + if (app_list_changed_cb != NULL && event_type >= 0) + { + app_list_changed_cb(event_type, package, app_list_changed_cb_data); + } + + event_id = -1; + event_type = -1; + } + + return APP_MANAGER_ERROR_NONE; +} + +int app_manager_set_app_list_changed_cb(app_manager_app_list_changed_cb callback, void* user_data) +{ + if (callback == NULL) + { + LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER); + return APP_MANAGER_ERROR_INVALID_PARAMETER; + } + + if (app_list_changed_cb == NULL) + { + package_manager = pkgmgr_client_new(PC_LISTENING); + + if (package_manager == NULL) + { + LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, APP_MANAGER_ERROR_OUT_OF_MEMORY); + return APP_MANAGER_ERROR_OUT_OF_MEMORY; + } + + pkgmgr_client_listen_status(package_manager, app_manager_app_list_changed_cb_broker, NULL); + } + + app_list_changed_cb = callback; + app_list_changed_cb_data = user_data; + + return APP_MANAGER_ERROR_NONE; +} + +int app_manager_unset_app_list_changed_cb() +{ + if (app_list_changed_cb != NULL) + { + pkgmgr_client_free(package_manager); + package_manager = NULL; + } + + app_list_changed_cb = NULL; + app_list_changed_cb_data = NULL; + + return APP_MANAGER_ERROR_NONE; +} + |