2 * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
22 #include <sys/types.h>
24 #include <sys/smack.h>
25 #include <linux/limits.h>
32 #include <tzplatform_config.h>
33 #include <system_info.h>
35 #include "pkgmgr-info.h"
36 #include "pkgmgrinfo_basic.h"
37 #include "pkgmgr_parser.h"
38 #include "pkgmgr_parser_db_queries.h"
39 #include "pkgmgr_parser_debug.h"
40 #include "pkgmgr_parser_internal.h"
46 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
49 #define APPFW_USER "app_fw"
58 #define XXHDPI "xxhdpi"
68 #define XXHDPI_MIN 481
69 #define XXHDPI_MAX 600
71 /* app background category value */
72 #define APP_BG_CATEGORY_USER_DISABLE_FALSE_VAL 0x00000
73 #define APP_BG_CATEGORY_USER_DISABLE_TRUE_VAL 0x00001
74 #define APP_BG_CATEGORY_MEDIA_VAL 0x00002
75 #define APP_BG_CATEGORY_DOWNLOAD_VAL 0x00004
76 #define APP_BG_CATEGORY_BGNETWORK_VAL 0x00008
77 #define APP_BG_CATEGORY_LOCATION_VAL 0x00010
78 #define APP_BG_CATEGORY_SENSOR_VAL 0x00020
79 #define APP_BG_CATEGORY_IOTCOMM_VAL 0x00040
80 #define APP_BG_CATEGORY_SYSTEM_VAL 0x00080
82 #define APP_BG_CATEGORY_USER_DISABLE_FALSE_STR "enable"
83 #define APP_BG_CATEGORY_USER_DISABLE_TRUE_STR "disable"
84 #define APP_BG_CATEGORY_MEDIA_STR "media"
85 #define APP_BG_CATEGORY_DOWNLOAD_STR "download"
86 #define APP_BG_CATEGORY_BGNETWORK_STR "background-network"
87 #define APP_BG_CATEGORY_LOCATION_STR "location"
88 #define APP_BG_CATEGORY_SENSOR_STR "sensor"
89 #define APP_BG_CATEGORY_IOTCOMM_STR "iot-communication"
90 #define APP_BG_CATEGORY_SYSTEM "system"
92 #define REGULAR_USER 5000
93 static inline uid_t __getuid(void)
97 if (uid < REGULAR_USER)
98 return tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
103 static const char *__get_bool(char *value, bool is_true)
106 if (!strcmp(value, ""))
107 return (is_true) ? "true" : "false";
111 return (is_true) ? "true" : "false";
114 #define __BEGIN_TRANSACTION(db) \
116 if (sqlite3_exec(db, "BEGIN EXCLUSIVE", NULL, NULL, NULL) != \
118 _LOGE("begin transaction failed: %s", sqlite3_errmsg(db)); \
119 sqlite3_close_v2(db); \
120 return PM_PARSER_R_ERROR; \
124 #define __DO_TRANSACTION(db, func) \
127 _LOGE("transaction failed: %s, rollback", sqlite3_errmsg(db)); \
128 if (sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL) != \
130 _LOGE("roll back transaction failed: %s", \
131 sqlite3_errmsg(db)); \
132 sqlite3_close_v2(db); \
133 return PM_PARSER_R_ERROR; \
137 #define __END_TRANSACTION(db) \
139 if (sqlite3_exec(db, "COMMIT", NULL, NULL, NULL) != \
141 _LOGE("commit failed: %s, rollback", sqlite3_errmsg(db)); \
142 if (sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL) != \
144 _LOGE("roll back transaction failed: %s", \
145 sqlite3_errmsg(db)); \
146 sqlite3_close_v2(db); \
147 return PM_PARSER_R_ERROR; \
151 #define __BIND_TEXT(db, stmt, i, text) \
153 if (sqlite3_bind_text(stmt, i, text, -1, SQLITE_STATIC) != SQLITE_OK) {\
154 _LOGE("bind error(index %d): %s", i, sqlite3_errmsg(db)); \
155 sqlite3_finalize(stmt); \
160 #define __BIND_INT(db, stmt, i, int) \
162 if (sqlite3_bind_int(stmt, i, int) != SQLITE_OK) { \
163 _LOGE("bind error(index %d): %s", i, sqlite3_errmsg(db)); \
164 sqlite3_finalize(stmt); \
169 static const char *__get_parser_db_path(uid_t uid)
174 if (uid == GLOBAL_USER || uid == OWNER_ROOT) {
175 path = tzplatform_mkpath(TZ_SYS_DB, ".pkgmgr_parser.db");
177 snprintf(buf, sizeof(buf), "user/%d/.pkgmgr_parser.db", uid);
178 path = tzplatform_mkpath(TZ_SYS_DB, buf);
184 static const char *__get_cert_db_path(void)
186 return tzplatform_mkpath(TZ_SYS_DB, ".pkgmgr_cert.db");
189 static int __set_db_version(sqlite3 *db)
191 static const char query_raw[] = "PRAGMA user_version=";
195 snprintf(query, sizeof(query), "%s%d", query_raw, PKG_DB_VERSION);
197 ret = sqlite3_exec(db, query, NULL, NULL, NULL);
198 if (ret != SQLITE_OK) {
199 _LOGE("exec failed: %s", sqlite3_errmsg(db));
206 /* TODO: Do not labeling directly */
207 #define DB_LABEL "User::Home"
208 #define SET_SMACK_LABEL(x) \
210 if (smack_setlabel((x), DB_LABEL, SMACK_LABEL_ACCESS)) \
211 _LOGE("failed chsmack -a %s %s", DB_LABEL, x); \
213 _LOGD("chsmack -a %s %s", DB_LABEL, x); \
216 static int __set_db_permission(const char *path, uid_t uid)
219 const char *files[2];
220 char journal_file[BUFSIZE];
224 struct passwd *result;
229 if (getuid() != OWNER_ROOT)
232 if (uid == OWNER_ROOT || uid == GLOBAL_USER) {
233 ret = getpwnam_r(APPFW_USER, &pwd, buf, sizeof(buf), &result);
234 if (result == NULL) {
236 _LOGE("no such user: %d", uid);
238 _LOGE("getpwuid_r failed: %d", errno);
244 snprintf(journal_file, sizeof(journal_file), "%s-journal", path);
246 files[1] = journal_file;
248 ret = getpwuid_r(uid, &pwd, buf, sizeof(buf), &result);
249 if (result == NULL) {
251 _LOGE("no such user: %d", uid);
253 _LOGE("getpwuid_r failed: %d", errno);
257 for (i = 0; i < 2; i++) {
258 fd = open(files[i], O_RDONLY);
260 _LOGE("open %s failed: %d", files[i], errno);
263 ret = fstat(fd, &sb);
265 _LOGE("stat %s failed: %d", files[i], errno);
269 if (S_ISLNK(sb.st_mode)) {
270 _LOGE("%s is symlink!", files[i]);
274 ret = fchown(fd, uid, pwd.pw_gid);
276 _LOGE("fchown %s failed: %d", files[i], errno);
281 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
282 if (!strcmp(path, __get_cert_db_path()))
284 ret = fchmod(fd, mode);
286 _LOGD("fchmod %s failed: %d", files[i], errno);
291 SET_SMACK_LABEL(files[i]);
297 static const char *parser_init_queries[] = {
298 QUERY_CREATE_TABLE_PACKAGE_INFO,
299 QUERY_CREATE_TABLE_PACKAGE_LOCALIZED_INFO,
300 QUERY_CREATE_TABLE_PACKAGE_PRIVILEGE_INFO,
301 QUERY_CREATE_TABLE_PACKAGE_APPDEFINED_PRIVILEGE_INFO,
302 QUERY_CREATE_TABLE_PACKAGE_UPDATE_INFO,
303 QUERY_CREATE_TABLE_PACKAGE_APP_INFO,
304 QUERY_CREATE_TABLE_PACKAGE_APP_LOCALIZED_INFO,
305 QUERY_CREATE_TABLE_PACKAGE_APP_APP_CONTROL,
306 QUERY_CREATE_TABLE_PACKAGE_APP_APP_CONTROL_PRIVILEGE,
307 QUERY_CREATE_TABLE_PACKAGE_APP_APP_CATEGORY,
308 QUERY_CREATE_TABLE_PACKAGE_APP_APP_METADATA,
309 QUERY_CREATE_TABLE_PACKAGE_APP_DATA_CONTROL,
310 QUERY_CREATE_TABLE_PACKAGE_APP_DATA_CONTROL_PRIVILEGE,
311 QUERY_CREATE_TABLE_PACKAGE_APP_INFO_FOR_UID,
312 QUERY_CREATE_TRIGGER_UPDATE_PACKAGE_APP_INFO_FOR_UID,
313 QUERY_CREATE_TABLE_PACKAGE_APP_SPLASH_SCREEN,
317 static const char *cert_init_queries[] = {
318 QUERY_CREATE_TABLE_PACKAGE_CERT_INFO,
319 QUERY_CREATE_TABLE_PACKAGE_CERT_INDEX_INFO,
320 QUERY_CREATE_TRIGGER_UPDATE_CERT_INFO,
321 QUERY_CREATE_TRIGGER_UPDATE_CERT_INFO2,
322 QUERY_CREATE_TRIGGER_DELETE_CERT_INFO,
323 QUERY_CREATE_TRIGGER_UPDATE_CERT_INDEX_INFO,
327 static int __initialize_db(sqlite3 *db, const char *dbpath, uid_t uid)
330 const char **queries;
333 if (__set_db_version(db))
336 if (strstr(dbpath, ".pkgmgr_parser.db")) {
337 queries = parser_init_queries;
338 } else if (strstr(dbpath, ".pkgmgr_cert.db")) {
339 queries = cert_init_queries;
341 _LOGE("unexpected dbpath: %s", dbpath);
345 for (i = 0; queries[i] != NULL; i++) {
346 ret = sqlite3_exec(db, queries[i], NULL, NULL, NULL);
347 if (ret != SQLITE_OK) {
348 _LOGE("exec failed: %s", sqlite3_errmsg(db));
353 if (__set_db_permission(dbpath, uid))
354 _LOGE("failed to set db permission");
359 API int pkgmgr_parser_initialize_parser_db(uid_t uid)
365 dbpath = __get_parser_db_path(uid);
366 if (access(dbpath, F_OK) != -1) {
367 _LOGE("Manifest db for user %d is already exists", uid);
368 return PM_PARSER_R_ERROR;
371 ret = sqlite3_open_v2(dbpath, &db,
372 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
373 if (ret != SQLITE_OK) {
374 _LOGE("open db failed: %d", ret);
375 return PM_PARSER_R_ERROR;
378 if (__initialize_db(db, dbpath, uid)) {
379 sqlite3_close_v2(db);
380 return PM_PARSER_R_ERROR;
382 sqlite3_close_v2(db);
384 return PM_PARSER_R_OK;
387 API int pkgmgr_parser_initialize_cert_db(void)
393 dbpath = __get_cert_db_path();
394 if (access(dbpath, F_OK) != -1) {
395 _LOGE("Cert db is already exists");
396 return PM_PARSER_R_ERROR;
399 ret = sqlite3_open_v2(dbpath, &db,
400 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
401 if (ret != SQLITE_OK) {
402 _LOGE("open db failed: %d", ret);
403 return PM_PARSER_R_ERROR;
406 if (__initialize_db(db, dbpath, GLOBAL_USER)) {
407 sqlite3_close_v2(db);
408 return PM_PARSER_R_ERROR;
410 sqlite3_close_v2(db);
412 return PM_PARSER_R_OK;
415 API int pkgmgr_parser_create_and_initialize_db(uid_t uid)
419 struct passwd *result;
422 ret = getpwnam_r(APPFW_USER, &pwd, buf, sizeof(buf), &result);
423 if (result == NULL) {
425 _LOGE("no such user: %s", APPFW_USER);
427 _LOGE("getpwnam_r failed: %d", errno);
428 return PM_PARSER_R_ERROR;
431 if (getuid() != OWNER_ROOT && getuid() != pwd.pw_uid) {
432 _LOGE("Only root or app_fw user is allowed");
433 return PM_PARSER_R_EINVAL;
436 if (pkgmgr_parser_initialize_parser_db(uid))
437 return PM_PARSER_R_ERROR;
439 if (pkgmgr_parser_initialize_cert_db())
440 return PM_PARSER_R_ERROR;
442 return PM_PARSER_R_OK;
445 #define BUSY_WAITING_USEC (1000000 / 10 / 2) /* 0.05 sec */
446 #define BUSY_WAITING_MAX 20 /* wait for max 1 sec */
447 static int __db_busy_handler(void *data, int count)
449 if (count < BUSY_WAITING_MAX) {
450 usleep(BUSY_WAITING_USEC);
453 /* sqlite3_prepare_v2 will return SQLITE_BUSY */
458 static int __open_db(uid_t uid, const char *path, sqlite3 **db, int flags)
462 /* FIXME: always open with OPEN_CREATE flag for keeping previous
465 if (flags & SQLITE_OPEN_READWRITE)
466 flags = flags | SQLITE_OPEN_CREATE;
468 ret = sqlite3_open_v2(path, db, flags, NULL);
469 if (ret != SQLITE_OK)
472 ret = sqlite3_busy_handler(*db, __db_busy_handler, NULL);
473 if (ret != SQLITE_OK) {
474 _LOGE("failed to register busy handler: %s",
475 sqlite3_errmsg(*db));
476 sqlite3_close_v2(*db);
480 if (flags & SQLITE_OPEN_CREATE) {
481 ret = __initialize_db(*db, path, uid);
483 _LOGE("failed to initialize db: %s\n");
484 sqlite3_close_v2(*db);
489 ret = sqlite3_exec(*db, "PRAGMA foreign_keys=ON", NULL, NULL, NULL);
490 if (ret != SQLITE_OK) {
491 _LOGE("failed to enable foreign key support: %s",
492 sqlite3_errmsg(*db));
493 sqlite3_close_v2(*db);
501 static int __convert_background_category(GList *category_list)
507 if (category_list == NULL)
510 for (tmp = category_list; tmp; tmp = tmp->next) {
511 category_data = (char *)tmp->data;
512 if (category_data == NULL)
514 if (!strcmp(category_data, APP_BG_CATEGORY_MEDIA_STR))
515 ret |= APP_BG_CATEGORY_MEDIA_VAL;
516 else if (!strcmp(category_data, APP_BG_CATEGORY_DOWNLOAD_STR))
517 ret |= APP_BG_CATEGORY_DOWNLOAD_VAL;
518 else if (!strcmp(category_data, APP_BG_CATEGORY_BGNETWORK_STR))
519 ret |= APP_BG_CATEGORY_BGNETWORK_VAL;
520 else if (!strcmp(category_data, APP_BG_CATEGORY_LOCATION_STR))
521 ret |= APP_BG_CATEGORY_LOCATION_VAL;
522 else if (!strcmp(category_data, APP_BG_CATEGORY_SENSOR_STR))
523 ret |= APP_BG_CATEGORY_SENSOR_VAL;
524 else if (!strcmp(category_data, APP_BG_CATEGORY_IOTCOMM_STR))
525 ret |= APP_BG_CATEGORY_IOTCOMM_VAL;
526 else if (!strcmp(category_data, APP_BG_CATEGORY_SYSTEM))
527 ret |= APP_BG_CATEGORY_SYSTEM_VAL;
529 _LOGE("Unidentified category [%s]", category_data);
535 #define EFFECTIVE_APPID_KEY "http://tizen.org/metadata/effective-appid"
536 static const char *__find_effective_appid(GList *metadata_list)
541 for (tmp = metadata_list; tmp; tmp = tmp->next) {
542 md = (metadata_x *)tmp->data;
543 if (md == NULL || md->key == NULL)
546 if (strcmp(md->key, EFFECTIVE_APPID_KEY) == 0) {
555 static int __insert_appcontrol_privilege_info(sqlite3 *db, const char *appid,
558 static const char query[] =
559 "INSERT INTO package_app_app_control_privilege (app_id,"
560 " app_control, privilege) VALUES (?, ?, ?)";
564 char app_control[BUFSIZE];
571 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
572 if (ret != SQLITE_OK) {
573 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
577 for (tmp = ac->privileges; tmp; tmp = tmp->next) {
578 privilege = (char *)tmp->data;
579 if (privilege == NULL || !strlen(privilege))
583 snprintf(app_control, sizeof(app_control), "%s|%s|%s",
584 ac->operation ? (strlen(ac->operation) > 0 ?
585 ac->operation : "NULL") : "NULL",
586 ac->uri ? (strlen(ac->uri) > 0 ?
587 ac->uri : "NULL") : "NULL",
588 ac->mime ? (strlen(ac->mime) > 0 ?
589 ac->mime : "NULL") : "NULL");
590 __BIND_TEXT(db, stmt, idx++, appid);
591 __BIND_TEXT(db, stmt, idx++, app_control);
592 __BIND_TEXT(db, stmt, idx++, privilege);
594 ret = sqlite3_step(stmt);
595 if (ret != SQLITE_DONE) {
596 _LOGE("step failed: %s", sqlite3_errmsg(db));
597 sqlite3_finalize(stmt);
604 sqlite3_finalize(stmt);
609 static int __insert_appcontrol_info(sqlite3 *db, application_x *app)
611 static const char query[] =
612 "INSERT INTO package_app_app_control (app_id, app_control) "
617 char app_control[BUFSIZE];
621 if (app->appcontrol == NULL)
624 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
625 if (ret != SQLITE_OK) {
626 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
630 for (tmp = app->appcontrol; tmp; tmp = tmp->next) {
631 ac = (appcontrol_x *)tmp->data;
635 snprintf(app_control, sizeof(app_control), "%s|%s|%s",
636 ac->operation ? (strlen(ac->operation) > 0 ?
637 ac->operation : "NULL") : "NULL",
638 ac->uri ? (strlen(ac->uri) > 0 ?
639 ac->uri : "NULL") : "NULL",
640 ac->mime ? (strlen(ac->mime) > 0 ?
641 ac->mime : "NULL") : "NULL");
642 __BIND_TEXT(db, stmt, idx++, app->appid);
643 __BIND_TEXT(db, stmt, idx++, app_control);
645 ret = sqlite3_step(stmt);
646 if (ret != SQLITE_DONE) {
647 _LOGE("step failed: %s", sqlite3_errmsg(db));
648 sqlite3_finalize(stmt);
652 if (__insert_appcontrol_privilege_info(db, app->appid, ac)) {
653 sqlite3_finalize(stmt);
660 sqlite3_finalize(stmt);
665 static int __insert_category_info(sqlite3 *db, application_x *app)
667 static const char query[] =
668 "INSERT INTO package_app_app_category (app_id, category) "
674 const char *category;
676 if (app->category == NULL)
679 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
680 if (ret != SQLITE_OK) {
681 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
685 for (tmp = app->category; tmp; tmp = tmp->next) {
686 category = (const char *)tmp->data;
687 if (category == NULL)
690 __BIND_TEXT(db, stmt, idx++, app->appid);
691 __BIND_TEXT(db, stmt, idx++, category);
693 ret = sqlite3_step(stmt);
694 if (ret != SQLITE_DONE) {
695 _LOGE("step failed: %s", sqlite3_errmsg(db));
696 sqlite3_finalize(stmt);
703 sqlite3_finalize(stmt);
708 static int __insert_metadata_info(sqlite3 *db, application_x *app)
710 static const char query[] =
711 "INSERT INTO package_app_app_metadata (app_id,"
712 " md_key, md_value) VALUES (?, ?, ?)";
719 if (app->metadata == NULL)
722 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
723 if (ret != SQLITE_OK) {
724 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
728 for (tmp = app->metadata; tmp; tmp = tmp->next) {
729 md = (metadata_x *)tmp->data;
733 __BIND_TEXT(db, stmt, idx++, app->appid);
734 __BIND_TEXT(db, stmt, idx++, md->key);
735 __BIND_TEXT(db, stmt, idx++, md->value);
737 ret = sqlite3_step(stmt);
738 if (ret != SQLITE_DONE) {
739 _LOGE("step failed: %s", sqlite3_errmsg(db));
740 sqlite3_finalize(stmt);
747 sqlite3_finalize(stmt);
752 static int __insert_app_data_control_privilege_info(sqlite3 *db,
753 datacontrol_x *datacontrol)
755 static const char query[] =
756 "INSERT INTO package_app_data_control_privilege (providerid,"
757 " privilege, type) VALUES (?, ?, ?)";
765 if (datacontrol == NULL)
768 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
769 if (ret != SQLITE_OK) {
770 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
774 for (privileges = datacontrol->privileges; privileges;
775 privileges = privileges->next) {
776 priv = (char *)privileges->data;
781 __BIND_TEXT(db, stmt, idx++, datacontrol->providerid);
782 __BIND_TEXT(db, stmt, idx++, priv);
783 __BIND_TEXT(db, stmt, idx++, datacontrol->type);
785 ret = sqlite3_step(stmt);
786 if (ret != SQLITE_DONE) {
787 _LOGE("step failed: %s", sqlite3_errmsg(db));
788 sqlite3_finalize(stmt);
795 sqlite3_finalize(stmt);
799 static int __insert_datacontrol_info(sqlite3 *db, application_x *app)
801 static const char query[] =
802 "INSERT INTO package_app_data_control (app_id, providerid,"
803 " access, type, trusted) VALUES (?, ?, ?, ?, ?)";
810 if (app->datacontrol == NULL)
813 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
814 if (ret != SQLITE_OK) {
815 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
819 for (tmp = app->datacontrol; tmp; tmp = tmp->next) {
820 dc = (datacontrol_x *)tmp->data;
824 __BIND_TEXT(db, stmt, idx++, app->appid);
825 __BIND_TEXT(db, stmt, idx++, dc->providerid);
826 __BIND_TEXT(db, stmt, idx++, dc->access);
827 __BIND_TEXT(db, stmt, idx++, dc->type);
828 __BIND_TEXT(db, stmt, idx++, dc->trusted);
830 ret = sqlite3_step(stmt);
831 if (ret != SQLITE_DONE) {
832 _LOGE("step failed: %s", sqlite3_errmsg(db));
833 sqlite3_finalize(stmt);
837 if (dc->privileges &&
838 __insert_app_data_control_privilege_info(db, dc)) {
839 sqlite3_finalize(stmt);
846 sqlite3_finalize(stmt);
851 /* TODO: move to installer */
852 static int __check_dpi(const char *dpi_char, int dpi_int)
854 if (dpi_char == NULL)
857 if (strcasecmp(dpi_char, LDPI) == 0) {
858 if (dpi_int >= LDPI_MIN && dpi_int <= LDPI_MAX)
862 } else if (strcasecmp(dpi_char, MDPI) == 0) {
863 if (dpi_int >= MDPI_MIN && dpi_int <= MDPI_MAX)
867 } else if (strcasecmp(dpi_char, HDPI) == 0) {
868 if (dpi_int >= HDPI_MIN && dpi_int <= HDPI_MAX)
872 } else if (strcasecmp(dpi_char, XHDPI) == 0) {
873 if (dpi_int >= XHDPI_MIN && dpi_int <= XHDPI_MAX)
877 } else if (strcasecmp(dpi_char, XXHDPI) == 0) {
878 if (dpi_int >= XXHDPI_MIN && dpi_int <= XXHDPI_MAX)
886 static gint __compare_splashscreen_with_orientation_dpi(gconstpointer a,
889 splashscreen_x *ss = (splashscreen_x *)a;
890 const char *orientation = (const char *)b;
894 if (ss->operation || ss->dpi == NULL)
897 ret = system_info_get_platform_int(
898 "http://tizen.org/feature/screen.dpi", &dpi);
899 if (ret != SYSTEM_INFO_ERROR_NONE)
902 if (strcasecmp(ss->orientation, orientation) == 0 &&
903 __check_dpi(ss->dpi, dpi) == 0)
909 static gint __compare_splashscreen_with_orientation(gconstpointer a,
912 splashscreen_x *ss = (splashscreen_x *)a;
913 const char *orientation = (const char *)b;
915 if (ss->operation || ss->dpi)
918 if (strcasecmp(ss->orientation, orientation) == 0)
924 static splashscreen_x *__find_default_splashscreen(GList *splashscreens,
925 const char *orientation)
929 tmp = g_list_find_custom(splashscreens, orientation,
931 __compare_splashscreen_with_orientation_dpi);
933 return (splashscreen_x *)tmp->data;
935 tmp = g_list_find_custom(splashscreens, orientation,
936 (GCompareFunc)__compare_splashscreen_with_orientation);
938 return (splashscreen_x *)tmp->data;
943 static void __find_appcontrol_splashscreen_with_dpi(gpointer data,
946 splashscreen_x *ss = (splashscreen_x *)data;
947 GList **list = (GList **)user_data;
951 if (ss->operation == NULL || ss->dpi == NULL)
954 ret = system_info_get_platform_int(
955 "http://tizen.org/feature/screen.dpi", &dpi);
956 if (ret != SYSTEM_INFO_ERROR_NONE)
959 if (__check_dpi(ss->dpi, dpi) != 0)
962 *list = g_list_append(*list, ss);
965 static void __find_appcontrol_splashscreen(gpointer data, gpointer user_data)
967 splashscreen_x *ss = (splashscreen_x *)data;
968 GList **list = (GList **)user_data;
969 splashscreen_x *ss_tmp;
972 if (ss->operation == NULL || ss->dpi)
975 for (tmp = *list; tmp; tmp = tmp->next) {
976 ss_tmp = (splashscreen_x *)tmp->data;
977 if (ss_tmp->operation
978 && strcmp(ss_tmp->operation, ss->operation) == 0
979 && strcmp(ss_tmp->orientation, ss->orientation) == 0)
983 *list = g_list_append(*list, ss);
986 static GList *__find_splashscreens(GList *splashscreens)
991 g_list_foreach(splashscreens,
992 __find_appcontrol_splashscreen_with_dpi, &list);
993 g_list_foreach(splashscreens,
994 __find_appcontrol_splashscreen, &list);
996 ss = __find_default_splashscreen(splashscreens, "portrait");
998 list = g_list_append(list, ss);
999 ss = __find_default_splashscreen(splashscreens, "landscape");
1001 list = g_list_append(list, ss);
1006 static int __insert_splashscreen_info(sqlite3 *db, application_x *app)
1008 static const char query[] =
1009 "INSERT INTO package_app_splash_screen (app_id, src, type,"
1010 " orientation, indicatordisplay, operation, color_depth) "
1011 "VALUES (?, ?, ?, ?, ?, ?, ?)";
1019 if (app->splashscreens == NULL)
1022 ss_list = __find_splashscreens(app->splashscreens);
1023 if (ss_list == NULL)
1026 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1027 if (ret != SQLITE_OK) {
1028 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1032 for (tmp = ss_list; tmp; tmp = tmp->next) {
1033 ss = (splashscreen_x *)tmp->data;
1037 __BIND_TEXT(db, stmt, idx++, app->appid);
1038 __BIND_TEXT(db, stmt, idx++, ss->src);
1039 __BIND_TEXT(db, stmt, idx++, ss->type);
1040 __BIND_TEXT(db, stmt, idx++, ss->orientation);
1041 __BIND_TEXT(db, stmt, idx++, ss->indicatordisplay);
1042 __BIND_TEXT(db, stmt, idx++, ss->operation);
1043 __BIND_TEXT(db, stmt, idx++, ss->color_depth);
1045 ret = sqlite3_step(stmt);
1046 if (ret != SQLITE_DONE) {
1047 _LOGE("step failed: %s", sqlite3_errmsg(db));
1048 sqlite3_finalize(stmt);
1052 sqlite3_reset(stmt);
1055 sqlite3_finalize(stmt);
1060 static void __trimfunc(GList *trim_list)
1064 GList *list = g_list_first(trim_list);
1067 trim_data = (char *)list->data;
1070 if (strcmp(trim_data, prev) == 0) {
1071 trim_list = g_list_remove(trim_list,
1073 list = g_list_first(trim_list);
1082 list = g_list_next(list);
1086 static gint __comparefunc(gconstpointer a, gconstpointer b, gpointer userdata)
1088 if (a == NULL || b == NULL)
1090 if (strcmp((char *)a, (char *)b) == 0)
1092 if (strcmp((char *)a, (char *)b) < 0)
1094 if (strcmp((char *)a, (char *)b) > 0)
1099 /* TODO: refactor inserting localized info */
1100 static GList *__create_locale_list(GList *lbls, GList *lcns, GList *icns,
1101 GList *dcns, GList *aths)
1103 GList *locale = NULL;
1111 for (tmp = lbls; tmp; tmp = tmp->next) {
1112 lbl = (label_x *)tmp->data;
1116 locale = g_list_insert_sorted_with_data(
1117 locale, (gpointer)lbl->lang,
1118 __comparefunc, NULL);
1120 for (tmp = lcns; tmp; tmp = tmp->next) {
1121 lcn = (license_x *)tmp->data;
1125 locale = g_list_insert_sorted_with_data(
1126 locale, (gpointer)lcn->lang,
1127 __comparefunc, NULL);
1129 for (tmp = icns; tmp; tmp = tmp->next) {
1130 icn = (icon_x *)tmp->data;
1134 locale = g_list_insert_sorted_with_data(
1135 locale, (gpointer)icn->lang,
1136 __comparefunc, NULL);
1138 for (tmp = dcns; tmp; tmp = tmp->next) {
1139 dcn = (description_x *)tmp->data;
1143 locale = g_list_insert_sorted_with_data(
1144 locale, (gpointer)dcn->lang,
1145 __comparefunc, NULL);
1147 for (tmp = aths; tmp; tmp = tmp->next) {
1148 ath = (author_x *)tmp->data;
1152 locale = g_list_insert_sorted_with_data(
1153 locale, (gpointer)ath->lang,
1154 __comparefunc, NULL);
1160 static gint __check_icon_resolution(const char *orig_icon_path,
1161 char **new_icon_path)
1165 char *icon_filename;
1166 char modified_iconpath[BUFSIZE];
1167 char icon_path[BUFSIZE];
1171 if (orig_icon_path == NULL)
1174 ret = system_info_get_platform_int(
1175 "http://tizen.org/feature/screen.dpi", &dpi);
1176 if (ret != SYSTEM_INFO_ERROR_NONE)
1179 if (dpi >= LDPI_MIN && dpi <= LDPI_MAX) {
1180 dpi_path[0] = "LDPI";
1181 dpi_path[1] = "ldpi";
1182 } else if (dpi >= MDPI_MIN && dpi <= MDPI_MAX) {
1183 dpi_path[0] = "MDPI";
1184 dpi_path[1] = "mdpi";
1185 } else if (dpi >= HDPI_MIN && dpi <= HDPI_MAX) {
1186 dpi_path[0] = "HDPI";
1187 dpi_path[1] = "hdpi";
1188 } else if (dpi >= XHDPI_MIN && dpi <= XHDPI_MAX) {
1189 dpi_path[0] = "XHDPI";
1190 dpi_path[1] = "xhdpi";
1191 } else if (dpi >= XXHDPI_MIN && dpi <= XXHDPI_MAX) {
1192 dpi_path[0] = "XXHDPI";
1193 dpi_path[1] = "xxhdpi";
1195 _LOGE("Unidentified dpi[%d]", dpi);
1199 icon_filename = strrchr(orig_icon_path, '/');
1200 if (icon_filename == NULL)
1204 strlen(orig_icon_path) - (strlen(icon_filename) - 1),
1205 "%s", orig_icon_path);
1206 for (i = 0; i < 2; i++) {
1207 snprintf(modified_iconpath, BUFSIZE - 1, "%s/%s%s",
1208 icon_path, dpi_path[i], icon_filename);
1209 if (access(modified_iconpath, F_OK) != -1) {
1210 /* if exists, return modified icon path */
1211 *new_icon_path = strdup(modified_iconpath);
1219 static gint __compare_icon(gconstpointer a, gconstpointer b)
1221 icon_x *icon = (icon_x *)a;
1224 if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
1227 if (icon->dpi != NULL)
1230 if (__check_icon_resolution(icon->text, &icon_path) == 0) {
1232 icon->text = icon_path;
1238 static gint __compare_icon_with_dpi(gconstpointer a, gconstpointer b)
1240 icon_x *icon = (icon_x *)a;
1241 int dpi = GPOINTER_TO_INT(b);
1243 if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
1246 if (icon->dpi == NULL)
1249 if (__check_dpi(icon->dpi, dpi) == 0)
1255 static gint __compare_icon_with_lang(gconstpointer a, gconstpointer b)
1257 icon_x *icon = (icon_x *)a;
1258 char *lang = (char *)b;
1261 if (icon->dpi != NULL)
1264 if (strcasecmp(icon->lang, lang) == 0) {
1265 if (strcasecmp(icon->lang, DEFAULT_LOCALE) == 0) {
1266 /* icon for no locale. check existance of
1267 * folder-hierachied default icons
1269 if (__check_icon_resolution(icon->text,
1272 icon->text = icon_path;
1281 static gint __compare_icon_with_lang_dpi(gconstpointer a, gconstpointer b)
1284 icon_x *icon = (icon_x *)a;
1285 char *lang = (char *)b;
1288 ret = system_info_get_platform_int(
1289 "http://tizen.org/feature/screen.dpi", &dpi);
1290 if (ret != SYSTEM_INFO_ERROR_NONE)
1293 if (strcasecmp(icon->lang, lang) == 0 &&
1294 __check_dpi(icon->dpi, dpi) == 0)
1300 static char *__find_icon(GList *icons, const char *lang)
1307 /* first, find icon whose locale and dpi with given lang and
1308 * system's dpi has matched
1310 tmp = g_list_find_custom(icons, lang,
1311 (GCompareFunc)__compare_icon_with_lang_dpi);
1313 icon = (icon_x *)tmp->data;
1314 return (char *)icon->text;
1317 /* if first has failed, find icon whose locale has matched */
1318 tmp = g_list_find_custom(icons, lang,
1319 (GCompareFunc)__compare_icon_with_lang);
1321 icon = (icon_x *)tmp->data;
1322 return (char *)icon->text;
1325 /* if second has failed, find icon whose dpi has matched with
1328 ret = system_info_get_platform_int(
1329 "http://tizen.org/feature/screen.dpi", &dpi);
1330 if (ret == SYSTEM_INFO_ERROR_NONE) {
1331 tmp = g_list_find_custom(icons, GINT_TO_POINTER(dpi),
1332 (GCompareFunc)__compare_icon_with_dpi);
1334 icon = (icon_x *)tmp->data;
1335 return (char *)icon->text;
1339 /* last, find default icon marked as "No Locale" */
1340 tmp = g_list_find_custom(icons, NULL, (GCompareFunc)__compare_icon);
1342 icon = (icon_x *)tmp->data;
1343 return (char *)icon->text;
1349 static void __extract_data(const char *locale, GList *lbls, GList *lcns,
1350 GList *icns, GList *dcns, GList *aths, char **label,
1351 char **license, char **icon, char **description, char **author)
1359 for (tmp = lbls; tmp; tmp = tmp->next) {
1360 lbl = (label_x *)tmp->data;
1364 if (strcmp(lbl->lang, locale) == 0) {
1365 *label = (char *)lbl->text;
1370 for (tmp = lcns; tmp; tmp = tmp->next) {
1371 lcn = (license_x *)tmp->data;
1375 if (strcmp(lcn->lang, locale) == 0) {
1376 *license = (char *)lcn->text;
1382 *icon = __find_icon(icns, locale);
1384 for (tmp = dcns; tmp; tmp = tmp->next) {
1385 dcn = (description_x *)tmp->data;
1389 if (strcmp(dcn->lang, locale) == 0) {
1390 *description = (char *)dcn->text;
1395 for (tmp = aths; tmp; tmp = tmp->next) {
1396 ath = (author_x *)tmp->data;
1400 if (strcmp(ath->lang, locale) == 0) {
1401 *author = (char *)ath->text;
1408 static int __insert_mainapp_localized_info(sqlite3 *db, application_x *app,
1409 const char *locale, const char *label, const char *icon)
1411 static const char query[] =
1412 "INSERT OR REPLACE INTO package_localized_info ("
1413 " package, package_locale, package_label, package_icon,"
1414 " package_description, package_license, package_author) "
1416 " COALESCE((SELECT package_label FROM package_localized_info"
1417 " WHERE package=? AND package_locale=?), ?),"
1418 " COALESCE((SELECT package_icon FROM package_localized_info"
1419 " WHERE package=? AND package_icon=?), ?),"
1420 " (SELECT package_description FROM package_localized_info"
1421 " WHERE package=? AND package_locale=?),"
1422 " (SELECT package_description FROM package_localized_info"
1423 " WHERE package=? AND package_locale=?),"
1424 " (SELECT package_description FROM package_localized_info"
1425 " WHERE package=? AND package_locale=?))";
1430 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1431 if (ret != SQLITE_OK) {
1432 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1436 __BIND_TEXT(db, stmt, idx++, app->package);
1437 __BIND_TEXT(db, stmt, idx++, locale);
1438 __BIND_TEXT(db, stmt, idx++, app->package);
1439 __BIND_TEXT(db, stmt, idx++, locale);
1440 __BIND_TEXT(db, stmt, idx++, label);
1441 __BIND_TEXT(db, stmt, idx++, app->package);
1442 __BIND_TEXT(db, stmt, idx++, locale);
1443 __BIND_TEXT(db, stmt, idx++, icon);
1444 __BIND_TEXT(db, stmt, idx++, app->package);
1445 __BIND_TEXT(db, stmt, idx++, locale);
1446 __BIND_TEXT(db, stmt, idx++, app->package);
1447 __BIND_TEXT(db, stmt, idx++, locale);
1448 __BIND_TEXT(db, stmt, idx++, app->package);
1449 __BIND_TEXT(db, stmt, idx++, locale);
1451 ret = sqlite3_step(stmt);
1452 if (ret != SQLITE_DONE) {
1453 _LOGE("step failed: %s", sqlite3_errmsg(db));
1454 sqlite3_finalize(stmt);
1458 sqlite3_finalize(stmt);
1463 static int __insert_app_localized_info(sqlite3 *db, application_x *app)
1465 static const char query[] =
1466 "INSERT INTO package_app_localized_info (app_id, app_locale,"
1467 " app_label, app_icon) "
1468 "VALUES (?, ?, ?, ?)";
1478 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1479 if (ret != SQLITE_OK) {
1480 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1484 locales = __create_locale_list(app->label, NULL, app->icon, NULL, NULL);
1485 for (tmp = locales; tmp; tmp = tmp->next) {
1486 locale = (const char *)tmp->data;
1489 __extract_data(locale, app->label, NULL, app->icon, NULL, NULL,
1490 &label, NULL, &icon, NULL, NULL);
1491 if (!label && !icon)
1495 __BIND_TEXT(db, stmt, idx++, app->appid);
1496 __BIND_TEXT(db, stmt, idx++, locale);
1497 __BIND_TEXT(db, stmt, idx++, label);
1498 __BIND_TEXT(db, stmt, idx++, icon);
1500 ret = sqlite3_step(stmt);
1501 if (ret != SQLITE_DONE) {
1502 _LOGE("step failed: %s", sqlite3_errmsg(db));
1503 g_list_free(locales);
1504 sqlite3_finalize(stmt);
1508 sqlite3_reset(stmt);
1510 if (strcasecmp(app->mainapp, "true") == 0) {
1511 if (__insert_mainapp_localized_info(db, app, locale,
1513 _LOGE("insert mainapp localized info failed");
1517 g_list_free(locales);
1518 sqlite3_finalize(stmt);
1523 static int __insert_package_privilege_info(sqlite3 *db, manifest_x *mfx)
1525 static const char query[] =
1526 "INSERT INTO package_privilege_info (package, privilege, type) "
1534 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1535 if (ret != SQLITE_OK) {
1536 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1540 for (tmp = mfx->privileges; tmp; tmp = tmp->next) {
1541 priv = (privilege_x *)tmp->data;
1546 __BIND_TEXT(db, stmt, idx++, mfx->package);
1547 __BIND_TEXT(db, stmt, idx++, priv->value);
1548 __BIND_TEXT(db, stmt, idx++, priv->type);
1550 ret = sqlite3_step(stmt);
1551 if (ret != SQLITE_DONE) {
1552 _LOGE("step failed: %s", sqlite3_errmsg(db));
1553 sqlite3_finalize(stmt);
1556 sqlite3_reset(stmt);
1559 sqlite3_finalize(stmt);
1564 static int __insert_package_appdefined_privilege_info(sqlite3 *db,
1567 static const char query[] =
1568 "INSERT INTO package_appdefined_privilege_info "
1569 "(package, privilege, license, type) "
1570 "VALUES (?, ?, ?, ?)";
1575 appdefined_privilege_x *priv;
1577 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1578 if (ret != SQLITE_OK) {
1579 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1583 for (tmp = mfx->appdefined_privileges; tmp; tmp = tmp->next) {
1584 priv = (appdefined_privilege_x *)tmp->data;
1589 __BIND_TEXT(db, stmt, idx++, mfx->package);
1590 __BIND_TEXT(db, stmt, idx++, priv->value);
1591 __BIND_TEXT(db, stmt, idx++, priv->license);
1592 __BIND_TEXT(db, stmt, idx++, priv->type);
1594 ret = sqlite3_step(stmt);
1595 if (ret != SQLITE_DONE) {
1596 _LOGE("step failed: %s", sqlite3_errmsg(db));
1597 sqlite3_finalize(stmt);
1600 sqlite3_reset(stmt);
1603 sqlite3_finalize(stmt);
1608 /* _PRODUCT_LAUNCHING_ENHANCED_
1609 * app->indicatordisplay, app->portraitimg, app->landscapeimg,
1610 * app->guestmode_appstatus
1612 static int __insert_application_info(sqlite3 *db, manifest_x *mfx)
1614 static const char query[] =
1615 "INSERT INTO package_app_info (app_id, app_component,"
1616 " app_exec, app_nodisplay, app_type, app_onboot, app_multiple,"
1617 " app_autorestart, app_taskmanage, app_hwacceleration,"
1618 " app_screenreader, app_mainapp, app_recentimage,"
1619 " app_launchcondition, app_indicatordisplay, app_portraitimg,"
1620 " app_landscapeimg, app_guestmodevisibility,"
1621 " app_permissiontype, app_preload, app_submode,"
1622 " app_submode_mainid, app_installed_storage, app_process_pool,"
1623 " app_launch_mode, app_ui_gadget, app_support_mode,"
1624 " app_support_disable, component_type, package, app_tep_name,"
1625 " app_zip_mount_file, app_background_category,"
1626 " app_package_type, app_root_path, app_api_version,"
1627 " app_effective_appid, app_splash_screen_display,"
1628 " app_package_system, app_removable,"
1629 " app_package_installed_time, app_support_ambient,"
1630 " app_setup_appid) "
1632 " ?, LOWER(?), ?, LOWER(?), LOWER(?),"
1633 " LOWER(?), LOWER(?), ?,"
1637 " ?, LOWER(?), LOWER(?),"
1639 " COALESCE(?, 'single'), LOWER(?), ?,"
1640 " LOWER(?), ?, ?, ?,"
1644 " LOWER(?), LOWER(?),"
1653 const char *effective_appid;
1655 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1656 if (ret != SQLITE_OK) {
1657 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1661 for (tmp = mfx->application; tmp; tmp = tmp->next) {
1662 app = (application_x *)tmp->data;
1666 bg_category = __convert_background_category(
1667 app->background_category);
1668 effective_appid = __find_effective_appid(app->metadata);
1671 __BIND_TEXT(db, stmt, idx++, app->appid);
1672 __BIND_TEXT(db, stmt, idx++, app->component_type);
1673 __BIND_TEXT(db, stmt, idx++, app->exec);
1674 __BIND_TEXT(db, stmt, idx++, __get_bool(app->nodisplay, false));
1675 __BIND_TEXT(db, stmt, idx++, app->type);
1676 __BIND_TEXT(db, stmt, idx++, __get_bool(app->onboot, false));
1677 __BIND_TEXT(db, stmt, idx++, __get_bool(app->multiple, false));
1678 __BIND_TEXT(db, stmt, idx++,
1679 __get_bool(app->autorestart, false));
1680 __BIND_TEXT(db, stmt, idx++,
1681 __get_bool(app->taskmanage, false));
1682 __BIND_TEXT(db, stmt, idx++, app->hwacceleration);
1683 __BIND_TEXT(db, stmt, idx++, app->screenreader);
1684 __BIND_TEXT(db, stmt, idx++, __get_bool(app->mainapp, false));
1685 __BIND_TEXT(db, stmt, idx++, app->recentimage);
1686 __BIND_TEXT(db, stmt, idx++, app->launchcondition);
1687 __BIND_TEXT(db, stmt, idx++,
1688 __get_bool(app->indicatordisplay, true));
1689 __BIND_TEXT(db, stmt, idx++, app->portraitimg);
1690 __BIND_TEXT(db, stmt, idx++, app->landscapeimg);
1691 __BIND_TEXT(db, stmt, idx++,
1692 __get_bool(app->guestmode_visibility, true));
1693 __BIND_TEXT(db, stmt, idx++, app->permission_type);
1694 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->preload, false));
1695 __BIND_TEXT(db, stmt, idx++, __get_bool(app->submode, false));
1696 __BIND_TEXT(db, stmt, idx++, app->submode_mainid);
1697 __BIND_TEXT(db, stmt, idx++, mfx->installed_storage);
1698 __BIND_TEXT(db, stmt, idx++,
1699 __get_bool(app->process_pool, false));
1700 __BIND_TEXT(db, stmt, idx++, app->launch_mode);
1701 __BIND_TEXT(db, stmt, idx++, __get_bool(app->ui_gadget, false));
1702 __BIND_TEXT(db, stmt, idx++, app->support_mode);
1703 __BIND_TEXT(db, stmt, idx++,
1704 __get_bool(mfx->support_disable, false));
1705 __BIND_TEXT(db, stmt, idx++, app->component_type);
1706 __BIND_TEXT(db, stmt, idx++, mfx->package);
1707 __BIND_TEXT(db, stmt, idx++, mfx->tep_name);
1708 __BIND_TEXT(db, stmt, idx++, mfx->zip_mount_file);
1709 __BIND_INT(db, stmt, idx++, bg_category);
1710 __BIND_TEXT(db, stmt, idx++, mfx->type ? mfx->type : "tpk");
1711 __BIND_TEXT(db, stmt, idx++, mfx->root_path);
1712 __BIND_TEXT(db, stmt, idx++, mfx->api_version);
1713 __BIND_TEXT(db, stmt, idx++, effective_appid);
1714 __BIND_TEXT(db, stmt, idx++,
1715 __get_bool(app->splash_screen_display, true));
1716 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
1717 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, false));
1718 __BIND_TEXT(db, stmt, idx++, mfx->installed_time);
1719 __BIND_TEXT(db, stmt, idx++,
1720 __get_bool(app->support_ambient, false));
1721 __BIND_TEXT(db, stmt, idx++, app->setup_appid);
1723 ret = sqlite3_step(stmt);
1724 if (ret != SQLITE_DONE) {
1725 _LOGE("step failed: %s", sqlite3_errmsg(db));
1726 sqlite3_finalize(stmt);
1730 sqlite3_reset(stmt);
1732 if (__insert_appcontrol_info(db, app)) {
1733 sqlite3_finalize(stmt);
1736 if (__insert_category_info(db, app)) {
1737 sqlite3_finalize(stmt);
1740 if (__insert_metadata_info(db, app)) {
1741 sqlite3_finalize(stmt);
1744 if (__insert_datacontrol_info(db, app)) {
1745 sqlite3_finalize(stmt);
1748 if (__insert_splashscreen_info(db, app)) {
1749 sqlite3_finalize(stmt);
1752 if (__insert_app_localized_info(db, app)) {
1753 sqlite3_finalize(stmt);
1758 sqlite3_finalize(stmt);
1763 static int __insert_package_update_info(sqlite3 *db, manifest_x *mfx)
1765 static const char query[] =
1766 "INSERT INTO package_update_info (package, update_version) "
1772 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1773 if (ret != SQLITE_OK) {
1774 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1779 __BIND_TEXT(db, stmt, idx++, mfx->package);
1780 __BIND_TEXT(db, stmt, idx, mfx->version);
1781 ret = sqlite3_step(stmt);
1782 if (ret != SQLITE_DONE) {
1783 _LOGE("step failed: %s", sqlite3_errmsg(db));
1784 sqlite3_finalize(stmt);
1787 sqlite3_finalize(stmt);
1792 static int __insert_package_localized_info(sqlite3 *db, manifest_x *mfx)
1794 static const char query[] =
1795 "INSERT INTO package_localized_info (package, package_locale,"
1796 " package_label, package_icon, package_description,"
1797 " package_license, package_author) "
1798 "VALUES (?, ?, ?, ?, ?, ?, ?)";
1811 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1812 if (ret != SQLITE_OK) {
1813 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1817 locales = __create_locale_list(mfx->label, mfx->license, mfx->icon,
1818 mfx->description, mfx->author);
1819 for (tmp = locales; tmp; tmp = tmp->next) {
1820 locale = (const char *)tmp->data;
1826 __extract_data(locale, mfx->label, mfx->license, mfx->icon,
1827 mfx->description, mfx->author,
1828 &label, &license, &icon, &description, &author);
1829 if (!label && !license && !icon && !description && !author)
1833 __BIND_TEXT(db, stmt, idx++, mfx->package);
1834 __BIND_TEXT(db, stmt, idx++, locale);
1835 __BIND_TEXT(db, stmt, idx++, label);
1836 __BIND_TEXT(db, stmt, idx++, icon);
1837 __BIND_TEXT(db, stmt, idx++, description);
1838 __BIND_TEXT(db, stmt, idx++, license);
1839 __BIND_TEXT(db, stmt, idx++, author);
1841 ret = sqlite3_step(stmt);
1842 if (ret != SQLITE_DONE) {
1843 _LOGE("step failed: %s", sqlite3_errmsg(db));
1844 g_list_free(locales);
1845 sqlite3_finalize(stmt);
1849 sqlite3_reset(stmt);
1852 g_list_free(locales);
1853 sqlite3_finalize(stmt);
1858 static int __insert_package_info(sqlite3 *db, manifest_x *mfx)
1860 static const char query[] =
1861 "INSERT INTO package_info (package, package_type,"
1862 " package_version, package_api_version, package_tep_name,"
1863 " package_zip_mount_file, install_location, package_size,"
1864 " package_removable, package_preload, package_readonly,"
1865 " package_update, package_appsetting, package_nodisplay,"
1866 " package_system, author_name, author_email, author_href,"
1867 " installed_time, installed_storage, storeclient_id,"
1868 " mainapp_id, package_url, root_path, external_path,"
1869 " csc_path, package_support_mode, package_support_disable) "
1873 " LOWER(?), LOWER(?), LOWER(?),"
1874 " LOWER(?), LOWER(?), LOWER(?),"
1875 " LOWER(?), ?, ?, ?,"
1882 const char *author_name = NULL;
1883 const char *author_email = NULL;
1884 const char *author_href = NULL;
1886 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1887 if (ret != SQLITE_OK) {
1888 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1892 if (mfx->author && mfx->author->data) {
1893 author_name = ((author_x *)mfx->author->data)->text;
1894 author_email = ((author_x *)mfx->author->data)->email;
1895 author_href = ((author_x *)mfx->author->data)->href;
1898 __BIND_TEXT(db, stmt, idx++, mfx->package);
1899 __BIND_TEXT(db, stmt, idx++, mfx->type);
1900 __BIND_TEXT(db, stmt, idx++, mfx->version);
1901 __BIND_TEXT(db, stmt, idx++, mfx->api_version);
1902 __BIND_TEXT(db, stmt, idx++, mfx->tep_name);
1903 __BIND_TEXT(db, stmt, idx++, mfx->zip_mount_file);
1904 __BIND_TEXT(db, stmt, idx++, mfx->installlocation);
1905 __BIND_TEXT(db, stmt, idx++, mfx->package_size);
1906 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, true));
1907 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->preload, false));
1908 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->readonly, false));
1909 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->update, false));
1910 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->appsetting, false));
1911 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->nodisplay_setting, false));
1912 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
1913 __BIND_TEXT(db, stmt, idx++, author_name);
1914 __BIND_TEXT(db, stmt, idx++, author_email);
1915 __BIND_TEXT(db, stmt, idx++, author_href);
1916 __BIND_TEXT(db, stmt, idx++, mfx->installed_time);
1917 __BIND_TEXT(db, stmt, idx++, mfx->installed_storage);
1918 __BIND_TEXT(db, stmt, idx++, mfx->storeclient_id);
1919 __BIND_TEXT(db, stmt, idx++, mfx->mainapp_id);
1920 __BIND_TEXT(db, stmt, idx++, mfx->package_url);
1921 __BIND_TEXT(db, stmt, idx++, mfx->root_path);
1922 __BIND_TEXT(db, stmt, idx++, mfx->external_path);
1923 __BIND_TEXT(db, stmt, idx++, mfx->csc_path);
1924 __BIND_TEXT(db, stmt, idx++, mfx->support_mode);
1925 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->support_disable, false));
1927 ret = sqlite3_step(stmt);
1928 if (ret != SQLITE_DONE) {
1929 _LOGE("step failed: %s", sqlite3_errmsg(db));
1930 sqlite3_finalize(stmt);
1934 sqlite3_finalize(stmt);
1936 if (__insert_package_update_info(db, mfx))
1938 if (__insert_package_localized_info(db, mfx))
1940 if (__insert_application_info(db, mfx))
1942 if (__insert_package_privilege_info(db, mfx))
1944 if (__insert_package_appdefined_privilege_info(db, mfx))
1950 API int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
1957 _LOGE("invalid parameter");
1958 return PM_PARSER_R_EINVAL;
1961 dbpath = __get_parser_db_path(uid);
1963 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
1964 if (ret != SQLITE_OK) {
1965 _LOGE("open db failed: %d", ret);
1966 return PM_PARSER_R_ERROR;
1969 __BEGIN_TRANSACTION(db);
1970 __DO_TRANSACTION(db, __insert_package_info(db, mfx));
1971 __END_TRANSACTION(db);
1973 sqlite3_close_v2(db);
1975 return PM_PARSER_R_OK;
1978 API int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx)
1980 return pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, __getuid());
1983 static int __delete_package_info(sqlite3 *db, const char *pkgid)
1985 static const char query[] =
1986 "DELETE FROM package_info WHERE package=?";
1990 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1991 if (ret != SQLITE_OK) {
1992 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1996 __BIND_TEXT(db, stmt, 1, pkgid);
1998 ret = sqlite3_step(stmt);
1999 if (ret != SQLITE_DONE) {
2000 _LOGE("step failed: %s", sqlite3_errmsg(db));
2001 sqlite3_finalize(stmt);
2005 sqlite3_finalize(stmt);
2010 API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx,
2018 _LOGE("invalid parameter");
2019 return PM_PARSER_R_EINVAL;
2022 dbpath = __get_parser_db_path(uid);
2024 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2025 if (ret != SQLITE_OK) {
2026 _LOGE("open db failed: %d", ret);
2027 return PM_PARSER_R_ERROR;
2030 __BEGIN_TRANSACTION(db);
2031 __DO_TRANSACTION(db, __delete_package_info(db, mfx->package));
2032 __END_TRANSACTION(db);
2034 sqlite3_close_v2(db);
2036 return PM_PARSER_R_OK;
2039 API int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx)
2041 return pkgmgr_parser_delete_manifest_info_from_usr_db(mfx, __getuid());
2044 API int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
2051 _LOGE("invalid parameter");
2052 return PM_PARSER_R_EINVAL;
2055 dbpath = __get_parser_db_path(uid);
2057 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2058 if (ret != SQLITE_OK) {
2059 _LOGE("open db failed: %d", ret);
2060 return PM_PARSER_R_ERROR;
2063 __BEGIN_TRANSACTION(db);
2064 __DO_TRANSACTION(db, __delete_package_info(db, mfx->package));
2065 __DO_TRANSACTION(db, __insert_package_info(db, mfx));
2066 __END_TRANSACTION(db);
2068 sqlite3_close_v2(db);
2070 return PM_PARSER_R_OK;
2073 API int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx)
2075 return pkgmgr_parser_update_manifest_info_in_usr_db(mfx, __getuid());
2078 static int __set_global_app_disable_for_uid(sqlite3 *db, const char *appid,
2079 uid_t uid, bool is_disable)
2081 static const char query[] =
2082 "INSERT OR REPLACE INTO package_app_info_for_uid ("
2083 " app_id, uid, is_disabled, is_splash_screen_enabled) "
2085 " (SELECT app_splash_screen_display FROM package_app_info"
2086 " WHERE app_id=?))";
2091 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2092 if (ret != SQLITE_OK) {
2093 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2097 __BIND_TEXT(db, stmt, idx++, appid);
2098 __BIND_INT(db, stmt, idx++, uid);
2099 __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false");
2100 __BIND_TEXT(db, stmt, idx++, appid);
2102 ret = sqlite3_step(stmt);
2103 if (ret != SQLITE_DONE) {
2104 _LOGE("step failed: %s", sqlite3_errmsg(db));
2105 sqlite3_finalize(stmt);
2109 sqlite3_finalize(stmt);
2114 API int pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
2115 const char *appid, uid_t uid, int is_disable)
2121 if (appid == NULL) {
2122 _LOGE("invalid parameter");
2123 return PM_PARSER_R_EINVAL;
2126 dbpath = __get_parser_db_path(GLOBAL_USER);
2128 ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE);
2129 if (ret != SQLITE_OK) {
2130 _LOGE("open db failed: %d", ret);
2131 return PM_PARSER_R_ERROR;
2134 __BEGIN_TRANSACTION(db);
2135 __DO_TRANSACTION(db, __set_global_app_disable_for_uid(db, appid,
2136 uid, (bool)is_disable));
2137 __END_TRANSACTION(db);
2139 sqlite3_close_v2(db);
2141 return PM_PARSER_R_OK;
2144 static int __set_app_disable(sqlite3 *db, const char *appid, uid_t uid,
2147 static const char query[] =
2148 "UPDATE package_app_info SET app_disable=? "
2154 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2155 if (ret != SQLITE_OK) {
2156 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2160 __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false");
2161 __BIND_TEXT(db, stmt, idx++, appid);
2163 ret = sqlite3_step(stmt);
2164 if (ret != SQLITE_DONE) {
2165 _LOGE("step failed: %s", sqlite3_errmsg(db));
2166 sqlite3_finalize(stmt);
2170 sqlite3_finalize(stmt);
2175 API int pkgmgr_parser_update_app_disable_info_in_usr_db(const char *appid,
2176 uid_t uid, int is_disable)
2182 if (appid == NULL) {
2183 _LOGE("invalid parameter");
2184 return PM_PARSER_R_EINVAL;
2187 dbpath = __get_parser_db_path(uid);
2189 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2190 if (ret != SQLITE_OK) {
2191 _LOGE("open db failed: %d", ret);
2192 return PM_PARSER_R_ERROR;
2195 __BEGIN_TRANSACTION(db);
2196 __DO_TRANSACTION(db, __set_app_disable(db, appid, uid,
2198 __END_TRANSACTION(db);
2200 sqlite3_close_v2(db);
2202 return PM_PARSER_R_OK;
2205 API int pkgmgr_parser_update_app_disable_info_in_db(const char *appid,
2208 return pkgmgr_parser_update_app_disable_info_in_usr_db(appid,
2209 __getuid(), is_disable);
2212 static int __set_pkg_disable(sqlite3 *db, const char *pkgid, uid_t uid,
2215 static const char query[] =
2216 "UPDATE package_info SET package_disable=? "
2222 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2223 if (ret != SQLITE_OK) {
2224 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2228 __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false");
2229 __BIND_TEXT(db, stmt, idx++, pkgid);
2231 ret = sqlite3_step(stmt);
2232 if (ret != SQLITE_DONE) {
2233 _LOGE("step failed: %s", sqlite3_errmsg(db));
2234 sqlite3_finalize(stmt);
2238 sqlite3_finalize(stmt);
2243 API int pkgmgr_parser_update_pkg_disable_info_in_usr_db(const char *pkgid,
2244 uid_t uid, int is_disable)
2250 if (pkgid == NULL) {
2251 _LOGE("invalid parameter");
2252 return PM_PARSER_R_EINVAL;
2255 dbpath = __get_parser_db_path(uid);
2257 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2258 if (ret != SQLITE_OK) {
2259 _LOGE("open db failed: %d", ret);
2260 return PM_PARSER_R_ERROR;
2263 __BEGIN_TRANSACTION(db);
2264 __DO_TRANSACTION(db, __set_pkg_disable(db, pkgid, uid,
2266 __END_TRANSACTION(db);
2268 sqlite3_close_v2(db);
2270 return PM_PARSER_R_OK;
2273 API int pkgmgr_parser_update_pkg_disable_info_in_db(const char *pkgid,
2276 return pkgmgr_parser_update_pkg_disable_info_in_usr_db(pkgid,
2277 __getuid(), is_disable);
2280 static int __set_global_app_splash_screen_for_uid(sqlite3 *db,
2281 const char *appid, uid_t uid, bool is_enabled)
2283 static const char query[] =
2284 "INSERT OR REPLACE INTO package_app_info_for_uid("
2285 " appid, uid, is_splash_screen_enabled) "
2291 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2292 if (ret != SQLITE_OK) {
2293 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2297 __BIND_TEXT(db, stmt, idx++, appid);
2298 __BIND_INT(db, stmt, idx++, uid);
2299 __BIND_TEXT(db, stmt, idx++, is_enabled ? "true" : "false");
2301 ret = sqlite3_step(stmt);
2302 if (ret != SQLITE_DONE) {
2303 _LOGE("step failed: %s", sqlite3_errmsg(db));
2304 sqlite3_finalize(stmt);
2308 sqlite3_finalize(stmt);
2313 API int pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(
2314 const char *appid, uid_t uid, int flag)
2320 if (appid == NULL) {
2321 _LOGE("invalid parameter");
2322 return PM_PARSER_R_EINVAL;
2325 dbpath = __get_parser_db_path(GLOBAL_USER);
2327 ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE);
2328 if (ret != SQLITE_OK) {
2329 _LOGE("open db failed: %d", ret);
2330 return PM_PARSER_R_ERROR;
2333 __BEGIN_TRANSACTION(db);
2334 __DO_TRANSACTION(db, __set_global_app_splash_screen_for_uid(db,
2335 appid, uid, (bool)flag));
2336 __END_TRANSACTION(db);
2338 sqlite3_close_v2(db);
2340 return PM_PARSER_R_OK;
2343 static int __set_app_splash_screen(sqlite3 *db, const char *appid,
2346 static const char query[] =
2347 "UPDATE package_app_info SET app_splash_screen_display=? "
2353 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2354 if (ret != SQLITE_OK) {
2355 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2359 __BIND_TEXT(db, stmt, idx++, is_enabled ? "true" : "false");
2360 __BIND_TEXT(db, stmt, idx++, appid);
2362 ret = sqlite3_step(stmt);
2363 if (ret != SQLITE_DONE) {
2364 _LOGE("step failed: %s", sqlite3_errmsg(db));
2365 sqlite3_finalize(stmt);
2369 sqlite3_finalize(stmt);
2374 API int pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
2375 const char *appid, uid_t uid, int flag)
2381 if (appid == NULL) {
2382 _LOGE("invalid parameter");
2383 return PM_PARSER_R_EINVAL;
2386 dbpath = __get_parser_db_path(uid);
2388 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2389 if (ret != SQLITE_OK) {
2390 _LOGE("open db failed: %d", ret);
2391 return PM_PARSER_R_ERROR;
2394 __BEGIN_TRANSACTION(db);
2395 __DO_TRANSACTION(db, __set_app_splash_screen(db, appid, (bool)flag));
2396 __END_TRANSACTION(db);
2398 sqlite3_close_v2(db);
2400 return PM_PARSER_R_OK;
2403 API int pkgmgr_parser_update_app_splash_screen_display_info_in_db(
2404 const char *appid, int flag)
2406 return pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
2407 appid, __getuid(), flag);
2410 static int __set_app_label(sqlite3 *db, const char *appid, const char *label)
2412 static const char query[] =
2413 "UPDATE package_app_localized_info SET app_label=? "
2414 "WHERE app_id=? AND app_label IS NOT NULL";
2419 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2420 if (ret != SQLITE_OK) {
2421 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2425 __BIND_TEXT(db, stmt, idx++, label);
2426 __BIND_TEXT(db, stmt, idx++, appid);
2428 ret = sqlite3_step(stmt);
2429 if (ret != SQLITE_DONE) {
2430 _LOGE("step failed: %s", sqlite3_errmsg(db));
2431 sqlite3_finalize(stmt);
2435 sqlite3_finalize(stmt);
2440 API int pkgmgr_parser_update_app_label_info_in_usr_db(const char *appid,
2441 uid_t uid, const char *label)
2447 if (appid == NULL) {
2448 _LOGE("invalid parameter");
2449 return PM_PARSER_R_EINVAL;
2452 dbpath = __get_parser_db_path(uid);
2454 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2455 if (ret != SQLITE_OK) {
2456 _LOGE("open db failed: %d", ret);
2457 return PM_PARSER_R_ERROR;
2460 __BEGIN_TRANSACTION(db);
2461 __DO_TRANSACTION(db, __set_app_label(db, appid, label));
2462 __END_TRANSACTION(db);
2464 sqlite3_close_v2(db);
2466 return PM_PARSER_R_OK;
2469 API int pkgmgr_parser_update_app_label_info_in_db(const char *appid,
2472 return pkgmgr_parser_update_app_label_info_in_usr_db(appid, __getuid(),
2476 static int __set_app_icon(sqlite3 *db, const char *appid, const char *icon_path)
2478 static const char query[] =
2479 "UPDATE package_app_localized_info SET app_icon=? "
2480 "WHERE app_id=? AND app_icon IS NOT NULL";
2485 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2486 if (ret != SQLITE_OK) {
2487 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2491 __BIND_TEXT(db, stmt, idx++, icon_path);
2492 __BIND_TEXT(db, stmt, idx++, appid);
2494 ret = sqlite3_step(stmt);
2495 if (ret != SQLITE_DONE) {
2496 _LOGE("step failed: %s", sqlite3_errmsg(db));
2497 sqlite3_finalize(stmt);
2501 sqlite3_finalize(stmt);
2506 API int pkgmgr_parser_update_app_icon_info_in_usr_db(const char *appid,
2507 uid_t uid, const char *icon_path)
2513 if (appid == NULL) {
2514 _LOGE("invalid parameter");
2515 return PM_PARSER_R_EINVAL;
2518 dbpath = __get_parser_db_path(uid);
2520 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2521 if (ret != SQLITE_OK) {
2522 _LOGE("open db failed: %d", ret);
2523 return PM_PARSER_R_ERROR;
2526 __BEGIN_TRANSACTION(db);
2527 __DO_TRANSACTION(db, __set_app_icon(db, appid, icon_path));
2528 __END_TRANSACTION(db);
2530 sqlite3_close_v2(db);
2532 return PM_PARSER_R_OK;
2535 API int pkgmgr_parser_update_app_icon_info_in_db(const char *appid,
2536 const char *icon_path)
2538 return pkgmgr_parser_update_app_icon_info_in_usr_db(appid, __getuid(),
2542 static int __set_tep_path(sqlite3 *db, const char *pkgid, const char *tep_path)
2544 static const char query[] =
2545 "UPDATE package_info SET package_tep_name=? "
2551 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2552 if (ret != SQLITE_OK) {
2553 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2557 __BIND_TEXT(db, stmt, idx++, tep_path);
2558 __BIND_TEXT(db, stmt, idx++, pkgid);
2560 ret = sqlite3_step(stmt);
2561 if (ret != SQLITE_DONE) {
2562 _LOGE("step failed: %s", sqlite3_errmsg(db));
2563 sqlite3_finalize(stmt);
2567 sqlite3_finalize(stmt);
2572 API int pkgmgr_parser_update_tep_info_in_usr_db(const char *pkgid,
2573 const char *tep_path, uid_t uid)
2579 if (pkgid == NULL) {
2580 _LOGE("invalid parameter");
2581 return PM_PARSER_R_EINVAL;
2584 dbpath = __get_parser_db_path(uid);
2586 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2587 if (ret != SQLITE_OK) {
2588 _LOGE("open db failed: %d", ret);
2589 return PM_PARSER_R_ERROR;
2592 __BEGIN_TRANSACTION(db);
2593 __DO_TRANSACTION(db, __set_tep_path(db, pkgid, tep_path));
2594 __END_TRANSACTION(db);
2596 sqlite3_close_v2(db);
2598 return PM_PARSER_R_OK;
2601 API int pkgmgr_parser_update_tep_info_in_db(const char *pkgid,
2602 const char *tep_path)
2604 return pkgmgr_parser_update_tep_info_in_usr_db(pkgid, tep_path,
2608 static int __convert_update_type(pkgmgrinfo_updateinfo_update_type type,
2609 const char **update_type)
2611 if (type == PMINFO_UPDATEINFO_NONE)
2612 *update_type = PMINFO_UPDATEINFO_TYPE_NONE;
2613 else if (type == PMINFO_UPDATEINFO_FORCE)
2614 *update_type = PMINFO_UPDATEINFO_TYPE_FORCE;
2615 else if (type == PMINFO_UPDATEINFO_OPTIONAL)
2616 *update_type = PMINFO_UPDATEINFO_TYPE_OPTIONAL;
2622 static int __register_pkg_update_info(sqlite3 *db, updateinfo_x *info,
2623 const char *update_type)
2625 static const char query[] =
2626 "UPDATE package_update_info "
2627 "SET update_version=?, update_type=? "
2633 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2634 if (ret != SQLITE_OK) {
2635 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2639 __BIND_TEXT(db, stmt, idx++, info->version);
2640 __BIND_TEXT(db, stmt, idx++, update_type);
2641 __BIND_TEXT(db, stmt, idx++, info->pkgid);
2643 ret = sqlite3_step(stmt);
2644 if (ret != SQLITE_DONE) {
2645 _LOGE("step failed: %s", sqlite3_errmsg(db));
2646 sqlite3_finalize(stmt);
2650 sqlite3_finalize(stmt);
2655 API int pkgmgr_parser_register_pkg_update_info_in_usr_db(
2656 pkgmgrinfo_updateinfo_h handle, uid_t uid)
2659 updateinfo_x *update_info;
2660 updateinfo_x *prev_update_info;
2661 pkgmgrinfo_updateinfo_h prev_update_handle;
2662 pkgmgrinfo_pkginfo_h pkginfo;
2663 pkgmgrinfo_version_compare_type compare_result;
2665 const char *update_type;
2669 if (handle == NULL) {
2670 _LOGE("invalid parameter");
2671 return PM_PARSER_R_EINVAL;
2674 update_info = (updateinfo_x *)handle;
2675 if (update_info->pkgid == NULL || update_info->version == NULL)
2676 return PM_PARSER_R_EINVAL;
2677 if (__convert_update_type(update_info->type, &update_type) != 0)
2678 return PM_PARSER_R_EINVAL;
2680 ret = pkgmgrinfo_updateinfo_get_usr_updateinfo(update_info->pkgid,
2681 &prev_update_handle, uid);
2682 if (ret != PMINFO_R_OK)
2683 return PM_PARSER_R_ERROR;
2685 prev_update_info = (updateinfo_x *)prev_update_handle;
2686 ret = pkgmgrinfo_compare_package_version(update_info->version,
2687 prev_update_info->version, &compare_result);
2688 if (ret != PMINFO_R_OK) {
2689 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2690 return PM_PARSER_R_ERROR;
2693 if (compare_result == PMINFO_VERSION_SAME &&
2694 prev_update_info->type == PMINFO_UPDATEINFO_NONE) {
2695 _LOGI("Given update info version[%s] of pkgid[%s] "
2697 update_info->version, update_info->pkgid);
2698 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2699 return PM_PARSER_R_OK;
2701 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2703 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(update_info->pkgid, uid,
2705 if (ret != PMINFO_R_OK)
2706 return PM_PARSER_R_ERROR;
2708 ret = pkgmgrinfo_pkginfo_is_global(pkginfo, &is_global_pkg);
2709 if (ret != PMINFO_R_OK) {
2710 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2711 return PM_PARSER_R_ERROR;
2713 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2715 dbpath = __get_parser_db_path(is_global_pkg ? GLOBAL_USER : uid);
2717 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2718 if (ret != SQLITE_OK) {
2719 _LOGE("open db failed: %d", ret);
2720 return PM_PARSER_R_ERROR;
2723 __BEGIN_TRANSACTION(db);
2724 __DO_TRANSACTION(db, __register_pkg_update_info(db, update_info,
2726 __END_TRANSACTION(db);
2728 sqlite3_close_v2(db);
2730 return PM_PARSER_R_OK;
2733 API int pkgmgr_parser_register_pkg_update_info_in_db(
2734 pkgmgrinfo_updateinfo_h handle)
2736 return pkgmgr_parser_register_pkg_update_info_in_usr_db(handle,
2740 static int __unregister_pkg_update_info(sqlite3 *db, const char *pkgid)
2742 static const char query[] =
2743 "UPDATE package_update_info SET update_type='none' "
2749 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2750 if (ret != SQLITE_OK) {
2751 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2755 __BIND_TEXT(db, stmt, idx++, pkgid);
2757 ret = sqlite3_step(stmt);
2758 if (ret != SQLITE_DONE) {
2759 _LOGE("step failed: %s", sqlite3_errmsg(db));
2760 sqlite3_finalize(stmt);
2764 sqlite3_finalize(stmt);
2769 API int pkgmgr_parser_unregister_pkg_update_info_in_usr_db(const char *pkgid,
2775 pkgmgrinfo_pkginfo_h pkginfo;
2778 if (pkgid == NULL) {
2779 _LOGE("invalid parameter");
2780 return PM_PARSER_R_EINVAL;
2783 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &pkginfo);
2784 if (ret != PMINFO_R_OK)
2785 return PM_PARSER_R_EINVAL;
2787 ret = pkgmgrinfo_pkginfo_is_global(pkginfo, &is_global_pkg);
2788 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2789 if (ret != PMINFO_R_OK)
2790 return PM_PARSER_R_ERROR;
2792 dbpath = __get_parser_db_path(is_global_pkg ? GLOBAL_USER : uid);
2794 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2795 if (ret != SQLITE_OK) {
2796 _LOGE("open db failed: %d", ret);
2797 return PM_PARSER_R_ERROR;
2800 __BEGIN_TRANSACTION(db);
2801 __DO_TRANSACTION(db, __unregister_pkg_update_info(db, pkgid));
2802 __END_TRANSACTION(db);
2804 sqlite3_close_v2(db);
2806 return PM_PARSER_R_OK;
2809 API int pkgmgr_parser_unregister_pkg_update_info_in_db(const char *pkgid)
2811 return pkgmgr_parser_unregister_pkg_update_info_in_usr_db(pkgid,
2815 static int __unregister_all_pkg_update_info(sqlite3 *db)
2817 static const char query[] =
2818 "UPDATE package_update_info SET update_type='none'";
2822 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2823 if (ret != SQLITE_OK) {
2824 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2828 ret = sqlite3_step(stmt);
2829 if (ret != SQLITE_DONE) {
2830 _LOGE("step failed: %s", sqlite3_errmsg(db));
2831 sqlite3_finalize(stmt);
2835 sqlite3_finalize(stmt);
2840 API int pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid_t uid)
2846 dbpath = __get_parser_db_path(uid);
2848 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2849 if (ret != SQLITE_OK) {
2850 _LOGE("open db failed: %d", ret);
2851 return PM_PARSER_R_ERROR;
2854 __BEGIN_TRANSACTION(db);
2855 __DO_TRANSACTION(db, __unregister_all_pkg_update_info(db));
2856 __END_TRANSACTION(db);
2858 sqlite3_close_v2(db);
2860 return PM_PARSER_R_OK;
2863 API int pkgmgr_parser_unregister_all_pkg_update_info_in_db(void)
2865 return pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(