static bool _get_bool_value(const char *str)
{
- if (str == NULL)
- return false;
- else if (!strcasecmp(str, "true"))
+ if (str && !strcmp(str, "true"))
return true;
else
return false;
static void __cleanup_appinfo(pkgmgr_appinfo_x *data)
{
pkgmgr_appinfo_x *info = data;
- pkgmgr_appinfo_x *tmp;
- while (info != NULL) {
- tmp = info->next;
+ if (info != NULL) {
if (info->package)
free((void *)info->package);
if (info->locale)
pkgmgrinfo_basic_free_application(info->app_info);
free((void *)info);
- info = tmp;
}
return;
}
-static char *_get_filtered_query(const char *query_raw,
- pkgmgrinfo_filter_x *filter)
-{
- char buf[MAX_QUERY_LEN] = { 0, };
- char *condition;
- size_t len;
+static const char join_localized_info[] =
+ " LEFT OUTER JOIN package_app_localized_info"
+ " ON ai.app_id=package_app_localized_info.app_id"
+ " AND package_app_localized_info.app_locale=?";
+static const char join_category[] =
+ " LEFT OUTER JOIN package_app_app_category"
+ " ON ai.app_id=package_app_app_category.app_id";
+static const char join_app_control[] =
+ " LEFT OUTER JOIN package_app_app_control"
+ " ON ai.app_id=package_app_app_control.app_id";
+static const char join_metadata[] =
+ " LEFT OUTER JOIN package_app_app_metadata"
+ " ON ai.app_id=package_app_app_metadata.app_id ";
+
+static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
+ const char *locale, uid_t uid, char **query, GList **bind_params)
+{
+ int joined = 0;
+ size_t len = 0;
+ char *condition = NULL;
+ char buf[MAX_QUERY_LEN] = { '\0' };
+ char tmp_query[MAX_QUERY_LEN] = { '\0' };
+ static const char query_pkg_disable[] = " AND ai.package IN "
+ "(SELECT package FROM package_info WHERE package_disable='false')";
GSList *list;
- GSList *head = NULL;
- if (filter)
- head = filter->list;
+ strncat(buf, " WHERE 1=1", MAX_QUERY_LEN - len - 1);
+ len += strlen(" WHERE 1=1");
+
+ if (filter == NULL) {
+ strncat(buf, query_pkg_disable, MAX_QUERY_LEN - len - 1);
+ *query = strdup(buf);
+ return PMINFO_R_OK;
+ }
- strncat(buf, query_raw, MAX_QUERY_LEN - 1);
- len = strlen(buf);
- for (list = head; list; list = list->next) {
- /* TODO: revise condition getter function */
- __get_filter_condition(list->data, &condition);
+ for (list = filter->list; list; list = list->next) {
+ joined |= __get_filter_condition(list->data, uid, &condition, bind_params);
if (condition == NULL)
continue;
- if (buf[strlen(query_raw)] == '\0') {
- len += strlen(" WHERE ");
- strncat(buf, " WHERE ", MAX_QUERY_LEN - len - 1);
- } else {
- len += strlen(" AND ");
- strncat(buf, " AND ", MAX_QUERY_LEN -len - 1);
- }
- len += strlen(condition);
+
+ strncat(buf, " AND ", MAX_QUERY_LEN - len - 1);
+ len += strlen(" AND ");
+
strncat(buf, condition, sizeof(buf) - len - 1);
+ len += strlen(condition);
free(condition);
condition = NULL;
}
- return strdup(buf);
-}
-
-static gint __list_strcmp(gconstpointer a, gconstpointer b)
-{
- return strcmp((char *)a, (char *)b);
-}
-
-static gint _appinfo_get_list(sqlite3 *db, const char *locale,
- pkgmgrinfo_filter_x *filter, GList **list)
-{
- static const char query_raw[] =
- "SELECT DISTINCT package_app_info.app_id FROM package_app_info"
- " LEFT OUTER JOIN package_app_localized_info"
- " ON package_app_info.app_id=package_app_localized_info.app_id"
- " AND package_app_localized_info.app_locale=%Q"
- " LEFT OUTER JOIN package_app_app_category"
- " ON package_app_info.app_id=package_app_app_category.app_id"
- " LEFT OUTER JOIN package_app_app_control"
- " ON package_app_info.app_id=package_app_app_control.app_id"
- " LEFT OUTER JOIN package_app_app_metadata"
- " ON package_app_info.app_id=package_app_app_metadata.app_id ";
- int ret;
- char *query;
- char *query_localized;
- sqlite3_stmt *stmt;
- char *appid = NULL;
-
- query = _get_filtered_query(query_raw, filter);
- if (query == NULL)
- return PMINFO_R_ERROR;
- query_localized = sqlite3_mprintf(query, locale);
- free(query);
- if (query_localized == NULL)
- return PMINFO_R_ERROR;
-
- ret = sqlite3_prepare_v2(db, query_localized,
- strlen(query_localized), &stmt, NULL);
- sqlite3_free(query_localized);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
- return PMINFO_R_ERROR;
- }
-
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- _save_column_str(stmt, 0, (const char **)&appid);
- if (appid != NULL)
- *list = g_list_insert_sorted(*list, appid,
- __list_strcmp);
- }
-
- sqlite3_finalize(stmt);
-
- return PMINFO_R_OK;
-}
-
-static int _appinfo_get_filtered_list(pkgmgrinfo_filter_x *filter, uid_t uid,
- GList **list)
-{
- int ret;
- sqlite3 *db;
- const char *dbpath;
- char *locale;
- GList *tmp;
- GList *tmp2;
-
- locale = _get_system_locale();
- if (locale == NULL)
- return PMINFO_R_ERROR;
-
- dbpath = getUserPkgParserDBPathUID(uid);
- if (dbpath == NULL) {
- free(locale);
- return PMINFO_R_ERROR;
- }
-
- ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
- if (ret != SQLITE_OK) {
- _LOGE("failed to open db: %d", ret);
- free(locale);
- return PMINFO_R_ERROR;
- }
-
- if (_appinfo_get_list(db, locale, filter, list)) {
- free(locale);
- sqlite3_close_v2(db);
- return PMINFO_R_ERROR;
- }
- sqlite3_close_v2(db);
-
- if (uid == GLOBAL_USER) {
- free(locale);
- return PMINFO_R_OK;
+ if (filter->list_metadata) {
+ strncat(buf, " AND (", MAX_QUERY_LEN - len - 1);
+ len += strlen(" AND (");
}
+ for (list = filter->list_metadata; list; list = list->next) {
+ joined |= __get_metadata_filter_condition(list->data,
+ &condition, bind_params);
+ if (condition == NULL)
+ continue;
+ strncat(buf, condition, sizeof(buf) - len - 1);
+ len += strlen(condition);
+ free(condition);
+ condition = NULL;
- /* search again from global */
- dbpath = getUserPkgParserDBPathUID(GLOBAL_USER);
- if (dbpath == NULL) {
- free(locale);
- return PMINFO_R_ERROR;
+ strncat(buf, " OR ", MAX_QUERY_LEN - len - 1);
+ len += strlen(" OR ");
}
-
- ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
- if (ret != SQLITE_OK) {
- _LOGE("failed to open db: %d", ret);
- free(locale);
- return PMINFO_R_ERROR;
+ if (filter->list_metadata) {
+ strncat(buf, "1=0)", MAX_QUERY_LEN - len - 1);
+ len += strlen("1=0)");
}
- if (_appinfo_get_list(db, locale, filter, list)) {
- free(locale);
- sqlite3_close_v2(db);
- return PMINFO_R_ERROR;
+ if (joined & E_PMINFO_APPINFO_JOIN_LOCALIZED_INFO) {
+ strncat(tmp_query, join_localized_info, MAX_QUERY_LEN - len - 1);
+ len += strlen(join_localized_info);
+ *bind_params = g_list_append(*bind_params, strdup(locale));
}
- sqlite3_close_v2(db);
-
- /* remove duplicate element:
- * since the list is sorted, we can remove duplicates in linear time
- */
- for (tmp = *list, tmp2 = g_list_next(tmp); tmp;
- tmp = tmp2, tmp2 = g_list_next(tmp)) {
- if (tmp->prev == NULL || tmp->data == NULL)
- continue;
- if (strcmp((const char *)tmp->prev->data,
- (const char *)tmp->data) == 0)
- *list = g_list_delete_link(*list, tmp);
+ if (joined & E_PMINFO_APPINFO_JOIN_CATEGORY) {
+ strncat(tmp_query, join_category, MAX_QUERY_LEN - len - 1);
+ len += strlen(join_category);
}
-
- free(locale);
-
- return PMINFO_R_OK;
-}
-
-static int _appinfo_get_label(sqlite3 *db, const char *appid,
- const char *locale, GList **label)
-{
- static const char query_raw[] =
- "SELECT app_label, app_locale "
- "FROM package_app_localized_info "
- "WHERE app_id=%Q AND app_locale IN (%Q, %Q)";
- int ret;
- char *query;
- sqlite3_stmt *stmt;
- int idx;
- label_x *info;
-
- query = sqlite3_mprintf(query_raw, appid, locale, DEFAULT_LOCALE);
- if (query == NULL) {
- LOGE("out of memory");
- return PMINFO_R_ERROR;
+ if (joined & E_PMINFO_APPINFO_JOIN_APP_CONTROL) {
+ strncat(tmp_query, join_app_control, MAX_QUERY_LEN - len - 1);
+ len += strlen(join_app_control);
}
-
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
- return PMINFO_R_ERROR;
+ if (joined & E_PMINFO_APPINFO_JOIN_METADATA) {
+ strncat(tmp_query, join_metadata, MAX_QUERY_LEN - len - 1);
+ len += strlen(join_metadata);
}
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = calloc(1, sizeof(label_x));
- if (info == NULL) {
- LOGE("out of memory");
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
- }
- idx = 0;
- _save_column_str(stmt, idx++, &info->text);
- _save_column_str(stmt, idx++, &info->lang);
- *label = g_list_append(*label, info);
- }
-
- sqlite3_finalize(stmt);
-
- return PMINFO_R_OK;
-}
-
-static void _appinfo_modify_icon(const char *appid, const char **icon)
-{
- char buf[PKG_VALUE_STRING_LEN_MAX];
- const char *tmp;
-
- if (*icon == NULL || (*icon)[0] == '/' || !strcasecmp(*icon, "(null)"))
- return;
+ strncat(tmp_query, buf, MAX_QUERY_LEN - len - 1);
+ len += strlen(buf);
- tmp = *icon;
- snprintf(buf, sizeof(buf), "%s%s.png", getIconPath(getuid()), appid);
- *icon = strdup(buf);
- free((char *)tmp);
-}
+ strncat(tmp_query, query_pkg_disable, MAX_QUERY_LEN - len - 1);
-static int _appinfo_get_icon(sqlite3 *db, const char *appid, const char *locale,
- GList **icon)
-{
- static const char query_raw[] =
- "SELECT app_icon, app_locale "
- "FROM package_app_localized_info "
- "WHERE app_id=%Q AND app_locale IN (%Q, %Q)";
- int ret;
- char *query;
- sqlite3_stmt *stmt;
- int idx;
- icon_x *info;
-
- query = sqlite3_mprintf(query_raw, appid, locale, DEFAULT_LOCALE);
- if (query == NULL) {
- LOGE("out of memory");
- return PMINFO_R_ERROR;
- }
-
- ret = sqlite3_prepare_v2(db, query, strlen(query),
- &stmt, NULL);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ *query = strdup(tmp_query);
+ if (*query == NULL)
return PMINFO_R_ERROR;
- }
-
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = calloc(1, sizeof(icon_x));
- if (info == NULL) {
- LOGE("out of memory");
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
- }
- idx = 0;
- _save_column_str(stmt, idx++, &info->text);
- /* FIXME: this is a workaround. this must be removed later */
- _appinfo_modify_icon(appid, &info->text);
- _save_column_str(stmt, idx++, &info->lang);
- *icon = g_list_append(*icon, info);
- }
-
- sqlite3_finalize(stmt);
return PMINFO_R_OK;
}
int ret;
char *query;
sqlite3_stmt *stmt;
- const char *val;
+ char *val;
query = sqlite3_mprintf(query_raw, appid);
if (query == NULL) {
while (sqlite3_step(stmt) == SQLITE_ROW) {
str = NULL;
- _save_column_str(stmt, 0, (const char **)&str);
+ _save_column_str(stmt, 0, &str);
/* TODO: revise */
__parse_appcontrol(appcontrol, str);
free(str);
return PMINFO_R_OK;
}
-static int _appinfo_get_data_control(sqlite3 *db, const char *appid,
- GList **datacontrol)
+static int _appinfo_get_metadata(sqlite3 *db, const char *appid,
+ GList **metadata)
{
static const char query_raw[] =
- "SELECT providerid, access, type "
- "FROM package_app_data_control WHERE app_id=%Q";
+ "SELECT md_key, md_value "
+ "FROM package_app_app_metadata WHERE app_id=%Q";
int ret;
char *query;
sqlite3_stmt *stmt;
int idx;
- datacontrol_x *info;
+ metadata_x *info;
query = sqlite3_mprintf(query_raw, appid);
if (query == NULL) {
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = calloc(1, sizeof(datacontrol_x));
+ info = calloc(1, sizeof(metadata_x));
if (info == NULL) {
LOGE("out of memory");
sqlite3_finalize(stmt);
return PMINFO_R_ERROR;
}
idx = 0;
- _save_column_str(stmt, idx++, &info->providerid);
- _save_column_str(stmt, idx++, &info->access);
- _save_column_str(stmt, idx++, &info->type);
- *datacontrol = g_list_append(*datacontrol, info);
+ _save_column_str(stmt, idx++, &info->key);
+ _save_column_str(stmt, idx++, &info->value);
+ *metadata = g_list_append(*metadata, info);
}
sqlite3_finalize(stmt);
return PMINFO_R_OK;
+
}
-static int _appinfo_get_metadata(sqlite3 *db, const char *appid,
- GList **metadata)
+static int _appinfo_get_splashscreens(sqlite3 *db, const char *appid,
+ GList **splashscreens)
{
static const char query_raw[] =
- "SELECT md_key, md_value "
- "FROM package_app_app_metadata WHERE app_id=%Q";
+ "SELECT src, type, orientation, indicatordisplay, operation, color_depth "
+ "FROM package_app_splash_screen WHERE app_id=%Q";
int ret;
char *query;
sqlite3_stmt *stmt;
int idx;
- metadata_x *info;
+ splashscreen_x *info;
query = sqlite3_mprintf(query_raw, appid);
if (query == NULL) {
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = calloc(1, sizeof(metadata_x));
+ info = calloc(1, sizeof(splashscreen_x));
if (info == NULL) {
LOGE("out of memory");
sqlite3_finalize(stmt);
return PMINFO_R_ERROR;
}
idx = 0;
- _save_column_str(stmt, idx++, &info->key);
- _save_column_str(stmt, idx++, &info->value);
- *metadata = g_list_append(*metadata, info);
+ _save_column_str(stmt, idx++, &info->src);
+ _save_column_str(stmt, idx++, &info->type);
+ _save_column_str(stmt, idx++, &info->orientation);
+ _save_column_str(stmt, idx++, &info->indicatordisplay);
+ _save_column_str(stmt, idx++, &info->operation);
+ _save_column_str(stmt, idx++, &info->color_depth);
+ *splashscreens = g_list_append(*splashscreens, info);
}
sqlite3_finalize(stmt);
return PMINFO_R_OK;
-
}
-static GList *__get_background_category(char *value)
+static GList *__get_background_category(const char *value)
{
GList *category_list = NULL;
int convert_value = 0;
}
-static int _appinfo_get_application(sqlite3 *db, const char *appid,
- const char *locale, application_x **application)
+static void __free_applications(gpointer data)
{
- static const char query_raw[] =
- "SELECT app_id, app_component, app_exec, app_nodisplay, "
- "app_type, app_onboot, app_multiple, app_autorestart, "
- "app_taskmanage, app_enabled, app_hwacceleration, "
- "app_screenreader, app_mainapp, app_recentimage, "
- "app_launchcondition, app_indicatordisplay, app_portraitimg, "
- "app_landscapeimg, app_guestmodevisibility, "
- "app_permissiontype, app_preload, app_submode, "
- "app_submode_mainid, app_launch_mode, app_ui_gadget, "
- "app_support_disable, "
- "component_type, package, app_process_pool, app_installed_storage, "
- "app_background_category, app_package_type "
- "FROM package_app_info WHERE app_id='%s' AND app_disable='false' "
- "AND app_id NOT IN "
- "(SELECT app_id from package_app_disable_for_user WHERE uid='%d')";
+ pkgmgrinfo_basic_free_application((application_x *)data);
+}
+
+static gint __app_disable_chk_func(gconstpointer data1, gconstpointer data2)
+{
+ pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)data1;
+
+ if (node->prop == E_PMINFO_APPINFO_PROP_APP_DISABLE)
+ return 0;
+ else
+ return 1;
+}
+
+static bool __check_disable_filter_exist(pkgmgrinfo_filter_x *filter)
+{
+ GSList *link;
+
+ if (filter == NULL)
+ return false;
+
+ link = g_slist_find_custom(filter->list, NULL, __app_disable_chk_func);
+ if (link)
+ return true;
+
+ return false;
+}
+
+static int __bind_params(sqlite3_stmt *stmt, GList *params)
+{
+ GList *tmp_list = NULL;
+ int idx = 0;
int ret;
- char query[MAX_QUERY_LEN] = { '\0' };
- sqlite3_stmt *stmt;
+
+ if (stmt == NULL || params == NULL)
+ return PMINFO_R_EINVAL;
+
+ tmp_list = params;
+ while (tmp_list) {
+ ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC);
+ if (ret != SQLITE_OK)
+ return PMINFO_R_ERROR;
+ tmp_list = tmp_list->next;
+ }
+
+ return PMINFO_R_OK;
+}
+
+static bool __check_app_storage_status(pkgmgrinfo_filter_x *tmp_filter)
+{
+ GSList *tmp_list = NULL;
+ pkgmgrinfo_node_x *tmp_node = NULL;
+ int property = -1;
+
+ if (tmp_filter == NULL)
+ return true;
+
+ property = _pminfo_appinfo_convert_to_prop_bool(PMINFO_APPINFO_PROP_APP_CHECK_STORAGE);
+ for (tmp_list = tmp_filter->list; tmp_list != NULL;
+ tmp_list = g_slist_next(tmp_list)) {
+ tmp_node = (pkgmgrinfo_node_x *)tmp_list->data;
+ if (property == tmp_node->prop) {
+ if (strcmp(tmp_node->value, "true") == 0)
+ return true;
+ else
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static int _appinfo_get_applications(uid_t db_uid, uid_t uid,
+ const char *locale, pkgmgrinfo_filter_x *filter, int flag,
+ GHashTable *applications)
+{
+ static const char query_raw[] =
+ "SELECT DISTINCT ai.app_id, ai.app_installed_storage, "
+ "ai.app_external_path";
+ static const char query_basic[] =
+ ", ai.app_component, ai.app_exec, "
+ "ai.app_nodisplay, ai.app_type, ai.app_onboot, "
+ "ai.app_multiple, ai.app_autorestart, ai.app_taskmanage, "
+ "ai.app_hwacceleration, ai.app_screenreader, "
+ "ai.app_mainapp, ai.app_recentimage, ai.app_launchcondition, "
+ "ai.app_indicatordisplay, ai.app_portraitimg, "
+ "ai.app_landscapeimg, ai.app_guestmodevisibility, "
+ "ai.app_permissiontype, ai.app_preload, ai.app_submode, "
+ "ai.app_submode_mainid, ai.app_launch_mode, ai.app_ui_gadget, "
+ "ai.app_support_disable, ai.app_process_pool, "
+ "ai.app_background_category, ai.app_package_type, "
+ "ai.app_root_path, ai.app_api_version, ai.app_effective_appid, "
+ "ai.app_disable, ai.app_splash_screen_display, ai.app_tep_name, "
+ "ai.app_zip_mount_file, ai.component_type, ai.package, "
+ "ai.app_package_system, ai.app_removable, "
+ "ai.app_package_installed_time, ai.app_support_mode, "
+ "ai.app_support_ambient, ai.app_setup_appid";
+ static const char query_uid_info[] =
+ ", ui.is_disabled, ui.is_splash_screen_enabled";
+ static const char query_label[] =
+ ", COALESCE("
+ "(SELECT app_label FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale=?), "
+ "(SELECT app_label FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale='No Locale'))";
+ static const char query_icon[] =
+ ", COALESCE("
+ "(SELECT app_icon FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale=?), "
+ "(SELECT app_icon FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale='No Locale'))";
+ static const char query_from_clause[] = " FROM package_app_info as ai";
+ static const char query_uid_info_clause[] =
+ " LEFT OUTER JOIN package_app_info_for_uid AS ui "
+ "ON (ai.app_id=ui.app_id AND ui.uid=?)";
+ int ret = PMINFO_R_ERROR;
int idx;
- application_x *info;
+ int len = 0;
+ char *dbpath;
char *bg_category_str = NULL;
- snprintf(query, MAX_QUERY_LEN - 1, query_raw, appid, (int)getuid());
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
- return PMINFO_R_ERROR;
- }
+ char *constraint = NULL;
+ char *tmp_record = NULL;
+ char query[MAX_QUERY_LEN] = { '\0' };
+ char buf[BUFSIZE] = { '\0' };
+ application_x *info = NULL;
+ GList *bind_params = NULL;
+ sqlite3 *db = NULL;
+ sqlite3_stmt *stmt = NULL;
+ bool is_check_storage = true;
+ const uid_t global_user_uid = GLOBAL_USER;
- ret = sqlite3_step(stmt);
- if (ret == SQLITE_DONE) {
- sqlite3_finalize(stmt);
- return PMINFO_R_ENOENT;
- } else if (ret != SQLITE_ROW) {
- LOGE("step failed: %s", sqlite3_errmsg(db));
- sqlite3_finalize(stmt);
+ dbpath = getUserPkgParserDBPathUID(db_uid);
+ if (dbpath == NULL)
return PMINFO_R_ERROR;
- }
- info = calloc(1, sizeof(application_x));
- if (info == NULL) {
- LOGE("out of memory");
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
- }
- idx = 0;
- _save_column_str(stmt, idx++, &info->appid);
- _save_column_str(stmt, idx++, &info->component);
- _save_column_str(stmt, idx++, &info->exec);
- _save_column_str(stmt, idx++, &info->nodisplay);
- _save_column_str(stmt, idx++, &info->type);
- _save_column_str(stmt, idx++, &info->onboot);
- _save_column_str(stmt, idx++, &info->multiple);
- _save_column_str(stmt, idx++, &info->autorestart);
- _save_column_str(stmt, idx++, &info->taskmanage);
- _save_column_str(stmt, idx++, &info->enabled);
- _save_column_str(stmt, idx++, &info->hwacceleration);
- _save_column_str(stmt, idx++, &info->screenreader);
- _save_column_str(stmt, idx++, &info->mainapp);
- _save_column_str(stmt, idx++, &info->recentimage);
- _save_column_str(stmt, idx++, &info->launchcondition);
- _save_column_str(stmt, idx++, &info->indicatordisplay);
- _save_column_str(stmt, idx++, &info->portraitimg);
- _save_column_str(stmt, idx++, &info->landscapeimg);
- _save_column_str(stmt, idx++, &info->guestmode_visibility);
- _save_column_str(stmt, idx++, &info->permission_type);
- _save_column_str(stmt, idx++, &info->preload);
- _save_column_str(stmt, idx++, &info->submode);
- _save_column_str(stmt, idx++, &info->submode_mainid);
- _save_column_str(stmt, idx++, &info->launch_mode);
- _save_column_str(stmt, idx++, &info->ui_gadget);
- _save_column_str(stmt, idx++, &info->support_disable);
- _save_column_str(stmt, idx++, &info->component_type);
- _save_column_str(stmt, idx++, &info->package);
- _save_column_str(stmt, idx++, &info->process_pool);
- _save_column_str(stmt, idx++, &info->installed_storage);
- _save_column_str(stmt, idx++, &bg_category_str);
- _save_column_str(stmt, idx++, &info->package_type);
-
- info->background_category = __get_background_category(bg_category_str);
-
- if (_appinfo_get_label(db, info->appid, locale, &info->label)) {
- pkgmgrinfo_basic_free_application(info);
- sqlite3_finalize(stmt);
+ ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
+ if (ret != SQLITE_OK) {
+ _LOGE("failed to open db(%s): %d", dbpath, ret);
+ free(dbpath);
return PMINFO_R_ERROR;
}
+ free(dbpath);
- if (_appinfo_get_icon(db, info->appid, locale, &info->icon)) {
- pkgmgrinfo_basic_free_application(info);
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
+ len = strlen(query_raw);
+ snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
+
+ if (flag & PMINFO_APPINFO_GET_BASICINFO) {
+ strncat(query, query_basic, MAX_QUERY_LEN - len - 1);
+ len += strlen(query_basic);
+ strncat(query, query_uid_info, MAX_QUERY_LEN - len - 1);
+ len += strlen(query_uid_info);
+ }
+ if (flag & PMINFO_APPINFO_GET_LABEL) {
+ strncat(query, query_label, MAX_QUERY_LEN - len - 1);
+ len += strlen(query_label);
+ bind_params = g_list_append(bind_params, strdup(locale));
+ }
+ if (flag & PMINFO_APPINFO_GET_ICON) {
+ strncat(query, query_icon, MAX_QUERY_LEN - len - 1);
+ len += strlen(query_icon);
+ bind_params = g_list_append(bind_params, strdup(locale));
}
- if (_appinfo_get_category(db, info->appid, &info->category)) {
- pkgmgrinfo_basic_free_application(info);
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
+ snprintf(buf, MAX_QUERY_LEN - 1, "%d", uid);
+ bind_params = g_list_append(bind_params, strdup(buf));
+
+ is_check_storage = __check_app_storage_status(filter);
+
+ ret = _get_filtered_query(filter, locale, uid, &constraint, &bind_params);
+ if (ret != PMINFO_R_OK) {
+ LOGE("Failed to get WHERE clause");
+ goto catch;
}
+ strncat(query, query_from_clause, MAX_QUERY_LEN - len - 1);
+ len += strlen(query_from_clause);
- if (_appinfo_get_app_control(db, info->appid, &info->appcontrol)) {
- pkgmgrinfo_basic_free_application(info);
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
+ strncat(query, query_uid_info_clause, MAX_QUERY_LEN - len - 1);
+ len += strlen(query_uid_info_clause);
+
+ if (constraint)
+ strncat(query, constraint, MAX_QUERY_LEN - len - 1);
+
+ ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ ret = PMINFO_R_ERROR;
+ goto catch;
}
- if (_appinfo_get_data_control(db, info->appid, &info->datacontrol)) {
- pkgmgrinfo_basic_free_application(info);
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
+ if (g_list_length(bind_params) != 0) {
+ ret = __bind_params(stmt, bind_params);
+ if (ret != SQLITE_OK) {
+ LOGE("Failed to bind parameters");
+ goto catch;
+ }
}
- if (_appinfo_get_metadata(db, info->appid, &info->metadata)) {
- pkgmgrinfo_basic_free_application(info);
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ info = calloc(1, sizeof(application_x));
+ if (info == NULL) {
+ LOGE("out of memory");
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ idx = 0;
+ _save_column_str(stmt, idx++, &info->appid);
+ _save_column_str(stmt, idx++, &info->installed_storage);
+ _save_column_str(stmt, idx++ , &info->external_path);
+
+ if (flag & PMINFO_APPINFO_GET_BASICINFO) {
+ _save_column_str(stmt, idx++, &info->component);
+ _save_column_str(stmt, idx++, &info->exec);
+ _save_column_str(stmt, idx++, &info->nodisplay);
+ _save_column_str(stmt, idx++, &info->type);
+ _save_column_str(stmt, idx++, &info->onboot);
+ _save_column_str(stmt, idx++, &info->multiple);
+ _save_column_str(stmt, idx++, &info->autorestart);
+ _save_column_str(stmt, idx++, &info->taskmanage);
+ _save_column_str(stmt, idx++, &info->hwacceleration);
+ _save_column_str(stmt, idx++, &info->screenreader);
+ _save_column_str(stmt, idx++, &info->mainapp);
+ _save_column_str(stmt, idx++, &info->recentimage);
+ _save_column_str(stmt, idx++, &info->launchcondition);
+ _save_column_str(stmt, idx++, &info->indicatordisplay);
+ _save_column_str(stmt, idx++, &info->portraitimg);
+ _save_column_str(stmt, idx++, &info->landscapeimg);
+ _save_column_str(stmt, idx++, &info->guestmode_visibility);
+ _save_column_str(stmt, idx++, &info->permission_type);
+ _save_column_str(stmt, idx++, &info->preload);
+ _save_column_str(stmt, idx++, &info->submode);
+ _save_column_str(stmt, idx++, &info->submode_mainid);
+ _save_column_str(stmt, idx++, &info->launch_mode);
+ _save_column_str(stmt, idx++, &info->ui_gadget);
+ _save_column_str(stmt, idx++, &info->support_disable);
+ _save_column_str(stmt, idx++, &info->process_pool);
+ _save_column_str(stmt, idx++, &bg_category_str);
+ _save_column_str(stmt, idx++, &info->package_type);
+ _save_column_str(stmt, idx++, &info->root_path);
+ _save_column_str(stmt, idx++, &info->api_version);
+ _save_column_str(stmt, idx++, &info->effective_appid);
+ _save_column_str(stmt, idx++, &info->is_disabled);
+ _save_column_str(stmt, idx++, &info->splash_screen_display);
+ _save_column_str(stmt, idx++, &info->tep_name);
+ _save_column_str(stmt, idx++, &info->zip_mount_file);
+ _save_column_str(stmt, idx++, &info->component_type);
+ _save_column_str(stmt, idx++, &info->package);
+ _save_column_str(stmt, idx++, &info->package_system);
+ _save_column_str(stmt, idx++, &info->removable);
+ _save_column_str(stmt, idx++, &info->package_installed_time);
+ _save_column_str(stmt, idx++, &info->support_mode);
+ _save_column_str(stmt, idx++, &info->support_ambient);
+ _save_column_str(stmt, idx++, &info->setup_appid);
+ info->background_category = __get_background_category(
+ bg_category_str);
+ free(bg_category_str);
+ }
+
+ info->for_all_users =
+ strdup((db_uid != global_user_uid) ? "false" : "true");
+
+ if (db_uid != global_user_uid) {
+ idx = idx + 2;
+ } else {
+ tmp_record = NULL;
+ _save_column_str(stmt, idx++, &tmp_record);
+ if (tmp_record != NULL) {
+ if (strcasecmp(info->is_disabled, "false") == 0 &&
+ strcasecmp(tmp_record, "false") == 0) {
+ free(info->is_disabled);
+ info->is_disabled = tmp_record;
+ }
+ }
+ tmp_record = NULL;
+ _save_column_str(stmt, idx++, &tmp_record);
+ if (tmp_record != NULL) {
+ if (strcasecmp(info->splash_screen_display, "false") == 0 &&
+ strcasecmp(tmp_record, "false") == 0) {
+ free(info->splash_screen_display);
+ info->splash_screen_display = tmp_record;
+ }
+ }
+ }
+
+ if (flag & PMINFO_APPINFO_GET_LABEL) {
+ tmp_record = NULL;
+ _save_column_str(stmt, idx++, &tmp_record);
+ if (_add_label_info_into_list(locale, tmp_record, &info->label)) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ }
+
+ if (flag & PMINFO_APPINFO_GET_ICON) {
+ tmp_record = NULL;
+ _save_column_str(stmt, idx++, &tmp_record);
+ if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ }
+
+ if (flag & PMINFO_APPINFO_GET_CATEGORY) {
+ if (_appinfo_get_category(db, info->appid,
+ &info->category)) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ }
+
+ if (flag & PMINFO_APPINFO_GET_APP_CONTROL) {
+ if (_appinfo_get_app_control(db, info->appid,
+ &info->appcontrol)) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ }
+
+ if (flag & PMINFO_APPINFO_GET_METADATA) {
+ if (_appinfo_get_metadata(db, info->appid,
+ &info->metadata)) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ }
+
+ if (flag & PMINFO_APPINFO_GET_SPLASH_SCREEN) {
+ if (_appinfo_get_splashscreens(db, info->appid,
+ &info->splashscreens)) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ }
+
+ if (is_check_storage &&
+ __appinfo_check_installed_storage(info) != PMINFO_R_OK) {
+ ret = PMINFO_R_ERROR;
+ pkgmgrinfo_basic_free_application(info);
+ info = NULL;
+ continue;
+ }
+
+ g_hash_table_insert(applications, (gpointer)info->appid,
+ (gpointer)info);
}
- *application = info;
+ ret = PMINFO_R_OK;
+
+catch:
+ if (constraint)
+ free(constraint);
+
+ if (ret != PMINFO_R_OK && info != NULL)
+ pkgmgrinfo_basic_free_application(info);
+ g_list_free_full(bind_params, free);
+ sqlite3_close_v2(db);
sqlite3_finalize(stmt);
- return PMINFO_R_OK;
+ return ret;
}
-static int _appinfo_get_appinfo(const char *appid, uid_t uid,
- pkgmgr_appinfo_x **appinfo)
+static int _pkgmgrinfo_get_appinfo(const char *appid, uid_t uid,
+ pkgmgrinfo_appinfo_filter_h filter, pkgmgrinfo_appinfo_h *handle)
{
int ret;
- sqlite3 *db;
- const char *dbpath;
char *locale;
+ GHashTable *list;
pkgmgr_appinfo_x *info;
- dbpath = getUserPkgParserDBPathUID(uid);
- if (dbpath == NULL)
- return PMINFO_R_ERROR;
+ if (appid == NULL || filter == NULL || handle == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
locale = _get_system_locale();
if (locale == NULL)
return PMINFO_R_ERROR;
- ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
- if (ret != SQLITE_OK) {
- _LOGE("failed to open db: %d", ret);
+ list = g_hash_table_new(g_str_hash, g_str_equal);
+ if (list == NULL) {
free(locale);
return PMINFO_R_ERROR;
}
+ ret = _appinfo_get_applications(uid, uid, locale, filter,
+ PMINFO_APPINFO_GET_ALL, list);
+ if (!g_hash_table_size(list) && uid != GLOBAL_USER)
+ ret = _appinfo_get_applications(GLOBAL_USER, uid, locale, filter,
+ PMINFO_APPINFO_GET_ALL, list);
+
+ if (!g_hash_table_size(list)) {
+ _LOGI("appinfo for [%s] is not existed for user [%d]",
+ appid, uid);
+ g_hash_table_destroy(list);
+ free(locale);
+ return PMINFO_R_ENOENT;
+ }
+
info = calloc(1, sizeof(pkgmgr_appinfo_x));
if (info == NULL) {
_LOGE("out of memory");
+ g_hash_table_destroy(list);
free(locale);
- sqlite3_close_v2(db);
return PMINFO_R_ERROR;
}
- ret = _appinfo_get_application(db, appid, locale, &info->app_info);
+ info->app_info = (application_x *)g_hash_table_lookup(list, appid);
+ info->locale = locale;
+ info->package = strdup(info->app_info->package);
+
+ /* just free list only */
+ g_hash_table_destroy(list);
+
+ *handle = info;
+
+ return ret;
+}
+
+API int pkgmgrinfo_appinfo_get_usr_disabled_appinfo(const char *appid, uid_t uid,
+ pkgmgrinfo_appinfo_h *handle)
+{
+ int ret;
+ pkgmgrinfo_appinfo_filter_h filter;
+
+ if (appid == NULL || handle == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ ret = pkgmgrinfo_appinfo_filter_create(&filter);
+ if (ret != PMINFO_R_OK)
+ return ret;
+
+ ret = pkgmgrinfo_appinfo_filter_add_string(filter,
+ PMINFO_APPINFO_PROP_APP_ID, appid);
if (ret != PMINFO_R_OK) {
- free(info);
- free(locale);
- sqlite3_close_v2(db);
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
+ }
+
+ ret = pkgmgrinfo_appinfo_filter_add_bool(filter,
+ PMINFO_APPINFO_PROP_APP_DISABLE, true);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
+ }
+
+ ret = _pkgmgrinfo_get_appinfo(appid, uid, filter, handle);
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+
+ return ret;
+}
+
+API int pkgmgrinfo_appinfo_get_disabled_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle)
+{
+ return pkgmgrinfo_appinfo_get_usr_disabled_appinfo(appid, _getuid(), handle);
+}
+
+API int pkgmgrinfo_appinfo_get_usr_appinfo(const char *appid, uid_t uid,
+ pkgmgrinfo_appinfo_h *handle)
+{
+ int ret;
+ pkgmgrinfo_appinfo_filter_h filter;
+
+ if (appid == NULL || handle == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ ret = pkgmgrinfo_appinfo_filter_create(&filter);
+ if (ret != PMINFO_R_OK)
return ret;
+
+ ret = pkgmgrinfo_appinfo_filter_add_string(filter,
+ PMINFO_APPINFO_PROP_APP_ID, appid);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
}
- info->locale = locale;
- info->package = strdup(info->app_info->package);
+ ret = pkgmgrinfo_appinfo_filter_add_bool(filter,
+ PMINFO_APPINFO_PROP_APP_DISABLE, false);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
+ }
- *appinfo = info;
+ ret = _pkgmgrinfo_get_appinfo(appid, uid, filter, handle);
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return ret;
+}
- sqlite3_close_v2(db);
+API int pkgmgrinfo_appinfo_get_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle)
+{
+ return pkgmgrinfo_appinfo_get_usr_appinfo(appid, _getuid(), handle);
+}
+
+API int pkgmgrinfo_appinfo_get_usr_all_appinfo(const char *appid, uid_t uid,
+ pkgmgrinfo_appinfo_h *handle)
+{
+ int ret;
+ pkgmgrinfo_appinfo_filter_h filter;
+
+ if (appid == NULL || handle == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ ret = pkgmgrinfo_appinfo_filter_create(&filter);
+ if (ret != PMINFO_R_OK)
+ return ret;
+
+ ret = pkgmgrinfo_appinfo_filter_add_string(filter,
+ PMINFO_APPINFO_PROP_APP_ID, appid);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
+ }
+
+ ret = pkgmgrinfo_appinfo_filter_add_bool(filter,
+ PMINFO_APPINFO_PROP_APP_CHECK_STORAGE, false);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
+ }
+
+ ret = _pkgmgrinfo_get_appinfo(appid, uid, filter, handle);
+ pkgmgrinfo_appinfo_filter_destroy(filter);
return ret;
}
+API int pkgmgrinfo_appinfo_get_all_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle)
+{
+ return pkgmgrinfo_appinfo_get_usr_all_appinfo(appid, _getuid(), handle);
+}
+
+static gpointer __copy_str(gconstpointer src, gpointer data)
+{
+ const char *tmp = (const char *)src;
+ char *buffer;
+
+ buffer = strdup(tmp);
+ if (buffer == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ return buffer;
+}
+
+static gpointer __copy_label(gconstpointer src, gpointer data)
+{
+ label_x *tmp = (label_x *)src;
+ label_x *label;
+
+ label = calloc(1, sizeof(label_x));
+ if (label == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ if (tmp->name)
+ label->name = strdup(tmp->name);
+ if (tmp->text)
+ label->text = strdup(tmp->text);
+ if (tmp->lang)
+ label->lang = strdup(tmp->lang);
+
+ return label;
+}
+
+static gpointer __copy_icon(gconstpointer src, gpointer data)
+{
+ icon_x *tmp = (icon_x *)src;
+ icon_x *icon;
+
+ icon = calloc(1, sizeof(icon_x));
+ if (icon == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ if (tmp->text)
+ icon->text = strdup(tmp->text);
+ if (tmp->lang)
+ icon->lang = strdup(tmp->lang);
+ if (tmp->section)
+ icon->section = strdup(tmp->section);
+ if (tmp->size)
+ icon->size = strdup(tmp->size);
+ if (tmp->resolution)
+ icon->resolution = strdup(tmp->resolution);
+
+ return icon;
+}
+
+static gpointer __copy_metadata(gconstpointer src, gpointer data)
+{
+ metadata_x *tmp = (metadata_x *)src;
+ metadata_x *metadata;
+
+ metadata = calloc(1, sizeof(metadata_x));
+ if (metadata == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ if (tmp->key)
+ metadata->key = strdup(tmp->key);
+ if (tmp->value)
+ metadata->value = strdup(tmp->value);
+
+ return metadata;
+}
+
+static gpointer __copy_datacontrol(gconstpointer src, gpointer data)
+{
+ datacontrol_x *tmp = (datacontrol_x *)src;
+ datacontrol_x *datacontrol;
+
+ datacontrol = calloc(1, sizeof(datacontrol_x));
+ if (datacontrol == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ if (tmp->providerid)
+ datacontrol->providerid = strdup(tmp->providerid);
+ if (tmp->access)
+ datacontrol->access = strdup(tmp->access);
+ if (tmp->type)
+ datacontrol->type = strdup(tmp->type);
+ if (tmp->trusted)
+ datacontrol->trusted = strdup(tmp->trusted);
+
+ return datacontrol;
+}
+
+static gpointer __copy_appcontrol(gconstpointer src, gpointer data)
+{
+ appcontrol_x *tmp = (appcontrol_x *)src;
+ appcontrol_x *appcontrol;
+
+ appcontrol = calloc(1, sizeof(appcontrol_x));
+ if (appcontrol == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ if (tmp->operation)
+ appcontrol->operation = strdup(tmp->operation);
+ if (tmp->uri)
+ appcontrol->uri = strdup(tmp->uri);
+ if (tmp->mime)
+ appcontrol->mime = strdup(tmp->mime);
+
+ return appcontrol;
+}
+
+static gpointer __copy_splashscreens(gconstpointer src, gpointer data)
+{
+ splashscreen_x *tmp = (splashscreen_x *)src;
+ splashscreen_x *splashscreen;
+
+ splashscreen = (splashscreen_x *)calloc(1, sizeof(splashscreen_x));
+ if (splashscreen == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ if (tmp->src)
+ splashscreen->src = strdup(tmp->src);
+ if (tmp->type)
+ splashscreen->type = strdup(tmp->type);
+ if (tmp->orientation)
+ splashscreen->orientation = strdup(tmp->orientation);
+ if (tmp->indicatordisplay)
+ splashscreen->indicatordisplay = strdup(tmp->indicatordisplay);
+ if (tmp->operation)
+ splashscreen->operation = strdup(tmp->operation);
+ if (tmp->color_depth)
+ splashscreen->color_depth = strdup(tmp->color_depth);
+
+ return splashscreen;
+}
+
static int _appinfo_copy_appinfo(application_x **application, application_x *data)
{
application_x *app_info;
+ int ret;
app_info = calloc(1, sizeof(application_x));
if (app_info == NULL) {
app_info->multiple = strdup(data->multiple);
if (data->taskmanage != NULL)
app_info->taskmanage = strdup(data->taskmanage);
- if (data->enabled != NULL)
- app_info->enabled = strdup(data->enabled);
if (data->type != NULL)
app_info->type = strdup(data->type);
if (data->categories != NULL)
app_info->categories = strdup(data->categories);
- if (data->extraid != NULL)
- app_info->extraid = strdup(data->extraid);
if (data->hwacceleration != NULL)
app_info->hwacceleration = strdup(data->hwacceleration);
if (data->screenreader != NULL)
app_info->portraitimg = strdup(data->portraitimg);
if (data->landscapeimg != NULL)
app_info->landscapeimg = strdup(data->landscapeimg);
- if (data->effectimage_type != NULL)
- app_info->effectimage_type = strdup(data->effectimage_type);
if (data->guestmode_visibility != NULL)
app_info->guestmode_visibility = strdup(data->guestmode_visibility);
if (data->component != NULL)
app_info->ui_gadget = strdup(data->ui_gadget);
if (data->launch_mode != NULL)
app_info->launch_mode = strdup(data->launch_mode);
- if (data->ambient_support != NULL)
- app_info->ambient_support = strdup(data->ambient_support);
- if (data->alias_appid != NULL)
- app_info->alias_appid = strdup(data->alias_appid);
+ if (data->package_type != NULL)
+ app_info->package_type = strdup(data->package_type);
if (data->effective_appid != NULL)
- app_info->effective_appid = strdup(data->effective_appid);
-
- app_info->label = g_list_copy(data->label);
- app_info->icon = g_list_copy(data->icon);
- app_info->image = g_list_copy(data->image);
- app_info->category = g_list_copy(data->category);
- app_info->metadata = g_list_copy(data->metadata);
- app_info->permission = g_list_copy(data->permission);
- app_info->launchconditions = g_list_copy(data->launchconditions);
- app_info->notification = g_list_copy(data->notification);
- app_info->datashare = g_list_copy(data->datashare);
- app_info->datacontrol = g_list_copy(data->datacontrol);
- app_info->background_category = g_list_copy(data->background_category);
- app_info->appcontrol = g_list_copy(data->appcontrol);
-
- *application = app_info;
-
- return PMINFO_R_OK;
-}
-
-API int pkgmgrinfo_appinfo_get_usr_appinfo(const char *appid, uid_t uid,
- pkgmgrinfo_appinfo_h *handle)
-{
- int ret;
+ app_info->effective_appid = strdup(data->effective_appid);
+ if (data->splash_screen_display != NULL)
+ app_info->splash_screen_display = strdup(data->splash_screen_display);
- if (appid == NULL || handle == NULL) {
- LOGE("invalid parameter");
- return PMINFO_R_EINVAL;
+ /* GList */
+ ret = 0;
+ app_info->label = g_list_copy_deep(data->label, __copy_label, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
}
- ret = _appinfo_get_appinfo(appid, uid, (pkgmgr_appinfo_x **)handle);
- if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
- ret = _appinfo_get_appinfo(appid, GLOBAL_USER,
- (pkgmgr_appinfo_x **)handle);
+ ret = 0;
+ app_info->icon = g_list_copy_deep(data->icon, __copy_icon, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
+ }
- if (ret != PMINFO_R_OK)
- _LOGE("failed to get appinfo of %s for user %d", appid, uid);
+ ret = 0;
+ app_info->category = g_list_copy_deep(data->category, __copy_str, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
+ }
- return ret;
-}
+ ret = 0;
+ app_info->metadata = g_list_copy_deep(data->metadata, __copy_metadata, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
+ }
-API int pkgmgrinfo_appinfo_get_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle)
-{
- return pkgmgrinfo_appinfo_get_usr_appinfo(appid, GLOBAL_USER, handle);
-}
+ ret = 0;
+ app_info->datacontrol = g_list_copy_deep(data->datacontrol, __copy_datacontrol, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
+ }
-static int _appinfo_get_filtered_foreach_appinfo(uid_t uid,
- pkgmgrinfo_filter_x *filter, pkgmgrinfo_app_list_cb app_list_cb,
- void *user_data)
-{
- int ret;
- pkgmgr_appinfo_x *info;
- GList *list = NULL;
- GList *tmp;
- char *appid;
- int stop = 0;
+ ret = 0;
+ app_info->appcontrol = g_list_copy_deep(data->appcontrol, __copy_appcontrol, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
+ }
- ret = _appinfo_get_filtered_list(filter, uid, &list);
- if (ret != PMINFO_R_OK)
+ ret = 0;
+ app_info->background_category = g_list_copy_deep(data->background_category, __copy_str, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
return PMINFO_R_ERROR;
+ }
- for (tmp = list; tmp; tmp = tmp->next) {
- appid = (char *)tmp->data;
- if (stop == 0) {
- ret = _appinfo_get_appinfo(appid, uid, &info);
- if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
- ret = _appinfo_get_appinfo(appid, GLOBAL_USER,
- &info);
- if (ret != PMINFO_R_OK) {
- free(appid);
- continue;
- }
- if (app_list_cb(info, user_data) < 0)
- stop = 1;
- pkgmgrinfo_appinfo_destroy_appinfo(info);
- }
- free(appid);
+ ret = 0;
+ app_info->splashscreens = g_list_copy_deep(data->splashscreens, __copy_splashscreens, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
}
- g_list_free(list);
+ *application = app_info;
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_clone(pkgmgrinfo_appinfo_h *clone,
- pkgmgrinfo_appinfo_h handle)
+API int pkgmgrinfo_appinfo_clone_appinfo(pkgmgrinfo_appinfo_h handle,
+ pkgmgrinfo_appinfo_h *clone)
{
pkgmgr_appinfo_x *info;
pkgmgr_appinfo_x *temp = (pkgmgr_appinfo_x *)handle;
if (_appinfo_copy_appinfo(&info->app_info, temp->app_info) < 0) {
LOGE("appinfo copy failed");
if (info->package)
- free(info->package);
+ free((void *)info->package);
if (info->locale)
free(info->locale);
free(info);
return PMINFO_R_OK;
}
+static int _appinfo_get_filtered_foreach_appinfo(uid_t uid,
+ pkgmgrinfo_filter_x *filter, int flag, pkgmgrinfo_app_list_cb app_list_cb,
+ void *user_data)
+{
+ int ret;
+ char *locale;
+ application_x *app;
+ pkgmgr_appinfo_x info;
+ GHashTable *list;
+ GHashTableIter iter;
+ gpointer value;
+
+ locale = _get_system_locale();
+ if (locale == NULL)
+ return PMINFO_R_ERROR;
+
+ list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+ __free_applications);
+ if (list == NULL) {
+ free(locale);
+ return PMINFO_R_ERROR;
+ }
+
+ if (__check_disable_filter_exist(filter) == false) {
+ pkgmgrinfo_appinfo_filter_add_bool(filter,
+ PMINFO_APPINFO_PROP_APP_DISABLE, false);
+ }
+
+ ret = _appinfo_get_applications(uid, uid, locale, filter,
+ flag | PMINFO_APPINFO_GET_BASICINFO, list);
+ if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
+ ret = _appinfo_get_applications(GLOBAL_USER, uid, locale,
+ filter, flag | PMINFO_APPINFO_GET_BASICINFO, list);
+
+ if (ret != PMINFO_R_OK) {
+ g_hash_table_destroy(list);
+ free(locale);
+ return ret;
+ }
+
+ g_hash_table_iter_init(&iter, list);
+ while (g_hash_table_iter_next(&iter, NULL, &value)) {
+ app = (application_x *)value;
+ info.app_info = app;
+ info.locale = locale;
+ info.package = app->package;
+ if (app_list_cb(&info, user_data) < 0)
+ break;
+ }
+ g_hash_table_destroy(list);
+ free(locale);
+
+ return PMINFO_R_OK;
+}
+
+static const char *__appcomponent_str(pkgmgrinfo_app_component comp);
+
API int pkgmgrinfo_appinfo_get_usr_list(pkgmgrinfo_pkginfo_h handle,
pkgmgrinfo_app_component component,
pkgmgrinfo_app_list_cb app_func, void *user_data, uid_t uid)
return PMINFO_R_ERROR;
}
- if (uid == GLOBAL_USER) {
- if (pkgmgrinfo_appinfo_filter_add_int(filter,
- PMINFO_APPINFO_PROP_APP_DISABLE_FOR_USER, (int)getuid())) {
- pkgmgrinfo_appinfo_filter_destroy(filter);
- return PMINFO_R_ERROR;
- }
- }
-
- switch (component) {
- case PMINFO_UI_APP:
- comp_str = PMINFO_APPINFO_UI_APP;
- break;
- case PMINFO_SVC_APP:
- comp_str = PMINFO_APPINFO_SVC_APP;
- break;
- default:
- break;
- }
+ comp_str = __appcomponent_str(component);
if (comp_str) {
if (pkgmgrinfo_appinfo_filter_add_string(filter,
}
}
- ret = _appinfo_get_filtered_foreach_appinfo(uid, filter, app_func,
- user_data);
+ ret = _appinfo_get_filtered_foreach_appinfo(uid, filter,
+ PMINFO_APPINFO_GET_ALL, app_func, user_data);
pkgmgrinfo_appinfo_filter_destroy(filter);
return ret;
}
-API int pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_app_component component,
- pkgmgrinfo_app_list_cb app_func, void *user_data)
+API int pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo_h handle,
+ pkgmgrinfo_app_component component,
+ pkgmgrinfo_app_list_cb app_func, void *user_data)
{
- return pkgmgrinfo_appinfo_get_usr_list(handle, component, app_func, user_data, GLOBAL_USER);
+ return pkgmgrinfo_appinfo_get_usr_list(handle, component, app_func, user_data, _getuid());
}
-API int pkgmgrinfo_appinfo_get_usr_install_list(pkgmgrinfo_app_list_cb app_func, uid_t uid, void *user_data)
+API int pkgmgrinfo_appinfo_get_usr_installed_list_full(
+ pkgmgrinfo_app_list_cb app_func, uid_t uid, int flag,
+ void *user_data)
{
+ int ret;
+ pkgmgrinfo_appinfo_filter_h filter;
+
if (app_func == NULL) {
LOGE("invalid parameter");
return PMINFO_R_EINVAL;
}
- return _appinfo_get_filtered_foreach_appinfo(uid, NULL, app_func,
+ if (pkgmgrinfo_appinfo_filter_create(&filter))
+ return PMINFO_R_ERROR;
+
+ if (pkgmgrinfo_appinfo_filter_add_bool(filter,
+ PMINFO_APPINFO_PROP_APP_DISABLE, false)) {
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
+ }
+
+ if (pkgmgrinfo_appinfo_filter_add_bool(filter,
+ PMINFO_APPINFO_PROP_APP_CHECK_STORAGE, false)) {
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+ return PMINFO_R_ERROR;
+ }
+
+ ret = _appinfo_get_filtered_foreach_appinfo(uid, filter, flag, app_func,
user_data);
+
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+
+ return ret;
}
-API int pkgmgrinfo_appinfo_get_install_list(pkgmgrinfo_app_list_cb app_func, void *user_data)
+API int pkgmgrinfo_appinfo_get_installed_list_full(
+ pkgmgrinfo_app_list_cb app_func, int flag, void *user_data)
{
- return pkgmgrinfo_appinfo_get_usr_install_list(app_func, GLOBAL_USER, user_data);
+ return pkgmgrinfo_appinfo_get_usr_installed_list_full(app_func,
+ _getuid(), flag, user_data);
}
-API int pkgmgrinfo_appinfo_get_usr_installed_list(pkgmgrinfo_app_list_cb app_func, uid_t uid, void *user_data)
+API int pkgmgrinfo_appinfo_get_usr_installed_list(
+ pkgmgrinfo_app_list_cb app_func, uid_t uid, void *user_data)
{
+ int ret;
+ pkgmgrinfo_appinfo_filter_h filter;
+
if (app_func == NULL) {
LOGE("invalid parameter");
return PMINFO_R_EINVAL;
}
- return _appinfo_get_filtered_foreach_appinfo(uid, NULL, app_func,
- user_data);
+ /* create an empty filter */
+ ret = pkgmgrinfo_appinfo_filter_create(&filter);
+ if (ret != PMINFO_R_OK)
+ return ret;
+
+ ret = _appinfo_get_filtered_foreach_appinfo(uid, filter,
+ PMINFO_APPINFO_GET_ALL, app_func, user_data);
+
+ pkgmgrinfo_appinfo_filter_destroy(filter);
+
+ return ret;
}
-API int pkgmgrinfo_appinfo_get_installed_list(pkgmgrinfo_app_list_cb app_func, void *user_data)
+API int pkgmgrinfo_appinfo_get_installed_list(pkgmgrinfo_app_list_cb app_func,
+ void *user_data)
{
- return pkgmgrinfo_appinfo_get_usr_installed_list(app_func, GLOBAL_USER, user_data);
+ return pkgmgrinfo_appinfo_get_usr_installed_list(app_func, _getuid(),
+ user_data);
}
API int pkgmgrinfo_appinfo_get_appid(pkgmgrinfo_appinfo_h handle, char **appid)
API int pkgmgrinfo_appinfo_get_icon(pkgmgrinfo_appinfo_h handle, char **icon)
{
- const char *locale;
- icon_x *ptr;
- GList *tmp;
- pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+ icon_x *ptr;
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
- locale = info->locale;
- retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
-
if (info->app_info == NULL)
return PMINFO_R_ERROR;
- for (tmp = info->app_info->icon; tmp; tmp = tmp->next) {
- ptr = (icon_x *)tmp->data;
- if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
- !strcasecmp(ptr->text, "(null)") ||
- strcmp(ptr->lang, locale))
- continue;
- *icon = (char *)ptr->text;
+ if (info->app_info->icon == NULL) {
+ *icon = "";
return PMINFO_R_OK;
}
- locale = DEFAULT_LOCALE;
- for (tmp = info->app_info->icon; tmp; tmp = tmp->next) {
- ptr = (icon_x *)tmp->data;
- if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
- strcmp(ptr->lang, locale))
- continue;
- *icon = (char *)ptr->text;
- return PMINFO_R_OK;
- }
+ ptr = (icon_x *)info->app_info->icon->data;
+ if (ptr == NULL)
+ return PMINFO_R_ERROR;
- return PMINFO_R_ERROR;
+ if (ptr->text == NULL)
+ return PMINFO_R_ERROR;
+ else
+ *icon = ptr->text;
+
+ return PMINFO_R_OK;
}
API int pkgmgrinfo_appinfo_get_label(pkgmgrinfo_appinfo_h handle, char **label)
{
- const char *locale;
label_x *ptr;
- GList *tmp;
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+ char *lbl = NULL;
+ const char *locale;
+ GList *tmp;
retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
- locale = info->locale;
- retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
-
if (info->app_info == NULL)
return PMINFO_R_ERROR;
+ locale = info->locale;
+ if (locale == NULL)
+ locale = DEFAULT_LOCALE;
+
for (tmp = info->app_info->label; tmp; tmp = tmp->next) {
ptr = (label_x *)tmp->data;
- if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
- strcmp(ptr->lang, locale))
+ if (ptr == NULL || strcmp(locale, ptr->lang) != 0)
continue;
- *label = (char *)ptr->text;
+ lbl = ptr->text;
+ break;
+ }
+
+ if (lbl != NULL) {
+ *label = lbl;
return PMINFO_R_OK;
}
- locale = DEFAULT_LOCALE;
for (tmp = info->app_info->label; tmp; tmp = tmp->next) {
ptr = (label_x *)tmp->data;
- if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
- strcmp(ptr->lang, locale))
+ if (ptr == NULL || strcmp(DEFAULT_LOCALE, ptr->lang) != 0)
continue;
- *label = (char *)ptr->text;
- return PMINFO_R_OK;
+ lbl = ptr->text;
+ break;
}
- return PMINFO_R_ERROR;
+ *label = lbl ? lbl : "";
+
+ return PMINFO_R_OK;
}
static char *_get_localed_label(const char *appid, const char *locale, uid_t uid)
sqlite3_stmt *stmt = NULL;
sqlite3 *db = NULL;
char *val;
- const char *manifest_db;
+ char *parser_db;
- manifest_db = getUserPkgParserDBPathUID(uid);
- if (manifest_db == NULL) {
- _LOGE("Failed to get manifest db path");
+ parser_db = getUserPkgParserDBPathUID(uid);
+ if (parser_db == NULL) {
+ _LOGE("Failed to get parser db path");
goto err;
}
- if (sqlite3_open_v2(manifest_db, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK) {
+ if (__open_db(parser_db, &db, SQLITE_OPEN_READONLY) != SQLITE_OK) {
_LOGE("DB open fail\n");
+ free(parser_db);
goto err;
}
+ free(parser_db);
query = sqlite3_mprintf("select app_label from package_app_localized_info where app_id=%Q and app_locale=%Q", appid, locale);
if (query == NULL) {
if (val == NULL)
val = _get_localed_label(appid, DEFAULT_LOCALE, uid);
+ if (val == NULL) {
+ val = _get_localed_label(appid, locale, GLOBAL_USER);
+ if (val == NULL)
+ val = _get_localed_label(appid, DEFAULT_LOCALE, GLOBAL_USER);
+ }
+
if (val == NULL)
return PMINFO_R_ERROR;
API int pkgmgrinfo_appinfo_get_localed_label(const char *appid, const char *locale, char **label)
{
- return pkgmgrinfo_appinfo_usr_get_localed_label(appid, locale, GLOBAL_USER, label);
+ return pkgmgrinfo_appinfo_usr_get_localed_label(appid, locale, _getuid(), label);
+}
+
+API int pkgmgrinfo_appinfo_get_metadata_value(pkgmgrinfo_appinfo_h handle, const char *metadata_key, char **metadata_value)
+{
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
+ retvm_if(metadata_key == NULL, PMINFO_R_EINVAL, "metadata_key is NULL");
+ retvm_if(metadata_value == NULL, PMINFO_R_EINVAL, "metadata_value is NULL");
+
+ GList *list_md = NULL;
+ metadata_x *metadata = NULL;
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ list_md = info->app_info->metadata;
+
+ for (; list_md; list_md = list_md->next) {
+ metadata = (metadata_x *)list_md->data;
+ if (metadata && metadata->key) {
+ if (strcasecmp(metadata->key, metadata_key) == 0) {
+ if (metadata->value == NULL)
+ *metadata_value = "";
+ else
+ *metadata_value = (char *)metadata->value;
+ return PMINFO_R_OK;
+ }
+ }
+ }
+
+ return PMINFO_R_EINVAL;
}
static pkgmgrinfo_app_component __appcomponent_convert(const char *comp)
{
- if ( strcasecmp(comp, "uiapp") == 0)
+ if (strcasecmp(comp, "uiapp") == 0)
return PMINFO_UI_APP;
- else if ( strcasecmp(comp, "svcapp") == 0)
+ else if (strcasecmp(comp, "svcapp") == 0)
return PMINFO_SVC_APP;
+ else if (strcasecmp(comp, "widgetapp") == 0)
+ return PMINFO_WIDGET_APP;
+ else if (strcasecmp(comp, "watchapp") == 0)
+ return PMINFO_WATCH_APP;
else
return -1;
}
+static const char *__appcomponent_str(pkgmgrinfo_app_component comp)
+{
+ switch (comp) {
+ case PMINFO_UI_APP:
+ return "uiapp";
+ case PMINFO_SVC_APP:
+ return "svcapp";
+ case PMINFO_WIDGET_APP:
+ return "widgetapp";
+ case PMINFO_WATCH_APP:
+ return "watchapp";
+ default:
+ return NULL;
+ }
+}
+
API int pkgmgrinfo_appinfo_get_component(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_app_component *component)
{
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
continue;
val = (char *)ptr->section;
- if (val && strcmp(val, "notification") == 0){
+ if (val && strcmp(val, "notification") == 0) {
*icon = (char *)ptr->text;
return PMINFO_R_OK;
}
return PMINFO_R_ERROR;
val = (char *)info->app_info->hwacceleration;
- if (strcasecmp(val, "not-use-GL") == 0)
- *hwacceleration = PMINFO_HWACCELERATION_NOT_USE_GL;
- else if (strcasecmp(val, "use-GL") == 0)
- *hwacceleration = PMINFO_HWACCELERATION_USE_GL;
+ if (strcasecmp(val, "off") == 0)
+ *hwacceleration = PMINFO_HWACCELERATION_OFF;
+ else if (strcasecmp(val, "on") == 0)
+ *hwacceleration = PMINFO_HWACCELERATION_ON;
else
- *hwacceleration = PMINFO_HWACCELERATION_USE_SYSTEM_SETTING;
+ *hwacceleration = PMINFO_HWACCELERATION_DEFAULT;
return PMINFO_R_OK;
}
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_effectimage(pkgmgrinfo_appinfo_h handle, char **portrait_img, char **landscape_img)
+API int pkgmgrinfo_appinfo_get_effectimage(pkgmgrinfo_appinfo_h handle, char **portrait_img, char **landscape_img)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
+ retvm_if(portrait_img == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
+ retvm_if(landscape_img == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
+
+ if (info->app_info == NULL)
+ return PMINFO_R_ERROR;
+
+ if (info->app_info->portraitimg == NULL)
+ *portrait_img = "";
+ else
+ *portrait_img = (char *)info->app_info->portraitimg;
+
+ if (info->app_info->landscapeimg == NULL)
+ *landscape_img = "";
+ else
+ *landscape_img = (char *)info->app_info->landscapeimg;
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_get_effectimage_type(pkgmgrinfo_appinfo_h handle, char **effectimage_type)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (handle == NULL || effectimage_type == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ if (info->app_info == NULL || info->app_info->effectimage_type == NULL)
+ return PMINFO_R_ERROR;
+
+ *effectimage_type = (char *)info->app_info->effectimage_type;
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_get_submode_mainid(pkgmgrinfo_appinfo_h handle, char **submode_mainid)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
+ retvm_if(submode_mainid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
+
+ if (info->app_info == NULL)
+ return PMINFO_R_ERROR;
+
+ if (info->app_info->submode_mainid == NULL)
+ *submode_mainid = "";
+ else
+ *submode_mainid = (char *)info->app_info->submode_mainid;
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_get_installed_storage_location(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_installed_storage *storage)
+{
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info->app_info && info->app_info->installed_storage) {
+ if (strcmp(info->app_info->installed_storage, "installed_internal") == 0)
+ *storage = PMINFO_INTERNAL_STORAGE;
+ else if (strcmp(info->app_info->installed_storage, "installed_external") == 0)
+ *storage = PMINFO_EXTERNAL_STORAGE;
+ else
+ return PMINFO_R_ERROR;
+ } else {
+ return PMINFO_R_ERROR;
+ }
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_get_launch_mode(pkgmgrinfo_appinfo_h handle, char **mode)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
+ retvm_if(mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
+
+ if (info->app_info->launch_mode == NULL)
+ return PMINFO_R_ERROR;
+
+ *mode = (char *)(info->app_info->launch_mode);
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_get_alias_appid(pkgmgrinfo_appinfo_h handle, char **alias_appid)
{
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
- retvm_if(portrait_img == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
- retvm_if(landscape_img == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
+ if (handle == NULL || alias_appid == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
- if (info->app_info == NULL || info->app_info->portraitimg ||
- info->app_info->landscapeimg == NULL)
+ if (info->app_info == NULL || info->app_info->alias_appid == NULL)
return PMINFO_R_ERROR;
- *portrait_img = (char *)info->app_info->portraitimg;
- *landscape_img = (char *)info->app_info->landscapeimg;
+ *alias_appid = (char *)info->app_info->alias_appid;
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_effectimage_type(pkgmgrinfo_appinfo_h handle, char **effectimage_type)
+API int pkgmgrinfo_appinfo_get_effective_appid(pkgmgrinfo_appinfo_h handle, char **effective_appid)
{
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- if (handle == NULL || effectimage_type == NULL) {
+ if (handle == NULL || effective_appid == NULL) {
LOGE("invalid parameter");
return PMINFO_R_EINVAL;
}
- if (info->app_info == NULL || info->app_info->effectimage_type == NULL)
+ if (info->app_info == NULL)
return PMINFO_R_ERROR;
- *effectimage_type = (char *)info->app_info->effectimage_type;
+ if (info->app_info->effective_appid == NULL)
+ *effective_appid = "";
+ else
+ *effective_appid = (char *)info->app_info->effective_appid;
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_submode_mainid(pkgmgrinfo_appinfo_h handle, char **submode_mainid)
+API int pkgmgrinfo_appinfo_get_tep_name(pkgmgrinfo_appinfo_h handle, char **tep_name)
{
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
- retvm_if(submode_mainid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
+ if (handle == NULL || tep_name == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
- if (info->app_info == NULL || info->app_info->submode_mainid == NULL)
+ if (info->app_info == NULL)
return PMINFO_R_ERROR;
- *submode_mainid = (char *)info->app_info->submode_mainid;
+ if (info->app_info->tep_name == NULL)
+ *tep_name = "";
+ else
+ *tep_name = (char *)info->app_info->tep_name;
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_installed_storage_location(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_installed_storage *storage)
+API int pkgmgrinfo_appinfo_get_zip_mount_file(pkgmgrinfo_appinfo_h handle, char **zip_mount_file)
{
- retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- if (info->app_info && info->app_info->installed_storage){
- if (strcmp(info->app_info->installed_storage,"installed_internal") == 0)
- *storage = PMINFO_INTERNAL_STORAGE;
- else if (strcmp(info->app_info->installed_storage,"installed_external") == 0)
- *storage = PMINFO_EXTERNAL_STORAGE;
- else
- return PMINFO_R_ERROR;
- }else
+ if (handle == NULL || zip_mount_file == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ if (info->app_info == NULL)
return PMINFO_R_ERROR;
+ if (info->app_info->zip_mount_file == NULL)
+ *zip_mount_file = "";
+ else
+ *zip_mount_file = (char *)info->app_info->zip_mount_file;
+
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_launch_mode(pkgmgrinfo_appinfo_h handle, char **mode)
+API int pkgmgrinfo_appinfo_get_root_path(pkgmgrinfo_appinfo_h handle, char **root_path)
{
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
- retvm_if(mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
+ if (handle == NULL || root_path == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
- if (info->app_info->launch_mode == NULL)
+ if (info->app_info == NULL || info->app_info->root_path == NULL)
return PMINFO_R_ERROR;
- *mode = (char *)(info->app_info->launch_mode);
+ *root_path = (char *)info->app_info->root_path;
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_alias_appid(pkgmgrinfo_appinfo_h handle, char **alias_appid)
+API int pkgmgrinfo_appinfo_get_api_version(pkgmgrinfo_appinfo_h handle, char **api_version)
{
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- if (handle == NULL || alias_appid == NULL) {
+ if (handle == NULL || api_version == NULL) {
LOGE("invalid parameter");
return PMINFO_R_EINVAL;
}
- if (info->app_info == NULL || info->app_info->alias_appid == NULL)
+ if (info->app_info == NULL || info->app_info->api_version == NULL)
return PMINFO_R_ERROR;
- *alias_appid = (char *)info->app_info->alias_appid;
+ *api_version = (char *)info->app_info->api_version;
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_get_effective_appid(pkgmgrinfo_appinfo_h handle, char **effective_appid)
+API int pkgmgrinfo_appinfo_get_installed_time(pkgmgrinfo_appinfo_h handle, int *installed_time)
{
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- if (handle == NULL || effective_appid == NULL) {
+ if (handle == NULL || installed_time == NULL) {
LOGE("invalid parameter");
return PMINFO_R_EINVAL;
}
- if (info->app_info == NULL || info->app_info->effective_appid == NULL)
+ if (info->app_info == NULL || info->app_info->package_installed_time == NULL)
return PMINFO_R_ERROR;
- *effective_appid = (char *)info->app_info->effective_appid;
+ *installed_time = atoi(info->app_info->package_installed_time);
return PMINFO_R_OK;
}
-API int pkgmgrinfo_appinfo_usr_get_datacontrol_info(const char *providerid, const char *type, uid_t uid, char **appid, char **access)
+API int pkgmgrinfo_appinfo_usr_get_datacontrol_info(const char *providerid,
+ const char *type, uid_t uid, char **appid, char **access)
{
retvm_if(providerid == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
/*Start constructing query*/
query = sqlite3_mprintf("select * from package_app_data_control where providerid=%Q and type=%Q", providerid, type);
+ tryvm_if(query == NULL, ret = PMINFO_R_ERROR, "Out of memory");
/*prepare query*/
ret = sqlite3_prepare_v2(GET_DB(manifest_db), query, strlen(query), &stmt, NULL);
return ret;
}
-API int pkgmgrinfo_appinfo_get_datacontrol_info(const char *providerid, const char *type, char **appid, char **access)
+API int pkgmgrinfo_appinfo_get_datacontrol_info(const char *providerid,
+ const char *type, char **appid, char **access)
{
- return pkgmgrinfo_appinfo_usr_get_datacontrol_info(providerid, type, GLOBAL_USER, appid, access);
+ return pkgmgrinfo_appinfo_usr_get_datacontrol_info(providerid,
+ type, _getuid(), appid, access);
}
API int pkgmgrinfo_appinfo_usr_get_datacontrol_appid(const char *providerid, uid_t uid, char **appid)
/*Start constructing query*/
query = sqlite3_mprintf("select * from package_app_data_control where providerid=%Q", providerid);
+ tryvm_if(query == NULL, ret = PMINFO_R_ERROR, "Out of memory");
/*prepare query*/
ret = sqlite3_prepare_v2(GET_DB(manifest_db), query, strlen(query), &stmt, NULL);
API int pkgmgrinfo_appinfo_get_datacontrol_appid(const char *providerid, char **appid)
{
- return pkgmgrinfo_appinfo_usr_get_datacontrol_appid(providerid, GLOBAL_USER, appid);
+ return pkgmgrinfo_appinfo_usr_get_datacontrol_appid(providerid, _getuid(), appid);
+}
+
+API int pkgmgrinfo_appinfo_usr_get_datacontrol_trusted_info(const char *providerid,
+ const char *type, uid_t uid, char **appid, bool *is_trusted)
+{
+ retvm_if(providerid == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
+ retvm_if(appid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
+
+ int ret = PMINFO_R_OK;
+ char *query = NULL;
+ sqlite3_stmt *stmt = NULL;
+
+ /*open db*/
+ ret = __open_manifest_db(uid, true);
+ retvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "connect db [%s] failed!", MANIFEST_DB);
+
+ /*Start constructing query*/
+ query = sqlite3_mprintf("SELECT app_id, trusted FROM package_app_data_control WHERE providerid=%Q AND type=%Q", providerid, type);
+ tryvm_if(query == NULL, ret = PMINFO_R_ERROR, "Out of memory");
+
+ /*prepare query*/
+ ret = sqlite3_prepare_v2(GET_DB(manifest_db), query, strlen(query), &stmt, NULL);
+ tryvm_if(ret != PMINFO_R_OK, ret = PMINFO_R_ERROR, "sqlite3_prepare_v2 failed[%s]\n", query);
+
+ /*step query*/
+ ret = sqlite3_step(stmt);
+ tryvm_if((ret != SQLITE_ROW) || (ret == SQLITE_DONE), ret = PMINFO_R_ERROR, "No records found");
+
+ _save_column_str(stmt, 0, appid);
+ *is_trusted = _get_bool_value((char *)sqlite3_column_text(stmt, 1));
+
+ ret = PMINFO_R_OK;
+
+catch:
+ sqlite3_free(query);
+ sqlite3_finalize(stmt);
+ __close_manifest_db();
+ return ret;
+}
+
+API int pkgmgrinfo_appinfo_get_datacontrol_trsuted_info(const char *providerid,
+ const char *type, char **appid, bool *is_trusted)
+{
+ return pkgmgrinfo_appinfo_usr_get_datacontrol_trusted_info(providerid,
+ type, _getuid(), appid, is_trusted);
+}
+
+API int pkgmgrinfo_appinfo_usr_foreach_datacontrol_privileges(const char *providerid, const char *type,
+ pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data, uid_t uid)
+{
+ retvm_if(providerid == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
+ retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
+
+ int ret = PMINFO_R_OK;
+ char *query = NULL;
+ sqlite3_stmt *stmt = NULL;
+
+ /*open db*/
+ ret = __open_manifest_db(uid, true);
+ retvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "connect db [%s] failed!", MANIFEST_DB);
+
+ /*Start constructing query*/
+ query = sqlite3_mprintf("SELECT privilege FROM package_app_data_control_privilege "
+ "WHERE providerid=%Q AND type=%Q", providerid, type);
+ tryvm_if(query == NULL, ret = PMINFO_R_ERROR, "Out of memory");
+
+ /*prepare query*/
+ ret = sqlite3_prepare_v2(GET_DB(manifest_db), query, strlen(query), &stmt, NULL);
+ tryvm_if(ret != PMINFO_R_OK, ret = PMINFO_R_ERROR, "sqlite3_prepare_v2 failed[%s]\n", query);
+
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ char *privilege;
+ privilege = (char *)sqlite3_column_text(stmt, 0);
+ ret = privilege_func(privilege, user_data);
+ if (ret < 0)
+ break;
+ }
+
+ ret = PMINFO_R_OK;
+
+catch:
+ sqlite3_free(query);
+ sqlite3_finalize(stmt);
+ __close_manifest_db();
+ return ret;
+}
+
+API int pkgmgrinfo_appinfo_foreach_datacontrol_privileges(const char *providerid, const char *type,
+ pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
+{
+ return pkgmgrinfo_appinfo_usr_foreach_datacontrol_privileges(providerid, type, privilege_func,
+ user_data, _getuid());
+}
+
+API int pkgmgrinfo_appinfo_get_support_mode(pkgmgrinfo_appinfo_h handle, int *support_mode)
+{
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
+ retvm_if(support_mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
+
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+ if (info->app_info->support_mode)
+ *support_mode = atoi(info->app_info->support_mode);
+ else
+ *support_mode = 0;
+
+ return PMINFO_R_OK;
}
API int pkgmgrinfo_appinfo_foreach_permission(pkgmgrinfo_appinfo_h handle,
if (ptr == NULL)
continue;
if (ptr->key) {
- ret = metadata_func(ptr->key, ptr->value, user_data);
+ ret = metadata_func(ptr->key, ptr->value ? ptr->value : "", user_data);
if (ret < 0)
break;
}
return PMINFO_R_OK;
}
+API int pkgmgrinfo_appinfo_foreach_splash_screen(pkgmgrinfo_appinfo_h handle,
+ pkgmgrinfo_app_splash_screen_list_cb splash_screen_func,
+ void *user_data)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+ splashscreen_x *splashscreen;
+ GList *tmp;
+ int ret;
+
+ if (info == NULL || info->app_info == NULL
+ || splash_screen_func == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ for (tmp = info->app_info->splashscreens; tmp; tmp = tmp->next) {
+ splashscreen = (splashscreen_x *)tmp->data;
+ if (splashscreen == NULL)
+ continue;
+ ret = splash_screen_func(splashscreen->src,
+ splashscreen->type,
+ splashscreen->orientation,
+ splashscreen->indicatordisplay,
+ splashscreen->operation,
+ splashscreen->color_depth,
+ user_data);
+ if (ret < 0)
+ break;
+ }
+
+ return PMINFO_R_OK;
+}
+
API int pkgmgrinfo_appinfo_is_nodisplay(pkgmgrinfo_appinfo_h handle, bool *nodisplay)
{
retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
retvm_if(enabled == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
- if (info->app_info == NULL || info->app_info->enabled == NULL)
+ if (info->app_info == NULL || info->app_info->is_disabled == NULL)
return PMINFO_R_ERROR;
- *enabled = _get_bool_value(info->app_info->enabled);
+ *enabled = !_get_bool_value(info->app_info->is_disabled);
return PMINFO_R_OK;
}
_LOGE("invalid parameter");
return PMINFO_R_EINVAL;
}
+ if (info->app_info->ui_gadget == NULL)
+ info->app_info->ui_gadget = strdup("false");
*ui_gadget = _get_bool_value(info->app_info->ui_gadget);
return PMINFO_R_OK;
}
+API int pkgmgrinfo_appinfo_is_removable(pkgmgrinfo_appinfo_h handle,
+ bool *removable)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info == NULL || info->app_info == NULL || removable == NULL) {
+ _LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ *removable = _get_bool_value(info->app_info->removable);
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_is_system(pkgmgrinfo_appinfo_h handle, bool *system)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info == NULL || info->app_info == NULL || system == NULL) {
+ _LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ *system = _get_bool_value(info->app_info->package_system);
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_is_disabled(pkgmgrinfo_appinfo_h handle, bool *disabled)
+{
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
+ retvm_if(disabled == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info->app_info == NULL || info->app_info->is_disabled == NULL)
+ return PMINFO_R_ERROR;
+
+ *disabled = _get_bool_value(info->app_info->is_disabled);
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_is_global(pkgmgrinfo_appinfo_h handle, bool *global)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
+ retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
+
+ if (info->app_info == NULL || info->app_info->for_all_users == NULL)
+ return PMINFO_R_ERROR;
+
+ *global = _get_bool_value(info->app_info->for_all_users);
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_get_splash_screen_display(pkgmgrinfo_appinfo_h handle, bool *splash_screen_display)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info == NULL || splash_screen_display == NULL) {
+ _LOGE("Invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ if (info->app_info == NULL || info->app_info->splash_screen_display == NULL)
+ return PMINFO_R_ERROR;
+
+ *splash_screen_display = _get_bool_value(info->app_info->splash_screen_display);
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_get_setup_appid(pkgmgrinfo_appinfo_h handle, char **setup_appid)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info == NULL || setup_appid == NULL) {
+ _LOGE("Invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ if (info->app_info == NULL || info->app_info->setup_appid == NULL)
+ return PMINFO_R_ERROR;
+
+ *setup_appid = info->app_info->setup_appid;
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_appinfo_is_support_ambient(pkgmgrinfo_appinfo_h handle,
+ bool *support_ambient)
+{
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info == NULL || support_ambient == NULL) {
+ _LOGE("Invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ if (info->app_info == NULL || info->app_info->support_ambient == NULL)
+ return PMINFO_R_ERROR;
+
+ *support_ambient = _get_bool_value(info->app_info->support_ambient);
+
+ return PMINFO_R_OK;
+}
+
API int pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo_h handle)
{
retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
static gint __compare_func(gconstpointer data1, gconstpointer data2)
{
- pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x*)data1;
- pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x*)data2;
+ pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x *)data1;
+ pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x *)data2;
if (node1->prop == node2->prop)
return 0;
else if (node1->prop > node2->prop)
_LOGE("Invalid Integer Property\n");
return PMINFO_R_EINVAL;
}
- pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
- pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
+ pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
+ pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
if (node == NULL) {
_LOGE("Out of Memory!!!\n");
return PMINFO_R_ERROR;
_LOGE("Invalid Boolean Property\n");
return PMINFO_R_EINVAL;
}
- pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
- pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
+ pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
+ pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
if (node == NULL) {
_LOGE("Out of Memory!!!\n");
return PMINFO_R_ERROR;
}
if (value)
- val = strndup("('true','True')", 15);
+ val = strndup("true", 4);
else
- val = strndup("('false','False')", 17);
+ val = strndup("false", 5);
if (val == NULL) {
_LOGE("Out of Memory\n");
free(node);
_LOGE("Invalid String Property\n");
return PMINFO_R_EINVAL;
}
- pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
- pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
+ pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
+ pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
if (node == NULL) {
_LOGE("Out of Memory!!!\n");
return PMINFO_R_ERROR;
node->prop = prop;
switch (prop) {
case E_PMINFO_APPINFO_PROP_APP_COMPONENT:
- if (strcmp(value, PMINFO_APPINFO_UI_APP) == 0)
- val = strndup("uiapp", PKG_STRING_LEN_MAX - 1);
- else
- val = strndup("svcapp", PKG_STRING_LEN_MAX - 1);
- node->value = val;
+ node->value = strdup(value);
link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
if (link)
filter->list = g_slist_delete_link(filter->list, link);
filter->list = g_slist_append(filter->list, (gpointer)node);
break;
case E_PMINFO_APPINFO_PROP_APP_CATEGORY:
- case E_PMINFO_APPINFO_PROP_APP_OPERATION:
- case E_PMINFO_APPINFO_PROP_APP_URI:
- case E_PMINFO_APPINFO_PROP_APP_MIME:
val = (char *)calloc(1, PKG_STRING_LEN_MAX);
if (val == NULL) {
_LOGE("Out of Memory\n");
if (link) {
ptr = (pkgmgrinfo_node_x *)link->data;
strncpy(prev, ptr->value, PKG_STRING_LEN_MAX - 1);
- _LOGE("Previous value is %s\n", prev);
+ _LOGI("Previous value is %s\n", prev);
filter->list = g_slist_delete_link(filter->list, link);
- snprintf(temp, PKG_STRING_LEN_MAX - 1, "%s , '%s'", prev, value);
+ snprintf(temp, PKG_STRING_LEN_MAX - 1, "%s,%s", prev, value);
strncpy(val, temp, PKG_STRING_LEN_MAX - 1);
- _LOGE("New value is %s\n", val);
+ _LOGI("New value is %s\n", val);
node->value = val;
filter->list = g_slist_append(filter->list, (gpointer)node);
memset(temp, '\0', PKG_STRING_LEN_MAX);
} else {
- snprintf(temp, PKG_STRING_LEN_MAX - 1, "'%s'", value);
+ snprintf(temp, PKG_STRING_LEN_MAX - 1, "%s", value);
strncpy(val, temp, PKG_STRING_LEN_MAX - 1);
- _LOGE("First value is %s\n", val);
+ _LOGI("First value is %s\n", val);
node->value = val;
filter->list = g_slist_append(filter->list, (gpointer)node);
memset(temp, '\0', PKG_STRING_LEN_MAX);
API int pkgmgrinfo_appinfo_usr_filter_count(pkgmgrinfo_appinfo_filter_h handle, int *count, uid_t uid)
{
int ret;
- GList *list = NULL;
+ char *locale;
+ GHashTable *list;
if (handle == NULL || count == NULL) {
_LOGE("invalid parameter");
return PMINFO_R_EINVAL;
}
- ret = _appinfo_get_filtered_list(handle, uid, &list);
- if (ret != PMINFO_R_OK)
+ locale = _get_system_locale();
+ if (locale == NULL)
+ return PMINFO_R_ERROR;
+
+ list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+ __free_applications);
+ if (list == NULL) {
+ free(locale);
return PMINFO_R_ERROR;
+ }
+
+ ret = _appinfo_get_applications(uid, uid, locale, handle, 0, list);
+ if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
+ ret = _appinfo_get_applications(GLOBAL_USER, uid, locale,
+ handle, 0, list);
- *count = g_list_length(list);
+ if (ret != PMINFO_R_OK) {
+ g_hash_table_destroy(list);
+ free(locale);
+ return PMINFO_R_ERROR;
+ }
- g_list_free_full(list, free);
+ *count = g_hash_table_size(list);
+ g_hash_table_destroy(list);
+ free(locale);
return PMINFO_R_OK;
}
API int pkgmgrinfo_appinfo_filter_count(pkgmgrinfo_appinfo_filter_h handle, int *count)
{
- return pkgmgrinfo_appinfo_usr_filter_count(handle, count, GLOBAL_USER);
+ return pkgmgrinfo_appinfo_usr_filter_count(handle, count, _getuid());
}
API int pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(
return PMINFO_R_EINVAL;
}
- return _appinfo_get_filtered_foreach_appinfo(uid, handle, app_cb,
+ return _appinfo_get_filtered_foreach_appinfo(uid, handle, PMINFO_APPINFO_GET_ALL, app_cb,
user_data);
}
API int pkgmgrinfo_appinfo_filter_foreach_appinfo(pkgmgrinfo_appinfo_filter_h handle,
- pkgmgrinfo_app_list_cb app_cb, void * user_data)
+ pkgmgrinfo_app_list_cb app_cb, void *user_data)
{
- return pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(handle, app_cb, user_data, GLOBAL_USER);
+ return pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(handle, app_cb, user_data, _getuid());
}
API int pkgmgrinfo_appinfo_metadata_filter_create(pkgmgrinfo_appinfo_metadata_filter_h *handle)
pkgmgrinfo_appinfo_metadata_filter_h handle,
const char *key, const char *value)
{
- int ret;
-
- ret = pkgmgrinfo_appinfo_filter_add_string(handle,
- PMINFO_APPINFO_PROP_APP_METADATA_KEY, key);
- if (ret != PMINFO_R_OK)
- return ret;
+ pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
+ pkgmgrinfo_metadata_node_x *node;
/* value can be NULL.
* In that case all apps with specified key should be displayed
*/
- if (value) {
- ret = pkgmgrinfo_appinfo_filter_add_string(handle,
- PMINFO_APPINFO_PROP_APP_METADATA_VALUE, value);
- if (ret != PMINFO_R_OK)
- return ret;
+ if (key == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ node = calloc(1, sizeof(pkgmgrinfo_metadata_node_x));
+ if (node == NULL) {
+ LOGE("out of memory");
+ return PMINFO_R_ERROR;
}
+ node->key = strdup(key);
+ if (value && strlen(value))
+ node->value = strdup(value);
+
+ filter->list_metadata = g_slist_append(filter->list_metadata,
+ (gpointer)node);
+
return PMINFO_R_OK;
}
return PMINFO_R_EINVAL;
}
- return _appinfo_get_filtered_foreach_appinfo(uid, handle, app_cb,
+ return _appinfo_get_filtered_foreach_appinfo(uid, handle, PMINFO_APPINFO_GET_ALL, app_cb,
user_data);
}
pkgmgrinfo_app_list_cb app_cb, void *user_data)
{
return pkgmgrinfo_appinfo_usr_metadata_filter_foreach(handle, app_cb,
- user_data, GLOBAL_USER);
+ user_data, _getuid());
}
API int pkgmgrinfo_appinfo_is_guestmode_visibility(pkgmgrinfo_appinfo_h handle, bool *status)