namespace {
-void __parse_appcontrol(GList** appcontrol,
- char* appcontrol_str, char* visibility, char* id) {
+char* GetCString(int idx, const tizen_base::Database::Result::Record& rec) {
+ std::optional<std::string> str = rec.GetString(idx);
+ if (!str)
+ return nullptr;
+
+ return strdup(str->c_str());
+}
+
+void ParseAppControl(GList** appcontrol,
+ const char* appcontrol_str, const char* visibility, const char* id) {
char* dup;
char* token;
char* ptr = nullptr;
free(dup);
}
-int _appinfo_get_splashscreens(sqlite3* db,
+int GetSplashScreens(const tizen_base::Database& db,
const char* appid, GList** splashscreens) {
- static const char query_raw[] =
+ auto q = std::move(tizen_base::Database::Sql(
"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;
- splashscreen_x* info;
-
- query = sqlite3_mprintf(query_raw, appid);
- if (query == nullptr) {
- LOGE("out of memory");
- return PMINFO_R_ERROR;
- }
+ "FROM package_app_splash_screen WHERE app_id=?")
+ .Bind(appid));
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ auto r = db.Exec(q);
+ if (!r) {
+ _LOGE("db.Exec() failed: %s", static_cast<const char*>(r));
return PMINFO_R_ERROR;
}
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = static_cast<splashscreen_x*>(calloc(1, sizeof(splashscreen_x)));
+ for (const auto& rec : r) {
+ splashscreen_x* info = static_cast<splashscreen_x*>(
+ calloc(1, sizeof(splashscreen_x)));
if (info == nullptr) {
LOGE("out of memory");
- sqlite3_finalize(stmt);
return PMINFO_R_ERROR;
}
- idx = 0;
- _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);
+
+ int idx = 0;
+ info->src = GetCString(idx++, rec);
+ info->type = GetCString(idx++, rec);
+ info->orientation = GetCString(idx++, rec);
+ info->indicatordisplay = GetCString(idx++, rec);
+ info->operation = GetCString(idx++, rec);
+ info->color_depth = GetCString(idx++, rec);
*splashscreens = g_list_prepend(*splashscreens, info);
}
- sqlite3_finalize(stmt);
-
return PMINFO_R_OK;
}
-int _appinfo_get_metadata(sqlite3* db,
+int GetMetadata(const tizen_base::Database& db,
const char* appid, GList** metadata) {
- static const char query_raw[] =
+ auto q = std::move(tizen_base::Database::Sql(
"SELECT md_key, md_value "
- "FROM package_app_app_metadata WHERE app_id=%Q";
- int ret;
- char* query;
- sqlite3_stmt* stmt;
- int idx;
- metadata_x* info;
-
- query = sqlite3_mprintf(query_raw, appid);
- if (query == nullptr) {
- LOGE("out of memory");
- return PMINFO_R_ERROR;
- }
+ "FROM package_app_app_metadata WHERE app_id=?")
+ .Bind(appid));
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ auto r = db.Exec(q);
+ if (!r) {
+ _LOGE("db.Exec() failed: %s", static_cast<const char*>(r));
return PMINFO_R_ERROR;
}
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
+ for (const auto& rec : r) {
+ metadata_x* info = static_cast<metadata_x*>(
+ calloc(1, sizeof(metadata_x)));
if (info == nullptr) {
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);
+
+ int idx = 0;
+ info->key = GetCString(idx++, rec);
+ info->value = GetCString(idx++, rec);
*metadata = g_list_prepend(*metadata, info);
}
- sqlite3_finalize(stmt);
-
return PMINFO_R_OK;
}
-int _appinfo_get_app_control(sqlite3* db,
+int GetAppControl(const tizen_base::Database& db,
const char* appid, GList** appcontrol) {
- static const char query_raw[] =
+ auto q = std::move(tizen_base::Database::Sql(
"SELECT app_control, visibility, app_control_id "
- "FROM package_app_app_control WHERE app_id=%Q";
- int ret;
- int idx;
- char *query;
- sqlite3_stmt *stmt;
- char *str;
- char *visibility;
- char *id;
-
- query = sqlite3_mprintf(query_raw, appid);
- if (query == nullptr) {
- LOGE("out of memory");
- return PMINFO_R_ERROR;
- }
+ "FROM package_app_app_control WHERE app_id=?")
+ .Bind(appid));
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ auto r = db.Exec(q);
+ if (!r) {
+ _LOGE("db.Exec() failed: %s", static_cast<const char*>(r));
return PMINFO_R_ERROR;
}
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- str = nullptr;
- visibility = nullptr;
- id = nullptr;
- idx = 0;
- _save_column_str(stmt, idx++, &str);
- _save_column_str(stmt, idx++, &visibility);
- _save_column_str(stmt, idx++, &id);
- /* TODO: revise */
- __parse_appcontrol(appcontrol, str, visibility, id);
- free(str);
- free(visibility);
- free(id);
+ for (const auto& rec : r) {
+ ParseAppControl(appcontrol, rec.GetString(0)->c_str(),
+ rec.GetString(1)->c_str(), rec.GetString(2)->c_str());
}
- sqlite3_finalize(stmt);
-
return PMINFO_R_OK;
}
-int _appinfo_get_category(sqlite3* db,
+int GetCategory(const tizen_base::Database& db,
const char* appid, GList** category) {
- static const char query_raw[] =
+ auto q = std::move(tizen_base::Database::Sql(
"SELECT category "
- "FROM package_app_app_category WHERE app_id=%Q";
- int ret;
- char* query;
- sqlite3_stmt* stmt;
- char* val;
-
- query = sqlite3_mprintf(query_raw, appid);
- if (query == nullptr) {
- LOGE("out of memory");
- return PMINFO_R_ERROR;
- }
-
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ "FROM package_app_app_category WHERE app_id=?")
+ .Bind(appid));
+ auto r = db.Exec(q);
+ if (!r) {
+ _LOGE("db.Exec() failed: %s", static_cast<const char*>(r));
return PMINFO_R_ERROR;
}
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- val = nullptr;
- _save_column_str(stmt, 0, &val);
+ for (const auto& rec : r) {
+ char* val = GetCString(0, rec);
if (val)
*category = g_list_prepend(*category, (gpointer)val);
}
- sqlite3_finalize(stmt);
-
return PMINFO_R_OK;
}
-int _appinfo_get_res_control(sqlite3* db, const char* appid,
+int GetResControl(const tizen_base::Database& db, const char* appid,
GList** res_control) {
- static const char query_raw[] =
- "SELECT res_type, min_res_version, max_res_version, auto_close "
- "FROM package_app_res_control WHERE app_id=%Q";
- int ret;
- char* query;
- sqlite3_stmt* stmt;
- int idx;
- res_control_x* info;
-
- query = sqlite3_mprintf(query_raw, appid);
- if (query == nullptr) {
- LOGE("out of memory");
+ auto q = std::move(tizen_base::Database::Sql(
+ "SELECT res_type, min_res_version, max_res_version, auto_close "
+ "FROM package_app_res_control WHERE app_id=?")
+ .Bind(appid));
+
+ auto r = db.Exec(q);
+ if (!r) {
+ _LOGE("db.Exec() failed: %s", static_cast<const char*>(r));
return PMINFO_R_ERROR;
}
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
- return PMINFO_R_ERROR;
- }
-
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = static_cast<res_control_x*>(calloc(1, sizeof(res_control_x)));
+ for (const auto& rec : r) {
+ res_control_x* info = static_cast<res_control_x*>(
+ calloc(1, sizeof(res_control_x)));
if (info == nullptr) {
LOGE("out of memory");
- sqlite3_finalize(stmt);
return PMINFO_R_ERROR;
}
- idx = 0;
- _save_column_str(stmt, idx++, &info->res_type);
- _save_column_str(stmt, idx++, &info->min_res_version);
- _save_column_str(stmt, idx++, &info->max_res_version);
- _save_column_str(stmt, idx++, &info->auto_close);
+
+ int idx = 0;
+ info->res_type = GetCString(idx++, rec);
+ info->min_res_version = GetCString(idx++, rec);
+ info->max_res_version = GetCString(idx++, rec);
+ info->auto_close = GetCString(idx++, rec);
*res_control = g_list_prepend(*res_control, info);
}
- sqlite3_finalize(stmt);
-
return PMINFO_R_OK;
}
return category_list;
}
-int __bind_params(sqlite3_stmt* stmt, GList* params) {
- GList* tmp_list = nullptr;
- int idx = 0;
- int ret;
-
- if (stmt == nullptr || params == nullptr)
- 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;
-}
-
constexpr const char join_localized_info[] =
" LEFT OUTER JOIN package_app_localized_info"
" ON ai.app_id=package_app_localized_info.app_id"
" LEFT OUTER JOIN package_privilege_info"
" ON ai.package=package_privilege_info.package ";
-int _get_filtered_query(pkgmgrinfo_filter_x* filter, const char* locale,
- uid_t uid, char** query, GList** bind_params) {
+int GetFilteredQuery(pkgmgrinfo_filter_x* filter, const char* locale,
+ uid_t uid, std::string& query, std::list<std::string>& bind_params) {
int joined = 0;
- int size;
char* condition = nullptr;
- char buf[MAX_QUERY_LEN] = {'\0'};
- char tmp_query[MAX_QUERY_LEN] = {'\0'};
- GSList* list;
if (!filter)
return PMINFO_R_OK;
- if (g_slist_length(filter->list) == 0) {
+ if (filter->cache_flag) {
joined = E_PMINFO_APPINFO_JOIN_LOCALIZED_INFO |
E_PMINFO_APPINFO_JOIN_CATEGORY |
E_PMINFO_APPINFO_JOIN_APP_CONTROL |
E_PMINFO_APPINFO_JOIN_PRIVILEGE;
}
- strncat(buf, " WHERE 1=1", sizeof(buf) - strlen(buf) - 1);
-
- for (list = filter->list; list; list = list->next) {
+ std::string buf = " WHERE 1=1";
+ GList* tmp_params = nullptr;
+ for (GSList* list = filter->list; list; list = list->next) {
joined |= __get_filter_condition(list->data,
- uid, &condition, bind_params);
+ uid, &condition, &tmp_params);
if (condition == nullptr)
continue;
- strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1);
-
- strncat(buf, condition, sizeof(buf) - strlen(buf) - 1);
+ buf += " AND ";
+ buf += condition;
free(condition);
condition = nullptr;
}
if (filter->list_metadata)
- strncat(buf, " AND (", sizeof(buf) - strlen(buf) - 1);
- for (list = filter->list_metadata; list; list = list->next) {
+ buf += " AND (";
+ for (GSList* list = filter->list_metadata; list; list = list->next) {
joined |= __get_metadata_filter_condition(list->data,
- &condition, bind_params);
+ &condition, &tmp_params);
if (condition == nullptr)
continue;
- strncat(buf, condition, sizeof(buf) - strlen(buf) - 1);
+ buf += condition;
free(condition);
condition = nullptr;
-
- strncat(buf, " OR ", sizeof(buf) - strlen(buf) - 1);
+ buf += " OR ";
}
+
if (filter->list_metadata)
- strncat(buf, "1=0)", sizeof(buf) - strlen(buf) - 1);
+ buf += "1=0)";
+ std::string tmp_query;
if (joined & E_PMINFO_APPINFO_JOIN_LOCALIZED_INFO) {
- strncat(tmp_query, join_localized_info,
- sizeof(tmp_query) - strlen(tmp_query) - 1);
- *bind_params = g_list_append(*bind_params, strdup(locale));
+ tmp_query += join_localized_info;
+ bind_params.push_back(locale);
}
+
if (joined & E_PMINFO_APPINFO_JOIN_CATEGORY)
- strncat(tmp_query, join_category,
- sizeof(tmp_query) - strlen(tmp_query) - 1);
+ tmp_query += join_category;
if (joined & E_PMINFO_APPINFO_JOIN_APP_CONTROL)
- strncat(tmp_query, join_app_control,
- sizeof(tmp_query) - strlen(tmp_query) - 1);
+ tmp_query += join_app_control;
if (joined & E_PMINFO_APPINFO_JOIN_METADATA)
- strncat(tmp_query, join_metadata,
- sizeof(tmp_query) - strlen(tmp_query) - 1);
+ tmp_query += join_metadata;
if (joined & E_PMINFO_APPINFO_JOIN_PRIVILEGE)
- strncat(tmp_query, join_privilege,
- sizeof(tmp_query) - strlen(tmp_query) - 1);
+ tmp_query += join_privilege;
- size = strlen(tmp_query) + strlen(buf) + 1;
- *query = static_cast<char*>(calloc(1, size));
- if (*query == nullptr)
- return PMINFO_R_ERROR;
- snprintf(*query, size, "%s%s", tmp_query, buf);
+ for (GList* l = tmp_params; l != nullptr; l = l->next)
+ bind_params.push_back(reinterpret_cast<char*>(l->data));
+
+ query = tmp_query + buf;
+ g_list_free_full(tmp_params, free);
return PMINFO_R_OK;
}
if (tmp_filter == nullptr)
return true;
+ if (tmp_filter->cache_flag)
+ return false;
+
property = _pminfo_appinfo_convert_to_prop_bool(
PMINFO_APPINFO_PROP_APP_CHECK_STORAGE);
for (tmp_list = tmp_filter->list; tmp_list != nullptr;
return true;
}
-int _appinfo_get_applications(sqlite3* db, uid_t db_uid, uid_t uid,
+enum class PackageDisableFilterStatus {
+ None,
+ True,
+ False
+};
+
+PackageDisableFilterStatus GetPackageDisableFilterStatus(
+ const pkgmgrinfo_filter_x* filter) {
+ GSList* tmp_list = nullptr;
+ pkgmgrinfo_node_x* tmp_node = nullptr;
+ int property = -1;
+
+ property = _pminfo_appinfo_convert_to_prop_bool(
+ PMINFO_APPINFO_PROP_PKG_DISABLE);
+ for (tmp_list = filter->list; tmp_list != nullptr;
+ tmp_list = g_slist_next(tmp_list)) {
+ tmp_node = reinterpret_cast<pkgmgrinfo_node_x*>(tmp_list->data);
+ if (property != tmp_node->prop)
+ continue;
+
+ return strcasecmp(tmp_node->value, "true") == 0 ?
+ PackageDisableFilterStatus::True : PackageDisableFilterStatus::False;
+ }
+
+ return PackageDisableFilterStatus::None;
+}
+
+bool CheckPkgDisableFilter(PackageDisableFilterStatus expected,
+ const char* package_disable, application_x* app_info) {
+ if (!package_disable)
+ return true;
+
+ PackageDisableFilterStatus result = strcasecmp(package_disable, "true") == 0 ?
+ PackageDisableFilterStatus::True : PackageDisableFilterStatus::False;
+
+ if (expected == result)
+ return true;
+
+ if (result == PackageDisableFilterStatus::True)
+ LOGW("The package [%s] to which the application [%s] belongs is disabled",
+ app_info->package, app_info->appid);
+
+ return false;
+}
+
+bool CheckAppDisableFilter(const pkgmgrinfo_filter_x* filter,
+ const application_x* app_info) {
+ GSList* tmp_list = nullptr;
+ pkgmgrinfo_node_x* tmp_node = nullptr;
+ int property = -1;
+
+ property = _pminfo_appinfo_convert_to_prop_bool(
+ PMINFO_APPINFO_PROP_APP_DISABLE);
+ for (tmp_list = filter->list; tmp_list != nullptr;
+ tmp_list = g_slist_next(tmp_list)) {
+ tmp_node = reinterpret_cast<pkgmgrinfo_node_x*>(tmp_list->data);
+ if (property != tmp_node->prop)
+ continue;
+
+ if (strcasecmp(tmp_node->value, app_info->is_disabled) == 0)
+ return true;
+
+ if (strcasecmp(app_info->is_disabled, "true") == 0)
+ LOGW("The application [%s] is disabled", app_info->appid);
+
+ return false;
+ }
+ return true;
+}
+
+int DoGetAppInfo(const tizen_base::Database& db, uid_t db_uid, uid_t uid,
const char* locale, pkgmgrinfo_filter_x* filter, int flag,
std::vector<std::shared_ptr<application_x>>& applications) {
static const char query_raw[] =
"SELECT DISTINCT ai.app_id, ai.app_installed_storage, "
"ai.app_external_path";
+ static const char query_app_disable[] = ", "
+ "CASE "
+ "WHEN ai.app_disable='true' COLLATE NOCASE OR "
+ "ui.is_disabled='true' COLLATE NOCASE "
+ "THEN 'true' "
+ "ELSE 'false' "
+ "END AS app_disable";
static const char query_basic[] =
", ai.app_component, ai.app_exec, "
"ai.app_nodisplay, ai.app_type, ai.app_onboot, "
"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_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, "
"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_package_disable[] =
+ ", (SELECT package_disable FROM package_info WHERE ai.package=package)";
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;
char* bg_category_str = nullptr;
- char* constraint = nullptr;
char* tmp_record = nullptr;
- char query[MAX_QUERY_LEN] = {'\0'};
- char buf[BUFSIZE] = {'\0'};
- application_x* info = nullptr;
- GList* bind_params = nullptr;
- sqlite3_stmt* stmt = nullptr;
+ std::list<std::string> bind_params;
bool is_check_storage = true;
const uid_t global_user_uid = GLOBAL_USER;
+ std::string query = query_raw;
+ auto pkg_disable_filter_status = GetPackageDisableFilterStatus(filter);
- snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
+ query += query_app_disable;
if (flag & PMINFO_APPINFO_GET_BASICINFO) {
- strncat(query, query_basic, sizeof(query) - strlen(query) - 1);
- strncat(query, query_uid_info,
- sizeof(query) - strlen(query) - 1);
+ query += query_basic;
+ query += query_uid_info;
}
+
if (flag & PMINFO_APPINFO_GET_LABEL) {
- strncat(query, query_label, sizeof(query) - strlen(query) - 1);
- bind_params = g_list_append(bind_params, strdup(locale));
+ query += query_label;
+ bind_params.push_back(locale);
}
+
if (flag & PMINFO_APPINFO_GET_ICON) {
- strncat(query, query_icon, sizeof(query) - strlen(query) - 1);
- bind_params = g_list_append(bind_params, strdup(locale));
+ query += query_icon;
+ bind_params.push_back(locale);
}
- snprintf(buf, MAX_QUERY_LEN - 1, "%d", uid);
- bind_params = g_list_append(bind_params, strdup(buf));
+ if (pkg_disable_filter_status != PackageDisableFilterStatus::None)
+ query += query_package_disable;
+ bind_params.push_back(std::to_string(uid));
is_check_storage = __check_app_storage_status(filter);
- ret = _get_filtered_query(filter, locale,
- uid, &constraint, &bind_params);
+ std::string constraint;
+ int ret = GetFilteredQuery(filter, locale, uid, constraint, bind_params);
if (ret != PMINFO_R_OK) {
LOGE("Failed to get WHERE clause");
- goto __catch;
+ return PMINFO_R_ERROR;
}
- strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1);
- strncat(query, query_uid_info_clause,
- sizeof(query) - strlen(query) - 1);
+ query += query_from_clause;
+ query += query_uid_info_clause;
- if (constraint)
- strncat(query, constraint, sizeof(query) - strlen(query) - 1);
+ if (!constraint.empty())
+ query += constraint;
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr);
- if (ret != SQLITE_OK) {
- LOGE("prepare failed: %s", sqlite3_errmsg(db));
- ret = PMINFO_R_ERROR;
- goto __catch;
- }
+ auto q = tizen_base::Database::Sql(query);
+ for (auto& i : bind_params)
+ q.Bind(std::move(i));
- if (g_list_length(bind_params) != 0) {
- ret = __bind_params(stmt, bind_params);
- if (ret != SQLITE_OK) {
- LOGE("Failed to bind parameters");
- goto __catch;
- }
+ auto r = db.Exec(q);
+ if (!r) {
+ _LOGE("db.Exec() failed: %s", static_cast<const char*>(r));
+ return PMINFO_R_ERROR;
}
- while (sqlite3_step(stmt) == SQLITE_ROW) {
- info = static_cast<application_x*>(calloc(1, sizeof(application_x)));
+ for (const auto& rec : r) {
+ application_x* info = static_cast<application_x*>(
+ calloc(1, sizeof(application_x)));
if (info == nullptr) {
LOGE("out of memory");
- ret = PMINFO_R_ERROR;
- goto __catch;
+ return PMINFO_R_ERROR;
}
+ std::shared_ptr<application_x> info_auto(info,
+ pkgmgrinfo_basic_free_application);
+
info->locale = strdup(locale);
if (info->locale == nullptr) {
LOGE("Out of memory");
- ret = PMINFO_R_ERROR;
- goto __catch;
+ return PMINFO_R_ERROR;
}
- 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);
-
+ int idx = 0;
+ info->appid = GetCString(idx++, rec);
+ info->installed_storage = GetCString(idx++, rec);
+ info->external_path = GetCString(idx++, rec);
+ info->is_disabled = GetCString(idx++, rec);
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);
- _save_column_str(stmt, idx++, &info->light_user_switch_mode);
+ info->component = GetCString(idx++, rec);
+ info->exec = GetCString(idx++, rec);
+ info->nodisplay = GetCString(idx++, rec);
+ info->type = GetCString(idx++, rec);
+ info->onboot = GetCString(idx++, rec);
+ info->multiple = GetCString(idx++, rec);
+ info->autorestart = GetCString(idx++, rec);
+ info->taskmanage = GetCString(idx++, rec);
+ info->hwacceleration = GetCString(idx++, rec);
+ info->screenreader = GetCString(idx++, rec);
+ info->mainapp = GetCString(idx++, rec);
+ info->recentimage = GetCString(idx++, rec);
+ info->launchcondition = GetCString(idx++, rec);
+ info->indicatordisplay = GetCString(idx++, rec);
+ info->portraitimg = GetCString(idx++, rec);
+ info->landscapeimg = GetCString(idx++, rec);
+ info->guestmode_visibility = GetCString(idx++, rec);
+ info->permission_type = GetCString(idx++, rec);
+ info->preload = GetCString(idx++, rec);
+ info->submode = GetCString(idx++, rec);
+ info->submode_mainid = GetCString(idx++, rec);
+ info->launch_mode = GetCString(idx++, rec);
+ info->ui_gadget = GetCString(idx++, rec);
+ info->support_disable = GetCString(idx++, rec);
+ info->process_pool = GetCString(idx++, rec);
+ bg_category_str = GetCString(idx++, rec);
+ info->package_type = GetCString(idx++, rec);
+ info->root_path = GetCString(idx++, rec);
+ info->api_version = GetCString(idx++, rec);
+ info->effective_appid = GetCString(idx++, rec);
+ info->splash_screen_display = GetCString(idx++, rec);
+ info->tep_name = GetCString(idx++, rec);
+ info->zip_mount_file = GetCString(idx++, rec);
+ info->component_type = GetCString(idx++, rec);
+ info->package = GetCString(idx++, rec);
+ info->package_system = GetCString(idx++, rec);
+ info->removable = GetCString(idx++, rec);
+ info->package_installed_time = GetCString(idx++, rec);
+ info->support_mode = GetCString(idx++, rec);
+ info->support_ambient = GetCString(idx++, rec);
+ info->setup_appid = GetCString(idx++, rec);
+ info->light_user_switch_mode = GetCString(idx++, rec);
info->background_category = __get_background_category(
bg_category_str);
free(bg_category_str);
- bg_category_str = nullptr;
}
info->for_all_users =
if (db_uid != global_user_uid) {
idx = idx + 2;
} else {
- tmp_record = nullptr;
- _save_column_str(stmt, idx++, &tmp_record);
+ tmp_record = GetCString(idx++, rec);
if (tmp_record != nullptr) {
- if (strcasecmp(info->is_disabled, "false") == 0 &&
+ if (info->is_disabled &&
+ strcasecmp(info->is_disabled, "false") == 0 &&
strcasecmp(tmp_record, "false") == 0) {
free(info->is_disabled);
info->is_disabled = tmp_record;
free(tmp_record);
}
}
- tmp_record = nullptr;
- _save_column_str(stmt, idx++, &tmp_record);
+ tmp_record = GetCString(idx++, rec);
if (tmp_record != nullptr) {
- if (strcasecmp(info->splash_screen_display, "false") == 0 &&
+ if (info->splash_screen_display &&
+ 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 = nullptr;
- _save_column_str(stmt, idx++, &tmp_record);
+ tmp_record = GetCString(idx++, rec);
if (_add_label_info_into_list(locale, tmp_record,
&info->label)) {
- ret = PMINFO_R_ERROR;
- goto __catch;
+ if (tmp_record)
+ free(tmp_record);
+
+ return PMINFO_R_ERROR;
}
}
if (flag & PMINFO_APPINFO_GET_ICON) {
- tmp_record = nullptr;
- _save_column_str(stmt, idx++, &tmp_record);
+ tmp_record = GetCString(idx++, rec);
if (_add_icon_info_into_list(locale, tmp_record,
&info->icon)) {
- ret = PMINFO_R_ERROR;
- goto __catch;
+ if (tmp_record)
+ free(tmp_record);
+
+ return PMINFO_R_ERROR;
}
}
- if (flag & PMINFO_APPINFO_GET_CATEGORY) {
- if (_appinfo_get_category(db, info->appid,
- &info->category)) {
- ret = PMINFO_R_ERROR;
- goto __catch;
+ if (pkg_disable_filter_status != PackageDisableFilterStatus::None) {
+ tmp_record = GetCString(idx++, rec);
+ if (tmp_record) {
+ bool filter_passed = CheckPkgDisableFilter(pkg_disable_filter_status,
+ tmp_record, info);
+ free(tmp_record);
+
+ if (!filter_passed)
+ continue;
}
}
+ if (flag & PMINFO_APPINFO_GET_CATEGORY) {
+ if (GetCategory(db, info->appid, &info->category))
+ return PMINFO_R_ERROR;
+ }
+
if (flag & PMINFO_APPINFO_GET_APP_CONTROL) {
- if (_appinfo_get_app_control(db, info->appid,
- &info->appcontrol)) {
- ret = PMINFO_R_ERROR;
- goto __catch;
- }
+ if (GetAppControl(db, info->appid, &info->appcontrol))
+ return PMINFO_R_ERROR;
}
if (flag & PMINFO_APPINFO_GET_METADATA) {
- if (_appinfo_get_metadata(db, info->appid,
- &info->metadata)) {
- ret = PMINFO_R_ERROR;
- goto __catch;
- }
+ if (GetMetadata(db, info->appid, &info->metadata))
+ return PMINFO_R_ERROR;
}
if (flag & PMINFO_APPINFO_GET_SPLASH_SCREEN) {
- if (_appinfo_get_splashscreens(db, info->appid,
- &info->splashscreens)) {
- ret = PMINFO_R_ERROR;
- goto __catch;
- }
+ if (GetSplashScreens(db, info->appid, &info->splashscreens))
+ return PMINFO_R_ERROR;
}
if (flag & PMINFO_APPINFO_GET_RES_CONTROL) {
- if (_appinfo_get_res_control(db, info->appid,
- &info->res_control)) {
- ret = PMINFO_R_ERROR;
- goto __catch;
- }
+ if (GetResControl(db, info->appid, &info->res_control))
+ return PMINFO_R_ERROR;
}
if (is_check_storage &&
__appinfo_check_installed_storage(info) !=
PMINFO_R_OK) {
- ret = PMINFO_R_ERROR;
- pkgmgrinfo_basic_free_application(info);
- info = nullptr;
continue;
}
- applications.emplace_back(info, pkgmgrinfo_basic_free_application);
- }
-
- ret = PMINFO_R_OK;
-
-__catch:
- sqlite3_finalize(stmt);
-
- if (constraint)
- free(constraint);
+ if (!CheckAppDisableFilter(filter, info))
+ continue;
- if (ret != PMINFO_R_OK && info != nullptr)
- pkgmgrinfo_basic_free_application(info);
+ if (!(flag & PMINFO_APPINFO_GET_BASICINFO) && info->is_disabled) {
+ free(info->is_disabled);
+ info->is_disabled = nullptr;
+ }
- g_list_free_full(bind_params, free);
+ applications.push_back(std::move(info_auto));
+ }
- return ret;
+ return PMINFO_R_OK;
}
} // namespace
namespace pkgmgr_server {
namespace internal {
-API int appinfo_internal_filter_get_list(sqlite3* db,
+API bool CheckAppStorageStatus(pkgmgrinfo_filter_x* tmp_filter) {
+ return ::__check_app_storage_status(tmp_filter);
+}
+
+API int GetAppInfo(const tizen_base::Database& db,
pkgmgrinfo_appinfo_filter_h filter, uid_t db_uid, uid_t uid,
- const char* locale,
+ const std::string& locale,
std::vector<std::shared_ptr<application_x>>& appinfo_list) {
- if (db == nullptr || filter == nullptr) {
+ if (!static_cast<bool>(db) || filter == nullptr) {
LOGE("Invalid argument");
return PMINFO_R_EINVAL;
}
- return ::_appinfo_get_applications(db, db_uid, uid, locale,
+ return ::DoGetAppInfo(db, db_uid, uid, locale.c_str(),
static_cast<pkgmgrinfo_filter_x*>(filter), PMINFO_APPINFO_GET_ALL,
appinfo_list);
}
projects / platform / core / appfw / pkgmgr-info.git / blobdiff