#define PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF "PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF"
/** String property for filtering based on package info*/
#define PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE "PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE"
+ /** String property for filtering based on package info*/
+#define PMINFO_PKGINFO_PROP_PACKAGE_RES_TYPE "PMINFO_PKGINFO_PROP_PACKAGE_RES_TYPE"
/** Boolean property for filtering based on package info*/
#define PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE "PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE"
*/
int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path);
+/**
+ * @fn int pkgmgrinfo_pkginfo_get_res_type(pkgmgrinfo_pkginfo_h handle, char **res_type)
+ * @brief This API gets the resource type of package
+ *
+ * @par Sync (or) Async : Synchronous API
+ *
+ * @param[in] handle pointer to package info handle
+ * @param[out] res_type pointer to hold resource type of package
+ * @return 0 if success, error code(<0) if fail
+ * @retval PMINFO_R_OK success
+ * @retval PMINFO_R_EINVAL invalid argument
+ * @retval PMINFO_R_ERROR internal error
+ * @code
+static int get_res_type(const char *pkgid)
+{
+ int ret = 0;
+ char *res_type = 0;
+ pkgmgrinfo_pkginfo_h handle;
+ ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
+ if (ret != PMINFO_R_OK)
+ return -1;
+
+ ret = pkgmgrinfo_pkginfo_get_res_type(handle, &res_type);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return -1;
+ }
+ printf("res_type : %s\n", res_type);
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+
+ return 0;
+}
+ * @endcode
+ */
+int pkgmgrinfo_pkginfo_get_res_type(pkgmgrinfo_pkginfo_h handle, char **res_type);
+
+/**
+ * @fn int pkgmgrinfo_pkginfo_get_res_version(pkgmgrinfo_pkginfo_h handle, char **res_version)
+ * @brief This API gets the resource version of package
+ *
+ * @par Sync (or) Async : Synchronous API
+ *
+ * @param[in] handle pointer to package info handle
+ * @param[out] res_version pointer to hold resource version of package
+ * @return 0 if success, error code(<0) if fail
+ * @retval PMINFO_R_OK success
+ * @retval PMINFO_R_EINVAL invalid argument
+ * @retval PMINFO_R_ERROR internal error
+ * @code
+static int get_res_version(const char *pkgid)
+{
+ int ret = 0;
+ char *res_version = 0;
+ pkgmgrinfo_pkginfo_h handle;
+ ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
+ if (ret != PMINFO_R_OK)
+ return -1;
+
+ ret = pkgmgrinfo_pkginfo_get_res_version(handle, &res_version);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return -1;
+ }
+ printf("res_version : %s\n", res_version);
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+
+ return 0;
+}
+ * @endcode
+ */
+int pkgmgrinfo_pkginfo_get_res_version(pkgmgrinfo_pkginfo_h handle, char **res_version);
+
/**
* @fn int pkgmgrinfo_pkginfo_get_support_mode(pkgmgrinfo_pkginfo_h handle, int *support_mode)
* @brief This API gets the support_mode of package
int pkgmgrinfo_appinfo_foreach_splash_screen(pkgmgrinfo_appinfo_h handle,
pkgmgrinfo_app_splash_screen_list_cb splash_screen_func, void *user_data);
+/**
+ * @fn int pkgmgrinfo_appinfo_foreach_res_control(pkgmgrinfo_appinfo_h handle,
+ pkgmgrinfo_app_res_control_list_cb res_control_func, void *user_data);
+ * @brief This API gets the list of resource control for a particular application
+ *
+ * @par This API is for package-manager client application
+ * @par Sync (or) Async : Synchronous API
+ * @param[in] handle pointer to the application info handle.
+ * @param[in] res_control_func callback function for list
+ * @param[in] user_data user data to be passed to callback function
+ * @return 0 if success, error code(<0) if fail
+ * @retval PMINFO_R_OK success
+ * @retval PMINFO_R_EINVAL invalid argument
+ * @retval PMINFO_R_ERROR internal error
+ * @pre pkgmgrinfo_appinfo_get_appinfo()
+ * @post pkgmgrinfo_appinfo_destroy_appinfo()
+ * @code
+int res_control_func(const char *res_type,
+ const char *min_res_version, const char *max_res_version,
+ const char *auto_close, void *user_data)
+{
+ printf("res_type : %s\n", res_type);
+ return 0;
+}
+
+static int list_res_control(const char *appid, char *key)
+{
+ int ret = 0;
+ pkgmgrinfo_appinfo_h handle;
+ ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
+ if (ret != PMINFO_R_OK)
+ return -1;
+ ret = pkgmgrinfo_appinfo_foreach_res_control(handle, res_control_func, NULL);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_destroy_appinfo(handle);
+ return -1;
+ }
+ pkgmgrinfo_appinfo_destroy_appinfo(handle);
+ return 0;
+}
+ * @endcode
+ */
+int pkgmgrinfo_appinfo_foreach_res_control(pkgmgrinfo_appinfo_h handle,
+ pkgmgrinfo_app_res_control_list_cb res_control_func,
+ void *user_data);
+
/**
* @fn int pkgmgrinfo_appinfo_is_nodisplay(pkgmgrinfo_appinfo_h handle, bool *nodisplay)
* @brief This API gets the application 'nodisplay' value from the app ID
pkgmgrinfo_pkg_dependency_list_cb dependency_cb,
void *user_data);
+/**
+ * @fn int pkgmgrinfo_pkginfo_foreach_res_allowed_package(pkgmgrinfo_pkginfo_h handle,
+ pkgmgrinfo_res_allowed_package_list_cb res_allowed_package_cb,
+ void *user_data)
+ * @brief This API gets the list of allowed package for a particular package
+ *
+ * @par This API is for package-manager client application
+ * @par Sync (or) Async : Synchronous API
+ * @param[in] handle pointer to the package info handle.
+ * @param[in] res_allowed_package_cb callback function for list
+ * @param[in] user_data user data to be passed to callback function
+ * @return 0 if success, error code(<0) if fail
+ * @retval PMINFO_R_OK success
+ * @retval PMINFO_R_EINVAL invalid argument
+ * @retval PMINFO_R_ERROR internal error
+ * @pre pkgmgrinfo_pkginfo_get_pkginfo()
+ * @post pkgmgrinfo_pkginfo_destroy_pkginfo()
+ * @code
+int res_allowed_package_cb(const char *allowed_package,
+ required_privilege_h handle, void *user_data)
+{
+ printf("allowed package : %s", allowed_package);
+
+ return 0;
+}
+
+static int list_res_allowed_package(const char *package)
+{
+ int ret = 0;
+ pkgmgrinfo_pkginfo_h handle;
+ ret = pkgmgrinfo_pkginfo_get_pkginfo(package, &handle);
+ if (ret != PMINFO_R_OK)
+ return -1;
+ ret = pkgmgrinfo_pkginfo_foreach_res_allowed_package(handle, res_allowed_package_cb, NULL);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return -1;
+ }
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return 0;
+}
+ * @endcode
+ */
+int pkgmgrinfo_pkginfo_foreach_res_allowed_package(pkgmgrinfo_pkginfo_h handle,
+ pkgmgrinfo_res_allowed_package_list_cb res_allowed_package_cb,
+ void *user_data);
+
+/**
+ * @fn int pkgmgrinfo_pkginfo_foreach_required_privilege(
+ required_privilege_h handle,
+ pkgmgrinfo_pkg_privilege_list_cb privilege_func,
+ void *user_data)
+ * @brief This API gets the list of allowed package's required privileges
+ *
+ * @par This API is for package-manager client application
+ * @par Sync (or) Async : Synchronous API
+ * @param[in] handle pointer to the required privilege handle.
+ * @param[in] privilege_func callback function for list
+ * @param[in] user_data user data to be passed to callback function
+ * @return 0 if success, error code(<0) if fail
+ * @retval PMINFO_R_OK success
+ * @retval PMINFO_R_EINVAL invalid argument
+ * @pre pkgmgrinfo_pkginfo_foreach_res_allowed_package()
+ * @post None
+ * @code
+int privilege_func(const char *privilege_name, void *user_data)
+{
+ printf("required privilege : %s", privilege_name);
+
+ return 0;
+}
+
+int res_allowed_package_cb(const char *allowed_package,
+ required_privilege_h handle, void *user_data)
+{
+ int ret = 0;
+ printf("allowed package : %s", allowed_package);
+
+ ret = pkgmgrinfo_pkginfo_foreach_required_privilege(handle, privilege_func, user_data);
+ if (ret != PMINFO_R_OK)
+ return -1;
+
+ return 0;
+}
+
+static int list_res_allowed_package(const char *package)
+{
+ int ret = 0;
+ pkgmgrinfo_pkginfo_h handle;
+ ret = pkgmgrinfo_pkginfo_get_pkginfo(package, &handle);
+ if (ret != PMINFO_R_OK)
+ return -1;
+ ret = pkgmgrinfo_pkginfo_foreach_res_allowed_package(handle, res_allowed_package_cb, NULL);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return -1;
+ }
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return 0;
+}
+ * @endcode
+ */
+int pkgmgrinfo_pkginfo_foreach_required_privilege(
+ required_privilege_h handle,
+ pkgmgrinfo_pkg_privilege_list_cb privilege_func,
+ void *user_data);
+
/**
* @fn int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb, int flag, void *user_data)
* @brief This API gets list of installed packages using flag that used for masking package's information
char *required_version;
} dependency_x;
+typedef struct res_allowed_package_x {
+ char *allowed_package;
+ GList *required_privileges;
+} res_allowed_package_x;
+
+typedef struct res_control_x {
+ char *res_type;
+ char *min_res_version;
+ char *max_res_version;
+ char *auto_close;
+} res_control_x;
+
typedef struct application_x {
char *appid; /*attr*/
char *exec; /*attr*/
GList *background_category; /*element*/
GList *appcontrol; /*element*/
GList *splashscreens; /*element*/
+ GList *res_control; /*element*/
} application_x;
typedef struct package_x {
char *external_path; /**< external storage path if exists, no xml part*/
char *use_system_certs; /**< use system certificates, attr*/
char *locale; /*no xml part*/
+ char *res_type; /**< res type, attr*/
+ char *res_version; /**< res version, attr*/
GList *icon; /**< package icon, element*/
GList *label; /**< package label, element*/
GList *author; /**< package author, element*/
GList *deviceprofile; /**< package device profile, element*/
GList *dependencies; /**< package dependencies, element*/
GList *plugin; /**< plugin execution list, no xml part*/
+ GList *res_allowed_packages; /**< res allowed packages, element*/
} package_x;
typedef struct updateinfo_x {
PMINFO_APPINFO_GET_APP_CONTROL = 0x0010,
PMINFO_APPINFO_GET_METADATA = 0x0020,
PMINFO_APPINFO_GET_SPLASH_SCREEN = 0x0040,
- PMINFO_APPINFO_GET_ALL = 0x007F
+ PMINFO_APPINFO_GET_RES_CONTROL = 0x0080,
+ PMINFO_APPINFO_GET_ALL = 0x00FF
} pkgmgrinfo_appinfo_get_option;
typedef enum {
PMINFO_PKGINFO_GET_PRIVILEGE = 0x0020,
PMINFO_PKGINFO_GET_APPDEFINED_PRIVILEGE = 0x0040,
PMINFO_PKGINFO_GET_DEPENDENCY = 0x0080,
- PMINFO_PKGINFO_GET_ALL = 0x00FF
+ PMINFO_PKGINFO_GET_RES_INFO = 0x0100,
+ PMINFO_PKGINFO_GET_ALL = 0x01FF
} pkgmgrinfo_pkginfo_get_option;
/**
*/
typedef void *pkgmgrinfo_archiveinfo_h;
+/**
+ * @brief A handle to get allowed package required privilege
+ */
+typedef void *required_privilege_h;
+
/**
* @brief type definition.
*/
const char *plugin_type, const char *plugin_name,
void *user_data);
+/**
+ * @fn int (*pkgmgrinfo_res_allowed_package_list_cb) (
+ const char *allowed_package,
+ required_privilege_h privilege_handle, void *user_data);
+ *
+ * @brief Specifies the type of function passed to pkgmgrinfo_pkginfo_foreach_res_allowed_package()
+ *
+ * @param[in] allowed_package the name of the package
+ * @param[in] privilege_handle the required privilege handle of the package
+ * @param[in] user_data user data passed to pkgmgrinfo_pkginfo_foreach_res_allowed_package()
+ *
+ * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
+ *
+ * @see pkgmgrinfo_pkginfo_foreach_res_allowed_package()
+ */
+typedef int (*pkgmgrinfo_res_allowed_package_list_cb) (
+ const char *allowed_package,
+ required_privilege_h privilege_handle, void *user_data);
+
/**
* @fn int (*pkgmgrinfo_app_metadata_list_cb) (const char *metadata_key, const char *metadata_value, void *user_data)
*
const char *indicatordisplay, const char *operation,
const char *color_depth, void *user_data);
+/**
+ * @fn int (*pkgmgrinfo_app_res_control_list_cb) (const char *res_type,
+ const char *min_res_version, const char *max_res_version,
+ const char *auto_close, void *user_data);
+ * @brief Specifies the type of function passed to pkgmgrinfo_appinfo_foreach_res_control()
+ *
+ * @param[in] res_type the resource type of the res_control
+ * @param[in] min_res_version the minimum resource version of the res_control
+ * @param[in] max_res_version the maximum resource version of the res_control
+ * @param[in] auto_close the auto close of the res_control
+ * @param[in] user_data user data passed to pkgmgrinfo_appinfo_foreach_res_control()
+ *
+ * @return 0 if success, negative value(<0) if fail, Callback is not called if return value is negative.\n
+ *
+ * @see pkgmgrinfo_appinfo_foreach_res_control()
+ */
+
+typedef int (*pkgmgrinfo_app_res_control_list_cb) (const char *res_type,
+ const char *min_res_version, const char *max_res_version,
+ const char *auto_close, void *user_data);
+
/**
return PMINFO_R_OK;
}
+static int _appinfo_get_res_control(sqlite3 *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 == 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));
+ return PMINFO_R_ERROR;
+ }
+
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ info = calloc(1, sizeof(res_control_x));
+ if (info == NULL) {
+ 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);
+ *res_control = g_list_prepend(*res_control, info);
+ }
+
+ sqlite3_finalize(stmt);
+
+ return PMINFO_R_OK;
+}
+
static GList *__get_background_category(const char *value)
{
GList *category_list = NULL;
}
}
+ 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 (is_check_storage &&
__appinfo_check_installed_storage(info) !=
PMINFO_R_OK) {
}
}
+void AppInfoParcelable::WriteResControl(tizen_base::Parcel* parcel,
+ GList* res_control) const {
+ int size = g_list_length(res_control);
+ WriteInt(parcel, size);
+
+ for (GList* tmp = res_control; tmp; tmp = tmp->next) {
+ res_control_x* ptr = reinterpret_cast<res_control_x*>(tmp->data);
+ WriteString(parcel, ptr->res_type);
+ WriteString(parcel, ptr->min_res_version);
+ WriteString(parcel, ptr->max_res_version);
+ WriteString(parcel, ptr->auto_close);
+ }
+}
+
void AppInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
int size = 0;
ReadInt(parcel, &size);
*list = g_list_append(*list, appcontrol);
}
}
+
void AppInfoParcelable::ReadSplashscreens(
tizen_base::Parcel* parcel, GList** list) {
int size = 0;
}
}
+void AppInfoParcelable::ReadResControl(
+ tizen_base::Parcel* parcel, GList** list) {
+ int size = 0;
+ ReadInt(parcel, &size);
+
+ for (int i = 0; i < size; ++i) {
+ res_control_x* res_control =
+ reinterpret_cast<res_control_x*>(calloc(1, sizeof(res_control_x)));
+ ReadString(parcel, &res_control->res_type);
+ ReadString(parcel, &res_control->min_res_version);
+ ReadString(parcel, &res_control->max_res_version);
+ ReadString(parcel, &res_control->auto_close);
+
+ *list = g_list_prepend(*list, res_control);
+ }
+}
+
AppInfoParcelable::AppInfoParcelable()
: AbstractParcelable(0, ParcelableType::AppInfo), auto_release_(true) {}
ReadBackgroundCategory(parcel, &application->background_category);
ReadAppcontrol(parcel, &application->appcontrol);
ReadSplashscreens(parcel, &application->splashscreens);
+ ReadResControl(parcel, &application->res_control);
return application;
}
WriteBackgroundCategory(parcel, application->background_category);
WriteAppcontrol(parcel, application->appcontrol);
WriteSplashscreens(parcel, application->splashscreens);
+ WriteResControl(parcel, application->res_control);
return true;
}
void WriteBackgroundCategory(tizen_base::Parcel* parcel, GList* backgroundcategory) const;
void WriteAppcontrol(tizen_base::Parcel* parcel, GList* appcontrol) const;
void WriteSplashscreens(tizen_base::Parcel* parcel, GList* splashscreens) const;
+ void WriteResControl(tizen_base::Parcel* parcel, GList* splashscreens) const;
bool WriteApplication(tizen_base::Parcel* parcel, application_x *application) const;
void ReadLabel(tizen_base::Parcel* parcel, GList** list);
void ReadIcon(tizen_base::Parcel* parcel, GList** list);
void ReadBackgroundCategory(tizen_base::Parcel* parcel, GList** list);
void ReadAppcontrol(tizen_base::Parcel* parcel, GList** list);
void ReadSplashscreens(tizen_base::Parcel* parcel, GList** list);
+ void ReadResControl(tizen_base::Parcel* parcel, GList** list);
application_x *ReadApplication(tizen_base::Parcel* parcel);
std::vector<application_x *> app_list_;
}
}
+void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
+ GList* res_allowed_packages) const {
+ int size = g_list_length(res_allowed_packages);
+ WriteInt(parcel, size);
+
+ for (GList* tmp = res_allowed_packages; tmp; tmp = tmp->next) {
+ res_allowed_package_x* ptr =
+ reinterpret_cast<res_allowed_package_x*>(tmp->data);
+ WriteString(parcel, ptr->allowed_package);
+
+ WriteInt(parcel, g_list_length(ptr->required_privileges));
+ for (GList *priv = ptr->required_privileges; priv; priv = priv->next)
+ WriteString(parcel, reinterpret_cast<char *>(priv->data));
+ }
+}
+
void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
package_x *package) const {
WriteString(parcel, package->for_all_users);
WriteString(parcel, package->external_path);
WriteString(parcel, package->use_system_certs);
WriteString(parcel, package->locale);
+ WriteString(parcel, package->res_type);
+ WriteString(parcel, package->res_version);
WriteIcon(parcel, package->icon);
WriteLabel(parcel, package->label);
WriteAuthor(parcel, package->author);
WriteDeviceprofile(parcel, package->deviceprofile);
WriteDependencies(parcel, package->dependencies);
WritePlugin(parcel, package->plugin);
+ WriteResAllowedPackages(parcel, package->res_allowed_packages);
}
void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
}
}
+void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
+ GList** list) {
+ int size = 0;
+ ReadInt(parcel, &size);
+
+ for (int i = 0; i < size; ++i) {
+ res_allowed_package_x* res_allowed_package =
+ reinterpret_cast<res_allowed_package_x*>(
+ calloc(1, sizeof(res_allowed_package_x)));
+ ReadString(parcel, &res_allowed_package->allowed_package);
+
+ int priv_len;
+ GList *priv_list = nullptr;
+ ReadInt(parcel, &priv_len);
+ for (int i = 0; i < priv_len; ++i) {
+ char *priv = nullptr;
+ ReadString(parcel, &priv);
+ priv_list = g_list_prepend(priv_list, priv);
+ }
+ res_allowed_package->required_privileges = priv_list;
+
+ *list = g_list_prepend(*list, res_allowed_package);
+ }
+}
+
package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
package_x* package =
reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
ReadString(parcel, &package->external_path);
ReadString(parcel, &package->use_system_certs);
ReadString(parcel, &package->locale);
+ ReadString(parcel, &package->res_type);
+ ReadString(parcel, &package->res_version);
ReadIcon(parcel, &package->icon);
ReadLabel(parcel, &package->label);
ReadAuthor(parcel, &package->author);
ReadDeviceprofile(parcel, &package->deviceprofile);
ReadDependencies(parcel, &package->dependencies);
ReadPlugin(parcel, &package->plugin);
+ ReadResAllowedPackages(parcel, &package->res_allowed_packages);
return package;
}
void WriteDeviceprofile(tizen_base::Parcel* parcel, GList* deviceprofile) const;
void WriteDependencies(tizen_base::Parcel* parcel, GList* dependencies) const;
void WritePlugin(tizen_base::Parcel* parcel, GList* plugin) const;
+ void WriteResAllowedPackages(tizen_base::Parcel* parcel, GList* plugin) const;
void WritePackage(tizen_base::Parcel* parcel, package_x *package) const;
void ReadIcon(tizen_base::Parcel* parcel, GList** list);
void ReadLabel(tizen_base::Parcel* parcel, GList** list);
void ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list);
void ReadDependencies(tizen_base::Parcel* parcel, GList** list);
void ReadPlugin(tizen_base::Parcel* parcel, GList** list);
+ void ReadResAllowedPackages(tizen_base::Parcel* parcel, GList** list);
package_x *ReadPackage(tizen_base::Parcel* parcel);
std::vector<package_x *> pkg_list_;
static const char join_privilege_info[] =
" LEFT OUTER JOIN package_privilege_info"
" ON pi.package=package_privilege_info.package";
+static const char join_res_info[] =
+ " LEFT OUTER JOIN package_res_info"
+ " ON pi.package=package_res_info.package";
static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
const char *locale, uid_t uid,
if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO)
strncat(buf2, join_privilege_info,
sizeof(buf2) - strlen(buf2) - 1);
+ if (joined & E_PMINFO_PKGINFO_JOIN_RES_INFO)
+ strncat(buf2, join_res_info,
+ sizeof(buf2) - strlen(buf2) - 1);
size = strlen(buf2) + strlen(buf) + 1;
*query = (char *)calloc(1, size);
return PMINFO_R_OK;
}
+static int _pkginfo_get_res_allowed_packages(sqlite3 *db, const char *pkgid,
+ GList **allowed_packages)
+{
+ static const char query_raw[] =
+ "SELECT DISTINCT allowed_package, required_privilege "
+ "FROM package_res_allowed_package WHERE package=%Q";
+ int ret;
+ char *query;
+ char *package;
+ char *privilege;
+ sqlite3_stmt *stmt;
+ res_allowed_package_x *allowed_package_x;
+ GList *l;
+
+ query = sqlite3_mprintf(query_raw, pkgid);
+ 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));
+ return PMINFO_R_ERROR;
+ }
+
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ allowed_package_x = NULL;
+ package = NULL;
+ privilege = NULL;
+
+ _save_column_str(stmt, 0, &package);
+ if (!package)
+ continue;
+
+ for (l = *allowed_packages; l; l = l->next) {
+ allowed_package_x = (res_allowed_package_x *)l->data;
+ if (!strcmp(package, (char *)l->data))
+ break;
+ allowed_package_x = NULL;
+ }
+
+ if (allowed_package_x) {
+ free(package);
+ } else {
+ allowed_package_x = calloc(1,
+ sizeof(res_allowed_package_x));
+ if (allowed_package_x == NULL) {
+ LOGE("failed to alloc memory");
+ sqlite3_finalize(stmt);
+ free(package);
+ return PMINFO_R_ERROR;
+ }
+ allowed_package_x->allowed_package = package;
+ *allowed_packages = g_list_prepend(*allowed_packages,
+ (gpointer)allowed_package_x);
+ }
+
+ _save_column_str(stmt, 1, &privilege);
+ if (!privilege)
+ continue;
+
+ allowed_package_x->required_privileges = g_list_prepend(
+ allowed_package_x->required_privileges,
+ privilege);
+ }
+
+ sqlite3_finalize(stmt);
+
+ return PMINFO_R_OK;
+}
+
+static int _pkginfo_get_res_info(sqlite3 *db, const char *pkgid,
+ char **res_type, char **res_version,
+ GList **res_allowed_packages)
+{
+ static const char query_raw[] =
+ "SELECT DISTINCT res_type, res_version "
+ "FROM package_res_info WHERE package=%Q";
+ int ret;
+ char *query;
+ sqlite3_stmt *stmt;
+
+ query = sqlite3_mprintf(query_raw, pkgid);
+ 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));
+ return PMINFO_R_ERROR;
+ }
+
+ if (sqlite3_step(stmt) != SQLITE_ROW) {
+ sqlite3_finalize(stmt);
+ return PMINFO_R_OK;
+ }
+
+ _save_column_str(stmt, 0, res_type);
+ _save_column_str(stmt, 1, res_version);
+
+ if (_pkginfo_get_res_allowed_packages(db, pkgid,
+ res_allowed_packages) != PMINFO_R_OK) {
+ sqlite3_finalize(stmt);
+ return PMINFO_R_ERROR;
+ }
+
+ sqlite3_finalize(stmt);
+
+ return PMINFO_R_OK;
+}
+
static int _pkginfo_get_packages(sqlite3 *db, uid_t uid, const char *locale,
pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
{
", COALESCE("
"(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
"(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
+ static const char query_res_type[] =
+ ", (SELECT res_type FROM package_res_info WHERE pi.package=package)";
+ static const char query_res_version[] =
+ ", (SELECT res_version FROM package_res_info WHERE pi.package=package)";
static const char query_from_clause[] = " FROM package_info as pi";
int ret = PMINFO_R_ERROR;
int idx = 0;
sizeof(query) - strlen(query) - 1);
bind_params = g_list_append(bind_params, strdup(locale));
}
+ if (flag & PMINFO_PKGINFO_GET_RES_INFO) {
+ strncat(query, query_res_type,
+ sizeof(query) - strlen(query) - 1);
+ strncat(query, query_res_version,
+ sizeof(query) - strlen(query) - 1);
+ }
strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1);
}
}
+ if (flag & PMINFO_PKGINFO_GET_RES_INFO) {
+ if (_pkginfo_get_res_info(db, info->package,
+ &info->res_type,
+ &info->res_version,
+ &info->res_allowed_packages) < 0) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ }
+ }
+
if (is_check_storage &&
__pkginfo_check_installed_storage(info) !=
PMINFO_R_OK) {
return 0;
}
+static int __insert_app_res_control(sqlite3 *db, application_x *app)
+{
+ static const char query[] =
+ "INSERT INTO package_app_res_control (app_id, res_type,"
+ " min_res_version, max_res_version, auto_close) "
+ "VALUES (?, ?, ?, ?, ?)";
+ int ret;
+ sqlite3_stmt *stmt;
+ int idx;
+ GList *tmp;
+ res_control_x *rc;
+
+ if (app->res_control == NULL)
+ return 0;
+
+ ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ return -1;
+ }
+
+ for (tmp = app->res_control; tmp; tmp = tmp->next) {
+ rc = (res_control_x *)tmp->data;
+ if (rc == NULL)
+ continue;
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, app->appid);
+ __BIND_TEXT(db, stmt, idx++, rc->res_type);
+ __BIND_TEXT(db, stmt, idx++, rc->min_res_version);
+ __BIND_TEXT(db, stmt, idx++, rc->max_res_version);
+ __BIND_TEXT(db, stmt, idx++, rc->auto_close);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
+ sqlite3_reset(stmt);
+ }
+
+ sqlite3_finalize(stmt);
+
+ return 0;
+}
+
static int __insert_package_privilege_info(sqlite3 *db, manifest_x *mfx)
{
static const char query[] =
return ret;
}
+static int __insert_package_res_info_allowed_package(sqlite3 *db,
+ const char *pkgid, GList *rap_list)
+{
+ static const char query[] =
+ "INSERT INTO package_res_allowed_package (package,"
+ " allowed_package, required_privilege) VALUES (?, ?, ?)";
+ int ret;
+ int idx;
+ sqlite3_stmt *stmt;
+ GList *tmp;
+ GList *priv_list;
+ res_allowed_package_x *rap;
+
+ if (rap_list == NULL)
+ return 0;
+
+ ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ return -1;
+ }
+
+ for (tmp = rap_list; tmp; tmp = tmp->next) {
+ rap = (res_allowed_package_x *)tmp->data;
+ if (rap == NULL)
+ continue;
+
+ if (!rap->required_privileges) {
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, pkgid);
+ __BIND_TEXT(db, stmt, idx++, rap->allowed_package);
+ __BIND_TEXT(db, stmt, idx++, NULL);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
+ sqlite3_reset(stmt);
+ continue;
+ }
+
+ for (priv_list = rap->required_privileges; priv_list;
+ priv_list = priv_list->next) {
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, pkgid);
+ __BIND_TEXT(db, stmt, idx++, rap->allowed_package);
+ __BIND_TEXT(db, stmt, idx++, (char *)priv_list->data);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
+ sqlite3_reset(stmt);
+ }
+ }
+
+ sqlite3_finalize(stmt);
+
+ return 0;
+}
+
+static int __insert_package_res_info(sqlite3 *db, manifest_x *mfx)
+{
+ static const char query[] =
+ "INSERT INTO package_res_info (package, res_type,"
+ " res_version) VALUES (?, ?, ?)";
+ int ret;
+ sqlite3_stmt *stmt;
+ int idx;
+
+ if (mfx->res_type == NULL || mfx->res_version == NULL)
+ return 0;
+
+ ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ return -1;
+ }
+
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, mfx->package);
+ __BIND_TEXT(db, stmt, idx++, mfx->res_type);
+ __BIND_TEXT(db, stmt, idx++, mfx->res_version);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
+ if (__insert_package_res_info_allowed_package(db, mfx->package,
+ mfx->res_allowed_packages) < 0) {
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
+ sqlite3_finalize(stmt);
+
+ return 0;
+}
+
static int __insert_application_info(sqlite3 *db, manifest_x *mfx)
{
static const char query[] =
sqlite3_finalize(stmt);
return -1;
}
+ if (__insert_app_res_control(db, app)) {
+ sqlite3_finalize(stmt);
+ return -1;
+ }
}
sqlite3_finalize(stmt);
return -1;
if (__insert_package_dependency_info(db, mfx))
return -1;
+ if (__insert_package_res_info(db, mfx))
+ return -1;
return 0;
}
return splashscreen;
}
+static gpointer __copy_res_control(gconstpointer src, gpointer data)
+{
+ res_control_x *tmp = (res_control_x *)src;
+ res_control_x *res_control;
+
+ res_control = (res_control_x *)calloc(1, sizeof(res_control_x));
+ if (res_control == NULL) {
+ LOGE("memory alloc failed");
+ *(int *)data = -1;
+ return NULL;
+ }
+
+ if (tmp->res_type)
+ res_control->res_type = strdup(tmp->res_type);
+ if (tmp->min_res_version)
+ res_control->min_res_version = strdup(tmp->min_res_version);
+ if (tmp->max_res_version)
+ res_control->max_res_version = strdup(tmp->max_res_version);
+ if (tmp->auto_close)
+ res_control->auto_close = strdup(tmp->auto_close);
+
+ return res_control;
+}
+
static int _appinfo_copy_appinfo(
application_x **application, application_x *data)
{
return PMINFO_R_ERROR;
}
+ ret = 0;
+ app_info->res_control = g_list_copy_deep(data->res_control, __copy_res_control, &ret);
+ if (ret < 0) {
+ LOGE("memory alloc failed");
+ pkgmgrinfo_basic_free_application(app_info);
+ return PMINFO_R_ERROR;
+ }
+
*application = app_info;
return PMINFO_R_OK;
return PMINFO_R_OK;
}
+API int pkgmgrinfo_appinfo_foreach_res_control(pkgmgrinfo_appinfo_h handle,
+ pkgmgrinfo_app_res_control_list_cb res_control_func,
+ void *user_data)
+{
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
+ retvm_if(res_control_func == NULL, PMINFO_R_EINVAL,
+ "Callback function is NULL");
+ int ret = -1;
+ res_control_x *res_control;
+ GList *tmp;
+ pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
+
+ if (info->app_info == NULL)
+ return PMINFO_R_ERROR;
+
+ for (tmp = info->app_info->res_control; tmp; tmp = tmp->next) {
+ res_control = (res_control_x *)tmp->data;
+ if (res_control == NULL)
+ continue;
+ ret = res_control_func(res_control->res_type,
+ res_control->min_res_version,
+ res_control->max_res_version,
+ res_control->auto_close,
+ user_data);
+ if (ret < 0)
+ break;
+ }
+ return PMINFO_R_OK;
+}
+
API int pkgmgrinfo_appinfo_is_nodisplay(
pkgmgrinfo_appinfo_h handle, bool *nodisplay)
{
free((void *)plugin);
}
+static void __ps_free_res_allowed_packages(gpointer data)
+{
+ res_allowed_package_x *allowed_package = (res_allowed_package_x *)data;
+
+ if (allowed_package == NULL)
+ return;
+ g_list_free_full(allowed_package->required_privileges, free);
+ free((void *)allowed_package->allowed_package);
+ free((void *)allowed_package);
+}
+
static void __ps_free_appcontrol(gpointer data)
{
appcontrol_x *appcontrol = (appcontrol_x *)data;
free((void *)dependency);
}
+static void __ps_free_res_control(gpointer data)
+{
+ res_control_x *res_control = (res_control_x *)data;
+
+ if (res_control == NULL)
+ return;
+ free((void *)res_control->res_type);
+ free((void *)res_control->min_res_version);
+ free((void *)res_control->max_res_version);
+ free((void *)res_control->auto_close);
+ free((void *)res_control);
+}
+
static void __ps_free_application(gpointer data)
{
application_x *application = (application_x *)data;
g_list_free_full(application->background_category, free);
/*Free SplashScreen*/
g_list_free_full(application->splashscreens, __ps_free_splashscreen);
+ /*Free ResControl*/
+ g_list_free_full(application->res_control, __ps_free_res_control);
free((void *)application);
}
g_list_free_full(package->dependencies, __ps_free_dependency);
/*Free Plugin execution history*/
g_list_free_full(package->plugin, __ps_free_plugin_info);
+ /*Free resource allowed packages*/
+ g_list_free_full(package->res_allowed_packages, __ps_free_res_allowed_packages);
free((void *)package);
}
return PMINFO_R_OK;
}
+API int pkgmgrinfo_pkginfo_get_res_type(pkgmgrinfo_pkginfo_h handle,
+ char **res_type)
+{
+ pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
+
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
+ retvm_if(res_type == NULL, PMINFO_R_EINVAL,
+ "Argument supplied to hold return value is NULL\n");
+
+ if (info->pkg_info == NULL)
+ return PMINFO_R_ERROR;
+
+ if (info->pkg_info->res_type == NULL)
+ return PMINFO_R_ENOENT;
+
+ *res_type = (char *)info->pkg_info->res_type;
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_pkginfo_get_res_version(pkgmgrinfo_pkginfo_h handle,
+ char **res_version)
+{
+ pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
+
+ retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
+ retvm_if(res_version == NULL, PMINFO_R_EINVAL,
+ "Argument supplied to hold return value is NULL\n");
+
+ if (info->pkg_info == NULL)
+ return PMINFO_R_ERROR;
+
+ if (info->pkg_info->res_version == NULL)
+ return PMINFO_R_ENOENT;
+
+ *res_version = (char *)info->pkg_info->res_version;
+
+ return PMINFO_R_OK;
+}
+
API int pkgmgrinfo_pkginfo_get_support_mode(pkgmgrinfo_pkginfo_h handle, int *support_mode)
{
retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
return PMINFO_R_OK;
}
+API int pkgmgrinfo_pkginfo_foreach_res_allowed_package(
+ pkgmgrinfo_pkginfo_h handle,
+ pkgmgrinfo_res_allowed_package_list_cb res_allowed_package_cb,
+ void *user_data)
+{
+ int ret;
+ pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
+ GList *res_pkgs;
+ res_allowed_package_x *res_allowed_package;
+
+ if (handle == NULL || res_allowed_package_cb == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ if (info->pkg_info == NULL)
+ return PMINFO_R_ERROR;
+
+ for (res_pkgs = info->pkg_info->res_allowed_packages; res_pkgs;
+ res_pkgs = res_pkgs->next) {
+ res_allowed_package = (res_allowed_package_x *)res_pkgs->data;
+ if (res_allowed_package == NULL)
+ continue;
+
+ ret = res_allowed_package_cb(
+ res_allowed_package->allowed_package,
+ res_allowed_package->required_privileges,
+ user_data);
+ if (ret < 0)
+ return PMINFO_R_OK;
+ }
+
+ return PMINFO_R_OK;
+}
+
+API int pkgmgrinfo_pkginfo_foreach_required_privilege(
+ required_privilege_h handle,
+ pkgmgrinfo_pkg_privilege_list_cb privilege_func,
+ void *user_data)
+{
+ int ret;
+ GList *privs;
+
+ if (privilege_func == NULL) {
+ LOGE("invalid parameter");
+ return PMINFO_R_EINVAL;
+ }
+
+ for (privs = (GList *)handle; privs; privs = privs->next) {
+ ret = privilege_func((char *)privs->data, user_data);
+ if (ret < 0)
+ return PMINFO_R_OK;
+ }
+
+ return PMINFO_R_OK;
+}
+
int __compare_package_version(const char *version, int *major,
int *minor, int *macro, int *nano)
{
{E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_NAME, PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_NAME},
{E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_EMAIL, PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_EMAIL},
{E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF, PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF},
- {E_PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE, PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE}
+ {E_PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE, PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE},
+ {E_PMINFO_PKGINFO_PROP_PACKAGE_RES_TYPE, PMINFO_PKGINFO_PROP_PACKAGE_RES_TYPE}
};
struct _pkginfo_int_map_t {
case E_PMINFO_PKGINFO_PROP_PACKAGE_SYSTEM:
snprintf(buf, sizeof(buf), "pi.package_system=? COLLATE NOCASE");
break;
-
+ case E_PMINFO_PKGINFO_PROP_PACKAGE_RES_TYPE:
+ if (node->value == NULL || strlen(node->value) == 0) {
+ *condition = strdup("package_res_info.res_type IS NOT NULL COLLATE NOCASE");
+ if (*condition == NULL) {
+ _LOGE("out of memeory");
+ return 0;
+ }
+ return E_PMINFO_PKGINFO_JOIN_RES_INFO;
+ } else {
+ snprintf(buf, sizeof(buf), "package_res_info.res_type=? COLLATE NOCASE");
+ flag = E_PMINFO_PKGINFO_JOIN_RES_INFO;
+ break;
+ }
case E_PMINFO_APPINFO_PROP_APP_ID:
snprintf(buf, sizeof(buf), "ai.app_id=?");
break;
E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_EMAIL,
E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF,
E_PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE,
- E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR = E_PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE
+ E_PMINFO_PKGINFO_PROP_PACKAGE_RES_TYPE,
+ E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR = E_PMINFO_PKGINFO_PROP_PACKAGE_RES_TYPE
} pkgmgrinfo_pkginfo_filter_prop_str;
/*Boolean properties for filtering based on package info*/
typedef enum _pkgmgrinfo_pkginfo_join_flag {
E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO = 0x0001,
E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO = 0x0002,
+ E_PMINFO_PKGINFO_JOIN_RES_INFO = 0x0004,
} pkgmgrinfo_pkginfo_join_flag;
typedef enum _pkgmgrinfo_appinfo_join_flag {
application->splashscreens =
g_list_append(application->splashscreens, splashscreen);
+ res_control_x* res_control =
+ reinterpret_cast<res_control_x*>(calloc(1, sizeof(res_control_x)));
+ res_control->res_type = strdup("test_res_type");
+ res_control->min_res_version = strdup("1.0.0");
+ res_control->max_res_version = strdup("2.0.0");
+ res_control->auto_close = strdup("true");
+ application->res_control =
+ g_list_append(application->res_control, res_control);
+
return application;
}
package->plugin = g_list_append(package->plugin, plugin);
+ res_allowed_package_x* allowed_package =
+ reinterpret_cast<res_allowed_package_x*>(calloc(1,
+ sizeof(res_allowed_package_x)));
+ allowed_package->allowed_package = strdup("test_allowed_package");
+ allowed_package->required_privileges = g_list_append(
+ allowed_package->required_privileges,
+ strdup("test_required_privilege1"));
+
+ package->res_allowed_packages =
+ g_list_append(package->res_allowed_packages, allowed_package);
+
package->application = g_list_append(package->application,
GetTestApplication("test_app1"));
package->application = g_list_append(package->application,
STR_EQ(plugin_a->plugin_type, plugin_b->plugin_type);
}
+ INT_EQ(g_list_length(packageA->res_allowed_packages),
+ g_list_length(packageB->res_allowed_packages));
+ for (GList* a = packageA->res_allowed_packages,
+ *b = packageB->res_allowed_packages; a && b; a = a->next, b = b->next) {
+ res_allowed_package_x* allowed_package_a =
+ reinterpret_cast<res_allowed_package_x*>(a->data);
+ res_allowed_package_x* allowed_package_b =
+ reinterpret_cast<res_allowed_package_x*>(b->data);
+ STR_EQ(allowed_package_a->allowed_package,
+ allowed_package_b->allowed_package);
+
+ INT_EQ(g_list_length(allowed_package_a->required_privileges),
+ g_list_length(allowed_package_b->required_privileges));
+
+ for (GList* a = allowed_package_a->required_privileges,
+ *b = allowed_package_b->required_privileges; a && b;
+ a = a->next, b = b->next) {
+ STR_EQ(reinterpret_cast<char*>(a->data),
+ reinterpret_cast<char*>(b->data));
+ }
+ }
+
INT_EQ(g_list_length(packageA->application),
g_list_length(packageB->application));
for (GList *a = packageA->application, *b = packageB->application;
projects / platform / core / appfw / pkgmgr-info.git / commitdiff