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_external_path, 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++, mfx->external_path);
1722 __BIND_TEXT(db, stmt, idx++, app->setup_appid);
1724 ret = sqlite3_step(stmt);
1725 if (ret != SQLITE_DONE) {
1726 _LOGE("step failed: %s", sqlite3_errmsg(db));
1727 sqlite3_finalize(stmt);
1731 sqlite3_reset(stmt);
1733 if (__insert_appcontrol_info(db, app)) {
1734 sqlite3_finalize(stmt);
1737 if (__insert_category_info(db, app)) {
1738 sqlite3_finalize(stmt);
1741 if (__insert_metadata_info(db, app)) {
1742 sqlite3_finalize(stmt);
1745 if (__insert_datacontrol_info(db, app)) {
1746 sqlite3_finalize(stmt);
1749 if (__insert_splashscreen_info(db, app)) {
1750 sqlite3_finalize(stmt);
1753 if (__insert_app_localized_info(db, app)) {
1754 sqlite3_finalize(stmt);
1759 sqlite3_finalize(stmt);
1764 static int __insert_package_update_info(sqlite3 *db, manifest_x *mfx)
1766 static const char query[] =
1767 "INSERT INTO package_update_info (package, update_version) "
1773 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1774 if (ret != SQLITE_OK) {
1775 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1780 __BIND_TEXT(db, stmt, idx++, mfx->package);
1781 __BIND_TEXT(db, stmt, idx, mfx->version);
1782 ret = sqlite3_step(stmt);
1783 if (ret != SQLITE_DONE) {
1784 _LOGE("step failed: %s", sqlite3_errmsg(db));
1785 sqlite3_finalize(stmt);
1788 sqlite3_finalize(stmt);
1793 static int __insert_package_localized_info(sqlite3 *db, manifest_x *mfx)
1795 static const char query[] =
1796 "INSERT INTO package_localized_info (package, package_locale,"
1797 " package_label, package_icon, package_description,"
1798 " package_license, package_author) "
1799 "VALUES (?, ?, ?, ?, ?, ?, ?)";
1812 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1813 if (ret != SQLITE_OK) {
1814 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1818 locales = __create_locale_list(mfx->label, mfx->license, mfx->icon,
1819 mfx->description, mfx->author);
1820 for (tmp = locales; tmp; tmp = tmp->next) {
1821 locale = (const char *)tmp->data;
1827 __extract_data(locale, mfx->label, mfx->license, mfx->icon,
1828 mfx->description, mfx->author,
1829 &label, &license, &icon, &description, &author);
1830 if (!label && !license && !icon && !description && !author)
1834 __BIND_TEXT(db, stmt, idx++, mfx->package);
1835 __BIND_TEXT(db, stmt, idx++, locale);
1836 __BIND_TEXT(db, stmt, idx++, label);
1837 __BIND_TEXT(db, stmt, idx++, icon);
1838 __BIND_TEXT(db, stmt, idx++, description);
1839 __BIND_TEXT(db, stmt, idx++, license);
1840 __BIND_TEXT(db, stmt, idx++, author);
1842 ret = sqlite3_step(stmt);
1843 if (ret != SQLITE_DONE) {
1844 _LOGE("step failed: %s", sqlite3_errmsg(db));
1845 g_list_free(locales);
1846 sqlite3_finalize(stmt);
1850 sqlite3_reset(stmt);
1853 g_list_free(locales);
1854 sqlite3_finalize(stmt);
1859 static int __insert_package_info(sqlite3 *db, manifest_x *mfx)
1861 static const char query[] =
1862 "INSERT INTO package_info (package, package_type,"
1863 " package_version, package_api_version, package_tep_name,"
1864 " package_zip_mount_file, install_location, package_size,"
1865 " package_removable, package_preload, package_readonly,"
1866 " package_update, package_appsetting, package_nodisplay,"
1867 " package_system, author_name, author_email, author_href,"
1868 " installed_time, installed_storage, storeclient_id,"
1869 " mainapp_id, package_url, root_path, external_path,"
1870 " csc_path, package_support_mode, package_support_disable) "
1874 " LOWER(?), LOWER(?), LOWER(?),"
1875 " LOWER(?), LOWER(?), LOWER(?),"
1876 " LOWER(?), ?, ?, ?,"
1883 const char *author_name = NULL;
1884 const char *author_email = NULL;
1885 const char *author_href = NULL;
1887 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1888 if (ret != SQLITE_OK) {
1889 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1893 if (mfx->author && mfx->author->data) {
1894 author_name = ((author_x *)mfx->author->data)->text;
1895 author_email = ((author_x *)mfx->author->data)->email;
1896 author_href = ((author_x *)mfx->author->data)->href;
1899 __BIND_TEXT(db, stmt, idx++, mfx->package);
1900 __BIND_TEXT(db, stmt, idx++, mfx->type);
1901 __BIND_TEXT(db, stmt, idx++, mfx->version);
1902 __BIND_TEXT(db, stmt, idx++, mfx->api_version);
1903 __BIND_TEXT(db, stmt, idx++, mfx->tep_name);
1904 __BIND_TEXT(db, stmt, idx++, mfx->zip_mount_file);
1905 __BIND_TEXT(db, stmt, idx++, mfx->installlocation);
1906 __BIND_TEXT(db, stmt, idx++, mfx->package_size);
1907 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, true));
1908 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->preload, false));
1909 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->readonly, false));
1910 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->update, false));
1911 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->appsetting, false));
1912 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->nodisplay_setting, false));
1913 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
1914 __BIND_TEXT(db, stmt, idx++, author_name);
1915 __BIND_TEXT(db, stmt, idx++, author_email);
1916 __BIND_TEXT(db, stmt, idx++, author_href);
1917 __BIND_TEXT(db, stmt, idx++, mfx->installed_time);
1918 __BIND_TEXT(db, stmt, idx++, mfx->installed_storage);
1919 __BIND_TEXT(db, stmt, idx++, mfx->storeclient_id);
1920 __BIND_TEXT(db, stmt, idx++, mfx->mainapp_id);
1921 __BIND_TEXT(db, stmt, idx++, mfx->package_url);
1922 __BIND_TEXT(db, stmt, idx++, mfx->root_path);
1923 __BIND_TEXT(db, stmt, idx++, mfx->external_path);
1924 __BIND_TEXT(db, stmt, idx++, mfx->csc_path);
1925 __BIND_TEXT(db, stmt, idx++, mfx->support_mode);
1926 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->support_disable, false));
1928 ret = sqlite3_step(stmt);
1929 if (ret != SQLITE_DONE) {
1930 _LOGE("step failed: %s", sqlite3_errmsg(db));
1931 sqlite3_finalize(stmt);
1935 sqlite3_finalize(stmt);
1937 if (__insert_package_update_info(db, mfx))
1939 if (__insert_package_localized_info(db, mfx))
1941 if (__insert_application_info(db, mfx))
1943 if (__insert_package_privilege_info(db, mfx))
1945 if (__insert_package_appdefined_privilege_info(db, mfx))
1951 API int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
1958 _LOGE("invalid parameter");
1959 return PM_PARSER_R_EINVAL;
1962 dbpath = __get_parser_db_path(uid);
1964 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
1965 if (ret != SQLITE_OK) {
1966 _LOGE("open db failed: %d", ret);
1967 return PM_PARSER_R_ERROR;
1970 __BEGIN_TRANSACTION(db);
1971 __DO_TRANSACTION(db, __insert_package_info(db, mfx));
1972 __END_TRANSACTION(db);
1974 sqlite3_close_v2(db);
1976 return PM_PARSER_R_OK;
1979 API int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx)
1981 return pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, __getuid());
1984 static int __delete_package_info(sqlite3 *db, const char *pkgid)
1986 static const char query[] =
1987 "DELETE FROM package_info WHERE package=?";
1991 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1992 if (ret != SQLITE_OK) {
1993 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1997 __BIND_TEXT(db, stmt, 1, pkgid);
1999 ret = sqlite3_step(stmt);
2000 if (ret != SQLITE_DONE) {
2001 _LOGE("step failed: %s", sqlite3_errmsg(db));
2002 sqlite3_finalize(stmt);
2006 sqlite3_finalize(stmt);
2011 API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx,
2019 _LOGE("invalid parameter");
2020 return PM_PARSER_R_EINVAL;
2023 dbpath = __get_parser_db_path(uid);
2025 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2026 if (ret != SQLITE_OK) {
2027 _LOGE("open db failed: %d", ret);
2028 return PM_PARSER_R_ERROR;
2031 __BEGIN_TRANSACTION(db);
2032 __DO_TRANSACTION(db, __delete_package_info(db, mfx->package));
2033 __END_TRANSACTION(db);
2035 sqlite3_close_v2(db);
2037 return PM_PARSER_R_OK;
2040 API int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx)
2042 return pkgmgr_parser_delete_manifest_info_from_usr_db(mfx, __getuid());
2045 API int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
2052 _LOGE("invalid parameter");
2053 return PM_PARSER_R_EINVAL;
2056 dbpath = __get_parser_db_path(uid);
2058 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2059 if (ret != SQLITE_OK) {
2060 _LOGE("open db failed: %d", ret);
2061 return PM_PARSER_R_ERROR;
2064 __BEGIN_TRANSACTION(db);
2065 __DO_TRANSACTION(db, __delete_package_info(db, mfx->package));
2066 __DO_TRANSACTION(db, __insert_package_info(db, mfx));
2067 __END_TRANSACTION(db);
2069 sqlite3_close_v2(db);
2071 return PM_PARSER_R_OK;
2074 API int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx)
2076 return pkgmgr_parser_update_manifest_info_in_usr_db(mfx, __getuid());
2079 static int __set_global_app_disable_for_uid(sqlite3 *db, const char *appid,
2080 uid_t uid, bool is_disable)
2082 static const char query[] =
2083 "INSERT OR REPLACE INTO package_app_info_for_uid ("
2084 " app_id, uid, is_disabled, is_splash_screen_enabled) "
2086 " (SELECT app_splash_screen_display FROM package_app_info"
2087 " WHERE app_id=?))";
2092 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2093 if (ret != SQLITE_OK) {
2094 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2098 __BIND_TEXT(db, stmt, idx++, appid);
2099 __BIND_INT(db, stmt, idx++, uid);
2100 __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false");
2101 __BIND_TEXT(db, stmt, idx++, appid);
2103 ret = sqlite3_step(stmt);
2104 if (ret != SQLITE_DONE) {
2105 _LOGE("step failed: %s", sqlite3_errmsg(db));
2106 sqlite3_finalize(stmt);
2110 sqlite3_finalize(stmt);
2115 API int pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
2116 const char *appid, uid_t uid, int is_disable)
2122 if (appid == NULL) {
2123 _LOGE("invalid parameter");
2124 return PM_PARSER_R_EINVAL;
2127 dbpath = __get_parser_db_path(GLOBAL_USER);
2129 ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE);
2130 if (ret != SQLITE_OK) {
2131 _LOGE("open db failed: %d", ret);
2132 return PM_PARSER_R_ERROR;
2135 __BEGIN_TRANSACTION(db);
2136 __DO_TRANSACTION(db, __set_global_app_disable_for_uid(db, appid,
2137 uid, (bool)is_disable));
2138 __END_TRANSACTION(db);
2140 sqlite3_close_v2(db);
2142 return PM_PARSER_R_OK;
2145 static int __set_app_disable(sqlite3 *db, const char *appid, uid_t uid,
2148 static const char query[] =
2149 "UPDATE package_app_info SET app_disable=? "
2155 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2156 if (ret != SQLITE_OK) {
2157 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2161 __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false");
2162 __BIND_TEXT(db, stmt, idx++, appid);
2164 ret = sqlite3_step(stmt);
2165 if (ret != SQLITE_DONE) {
2166 _LOGE("step failed: %s", sqlite3_errmsg(db));
2167 sqlite3_finalize(stmt);
2171 sqlite3_finalize(stmt);
2176 API int pkgmgr_parser_update_app_disable_info_in_usr_db(const char *appid,
2177 uid_t uid, int is_disable)
2183 if (appid == NULL) {
2184 _LOGE("invalid parameter");
2185 return PM_PARSER_R_EINVAL;
2188 dbpath = __get_parser_db_path(uid);
2190 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2191 if (ret != SQLITE_OK) {
2192 _LOGE("open db failed: %d", ret);
2193 return PM_PARSER_R_ERROR;
2196 __BEGIN_TRANSACTION(db);
2197 __DO_TRANSACTION(db, __set_app_disable(db, appid, uid,
2199 __END_TRANSACTION(db);
2201 sqlite3_close_v2(db);
2203 return PM_PARSER_R_OK;
2206 API int pkgmgr_parser_update_app_disable_info_in_db(const char *appid,
2209 return pkgmgr_parser_update_app_disable_info_in_usr_db(appid,
2210 __getuid(), is_disable);
2213 static int __set_pkg_disable(sqlite3 *db, const char *pkgid, uid_t uid,
2216 static const char query[] =
2217 "UPDATE package_info SET package_disable=? "
2223 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2224 if (ret != SQLITE_OK) {
2225 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2229 __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false");
2230 __BIND_TEXT(db, stmt, idx++, pkgid);
2232 ret = sqlite3_step(stmt);
2233 if (ret != SQLITE_DONE) {
2234 _LOGE("step failed: %s", sqlite3_errmsg(db));
2235 sqlite3_finalize(stmt);
2239 sqlite3_finalize(stmt);
2244 API int pkgmgr_parser_update_pkg_disable_info_in_usr_db(const char *pkgid,
2245 uid_t uid, int is_disable)
2251 if (pkgid == NULL) {
2252 _LOGE("invalid parameter");
2253 return PM_PARSER_R_EINVAL;
2256 dbpath = __get_parser_db_path(uid);
2258 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2259 if (ret != SQLITE_OK) {
2260 _LOGE("open db failed: %d", ret);
2261 return PM_PARSER_R_ERROR;
2264 __BEGIN_TRANSACTION(db);
2265 __DO_TRANSACTION(db, __set_pkg_disable(db, pkgid, uid,
2267 __END_TRANSACTION(db);
2269 sqlite3_close_v2(db);
2271 return PM_PARSER_R_OK;
2274 API int pkgmgr_parser_update_pkg_disable_info_in_db(const char *pkgid,
2277 return pkgmgr_parser_update_pkg_disable_info_in_usr_db(pkgid,
2278 __getuid(), is_disable);
2281 static int __set_global_app_splash_screen_for_uid(sqlite3 *db,
2282 const char *appid, uid_t uid, bool is_enabled)
2284 static const char query[] =
2285 "INSERT OR REPLACE INTO package_app_info_for_uid("
2286 " appid, uid, is_splash_screen_enabled) "
2292 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2293 if (ret != SQLITE_OK) {
2294 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2298 __BIND_TEXT(db, stmt, idx++, appid);
2299 __BIND_INT(db, stmt, idx++, uid);
2300 __BIND_TEXT(db, stmt, idx++, is_enabled ? "true" : "false");
2302 ret = sqlite3_step(stmt);
2303 if (ret != SQLITE_DONE) {
2304 _LOGE("step failed: %s", sqlite3_errmsg(db));
2305 sqlite3_finalize(stmt);
2309 sqlite3_finalize(stmt);
2314 API int pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(
2315 const char *appid, uid_t uid, int flag)
2321 if (appid == NULL) {
2322 _LOGE("invalid parameter");
2323 return PM_PARSER_R_EINVAL;
2326 dbpath = __get_parser_db_path(GLOBAL_USER);
2328 ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE);
2329 if (ret != SQLITE_OK) {
2330 _LOGE("open db failed: %d", ret);
2331 return PM_PARSER_R_ERROR;
2334 __BEGIN_TRANSACTION(db);
2335 __DO_TRANSACTION(db, __set_global_app_splash_screen_for_uid(db,
2336 appid, uid, (bool)flag));
2337 __END_TRANSACTION(db);
2339 sqlite3_close_v2(db);
2341 return PM_PARSER_R_OK;
2344 static int __set_app_splash_screen(sqlite3 *db, const char *appid,
2347 static const char query[] =
2348 "UPDATE package_app_info SET app_splash_screen_display=? "
2354 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2355 if (ret != SQLITE_OK) {
2356 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2360 __BIND_TEXT(db, stmt, idx++, is_enabled ? "true" : "false");
2361 __BIND_TEXT(db, stmt, idx++, appid);
2363 ret = sqlite3_step(stmt);
2364 if (ret != SQLITE_DONE) {
2365 _LOGE("step failed: %s", sqlite3_errmsg(db));
2366 sqlite3_finalize(stmt);
2370 sqlite3_finalize(stmt);
2375 API int pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
2376 const char *appid, uid_t uid, int flag)
2382 if (appid == NULL) {
2383 _LOGE("invalid parameter");
2384 return PM_PARSER_R_EINVAL;
2387 dbpath = __get_parser_db_path(uid);
2389 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2390 if (ret != SQLITE_OK) {
2391 _LOGE("open db failed: %d", ret);
2392 return PM_PARSER_R_ERROR;
2395 __BEGIN_TRANSACTION(db);
2396 __DO_TRANSACTION(db, __set_app_splash_screen(db, appid, (bool)flag));
2397 __END_TRANSACTION(db);
2399 sqlite3_close_v2(db);
2401 return PM_PARSER_R_OK;
2404 API int pkgmgr_parser_update_app_splash_screen_display_info_in_db(
2405 const char *appid, int flag)
2407 return pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
2408 appid, __getuid(), flag);
2411 static int __set_app_label(sqlite3 *db, const char *appid, const char *label)
2413 static const char query[] =
2414 "UPDATE package_app_localized_info SET app_label=? "
2415 "WHERE app_id=? AND app_label IS NOT NULL";
2420 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2421 if (ret != SQLITE_OK) {
2422 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2426 __BIND_TEXT(db, stmt, idx++, label);
2427 __BIND_TEXT(db, stmt, idx++, appid);
2429 ret = sqlite3_step(stmt);
2430 if (ret != SQLITE_DONE) {
2431 _LOGE("step failed: %s", sqlite3_errmsg(db));
2432 sqlite3_finalize(stmt);
2436 sqlite3_finalize(stmt);
2441 API int pkgmgr_parser_update_app_label_info_in_usr_db(const char *appid,
2442 uid_t uid, const char *label)
2448 if (appid == NULL) {
2449 _LOGE("invalid parameter");
2450 return PM_PARSER_R_EINVAL;
2453 dbpath = __get_parser_db_path(uid);
2455 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2456 if (ret != SQLITE_OK) {
2457 _LOGE("open db failed: %d", ret);
2458 return PM_PARSER_R_ERROR;
2461 __BEGIN_TRANSACTION(db);
2462 __DO_TRANSACTION(db, __set_app_label(db, appid, label));
2463 __END_TRANSACTION(db);
2465 sqlite3_close_v2(db);
2467 return PM_PARSER_R_OK;
2470 API int pkgmgr_parser_update_app_label_info_in_db(const char *appid,
2473 return pkgmgr_parser_update_app_label_info_in_usr_db(appid, __getuid(),
2477 static int __set_app_icon(sqlite3 *db, const char *appid, const char *icon_path)
2479 static const char query[] =
2480 "UPDATE package_app_localized_info SET app_icon=? "
2481 "WHERE app_id=? AND app_icon IS NOT NULL";
2486 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2487 if (ret != SQLITE_OK) {
2488 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2492 __BIND_TEXT(db, stmt, idx++, icon_path);
2493 __BIND_TEXT(db, stmt, idx++, appid);
2495 ret = sqlite3_step(stmt);
2496 if (ret != SQLITE_DONE) {
2497 _LOGE("step failed: %s", sqlite3_errmsg(db));
2498 sqlite3_finalize(stmt);
2502 sqlite3_finalize(stmt);
2507 API int pkgmgr_parser_update_app_icon_info_in_usr_db(const char *appid,
2508 uid_t uid, const char *icon_path)
2514 if (appid == NULL) {
2515 _LOGE("invalid parameter");
2516 return PM_PARSER_R_EINVAL;
2519 dbpath = __get_parser_db_path(uid);
2521 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2522 if (ret != SQLITE_OK) {
2523 _LOGE("open db failed: %d", ret);
2524 return PM_PARSER_R_ERROR;
2527 __BEGIN_TRANSACTION(db);
2528 __DO_TRANSACTION(db, __set_app_icon(db, appid, icon_path));
2529 __END_TRANSACTION(db);
2531 sqlite3_close_v2(db);
2533 return PM_PARSER_R_OK;
2536 API int pkgmgr_parser_update_app_icon_info_in_db(const char *appid,
2537 const char *icon_path)
2539 return pkgmgr_parser_update_app_icon_info_in_usr_db(appid, __getuid(),
2543 static int __set_tep_path(sqlite3 *db, const char *pkgid, const char *tep_path)
2545 static const char query[] =
2546 "UPDATE package_info SET package_tep_name=? "
2552 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2553 if (ret != SQLITE_OK) {
2554 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2558 __BIND_TEXT(db, stmt, idx++, tep_path);
2559 __BIND_TEXT(db, stmt, idx++, pkgid);
2561 ret = sqlite3_step(stmt);
2562 if (ret != SQLITE_DONE) {
2563 _LOGE("step failed: %s", sqlite3_errmsg(db));
2564 sqlite3_finalize(stmt);
2568 sqlite3_finalize(stmt);
2573 API int pkgmgr_parser_update_tep_info_in_usr_db(const char *pkgid,
2574 const char *tep_path, uid_t uid)
2580 if (pkgid == NULL) {
2581 _LOGE("invalid parameter");
2582 return PM_PARSER_R_EINVAL;
2585 dbpath = __get_parser_db_path(uid);
2587 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2588 if (ret != SQLITE_OK) {
2589 _LOGE("open db failed: %d", ret);
2590 return PM_PARSER_R_ERROR;
2593 __BEGIN_TRANSACTION(db);
2594 __DO_TRANSACTION(db, __set_tep_path(db, pkgid, tep_path));
2595 __END_TRANSACTION(db);
2597 sqlite3_close_v2(db);
2599 return PM_PARSER_R_OK;
2602 API int pkgmgr_parser_update_tep_info_in_db(const char *pkgid,
2603 const char *tep_path)
2605 return pkgmgr_parser_update_tep_info_in_usr_db(pkgid, tep_path,
2609 static int __convert_update_type(pkgmgrinfo_updateinfo_update_type type,
2610 const char **update_type)
2612 if (type == PMINFO_UPDATEINFO_NONE)
2613 *update_type = PMINFO_UPDATEINFO_TYPE_NONE;
2614 else if (type == PMINFO_UPDATEINFO_FORCE)
2615 *update_type = PMINFO_UPDATEINFO_TYPE_FORCE;
2616 else if (type == PMINFO_UPDATEINFO_OPTIONAL)
2617 *update_type = PMINFO_UPDATEINFO_TYPE_OPTIONAL;
2623 static int __register_pkg_update_info(sqlite3 *db, updateinfo_x *info,
2624 const char *update_type)
2626 static const char query[] =
2627 "UPDATE package_update_info "
2628 "SET update_version=?, update_type=? "
2634 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2635 if (ret != SQLITE_OK) {
2636 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2640 __BIND_TEXT(db, stmt, idx++, info->version);
2641 __BIND_TEXT(db, stmt, idx++, update_type);
2642 __BIND_TEXT(db, stmt, idx++, info->pkgid);
2644 ret = sqlite3_step(stmt);
2645 if (ret != SQLITE_DONE) {
2646 _LOGE("step failed: %s", sqlite3_errmsg(db));
2647 sqlite3_finalize(stmt);
2651 sqlite3_finalize(stmt);
2656 API int pkgmgr_parser_register_pkg_update_info_in_usr_db(
2657 pkgmgrinfo_updateinfo_h handle, uid_t uid)
2660 updateinfo_x *update_info;
2661 updateinfo_x *prev_update_info;
2662 pkgmgrinfo_updateinfo_h prev_update_handle;
2663 pkgmgrinfo_pkginfo_h pkginfo;
2664 pkgmgrinfo_version_compare_type compare_result;
2666 const char *update_type;
2670 if (handle == NULL) {
2671 _LOGE("invalid parameter");
2672 return PM_PARSER_R_EINVAL;
2675 update_info = (updateinfo_x *)handle;
2676 if (update_info->pkgid == NULL || update_info->version == NULL)
2677 return PM_PARSER_R_EINVAL;
2678 if (__convert_update_type(update_info->type, &update_type) != 0)
2679 return PM_PARSER_R_EINVAL;
2681 ret = pkgmgrinfo_updateinfo_get_usr_updateinfo(update_info->pkgid,
2682 &prev_update_handle, uid);
2683 if (ret != PMINFO_R_OK)
2684 return PM_PARSER_R_ERROR;
2686 prev_update_info = (updateinfo_x *)prev_update_handle;
2687 ret = pkgmgrinfo_compare_package_version(update_info->version,
2688 prev_update_info->version, &compare_result);
2689 if (ret != PMINFO_R_OK) {
2690 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2691 return PM_PARSER_R_ERROR;
2694 if (compare_result == PMINFO_VERSION_SAME &&
2695 prev_update_info->type == PMINFO_UPDATEINFO_NONE) {
2696 _LOGI("Given update info version[%s] of pkgid[%s] "
2698 update_info->version, update_info->pkgid);
2699 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2700 return PM_PARSER_R_OK;
2702 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2704 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(update_info->pkgid, uid,
2706 if (ret != PMINFO_R_OK)
2707 return PM_PARSER_R_ERROR;
2709 ret = pkgmgrinfo_pkginfo_is_global(pkginfo, &is_global_pkg);
2710 if (ret != PMINFO_R_OK) {
2711 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2712 return PM_PARSER_R_ERROR;
2714 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2716 dbpath = __get_parser_db_path(is_global_pkg ? GLOBAL_USER : uid);
2718 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2719 if (ret != SQLITE_OK) {
2720 _LOGE("open db failed: %d", ret);
2721 return PM_PARSER_R_ERROR;
2724 __BEGIN_TRANSACTION(db);
2725 __DO_TRANSACTION(db, __register_pkg_update_info(db, update_info,
2727 __END_TRANSACTION(db);
2729 sqlite3_close_v2(db);
2731 return PM_PARSER_R_OK;
2734 API int pkgmgr_parser_register_pkg_update_info_in_db(
2735 pkgmgrinfo_updateinfo_h handle)
2737 return pkgmgr_parser_register_pkg_update_info_in_usr_db(handle,
2741 static int __unregister_pkg_update_info(sqlite3 *db, const char *pkgid)
2743 static const char query[] =
2744 "UPDATE package_update_info SET update_type='none' "
2750 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2751 if (ret != SQLITE_OK) {
2752 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2756 __BIND_TEXT(db, stmt, idx++, pkgid);
2758 ret = sqlite3_step(stmt);
2759 if (ret != SQLITE_DONE) {
2760 _LOGE("step failed: %s", sqlite3_errmsg(db));
2761 sqlite3_finalize(stmt);
2765 sqlite3_finalize(stmt);
2770 API int pkgmgr_parser_unregister_pkg_update_info_in_usr_db(const char *pkgid,
2776 pkgmgrinfo_pkginfo_h pkginfo;
2779 if (pkgid == NULL) {
2780 _LOGE("invalid parameter");
2781 return PM_PARSER_R_EINVAL;
2784 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &pkginfo);
2785 if (ret != PMINFO_R_OK)
2786 return PM_PARSER_R_EINVAL;
2788 ret = pkgmgrinfo_pkginfo_is_global(pkginfo, &is_global_pkg);
2789 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2790 if (ret != PMINFO_R_OK)
2791 return PM_PARSER_R_ERROR;
2793 dbpath = __get_parser_db_path(is_global_pkg ? GLOBAL_USER : uid);
2795 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2796 if (ret != SQLITE_OK) {
2797 _LOGE("open db failed: %d", ret);
2798 return PM_PARSER_R_ERROR;
2801 __BEGIN_TRANSACTION(db);
2802 __DO_TRANSACTION(db, __unregister_pkg_update_info(db, pkgid));
2803 __END_TRANSACTION(db);
2805 sqlite3_close_v2(db);
2807 return PM_PARSER_R_OK;
2810 API int pkgmgr_parser_unregister_pkg_update_info_in_db(const char *pkgid)
2812 return pkgmgr_parser_unregister_pkg_update_info_in_usr_db(pkgid,
2816 static int __unregister_all_pkg_update_info(sqlite3 *db)
2818 static const char query[] =
2819 "UPDATE package_update_info SET update_type='none'";
2823 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2824 if (ret != SQLITE_OK) {
2825 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2829 ret = sqlite3_step(stmt);
2830 if (ret != SQLITE_DONE) {
2831 _LOGE("step failed: %s", sqlite3_errmsg(db));
2832 sqlite3_finalize(stmt);
2836 sqlite3_finalize(stmt);
2841 API int pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid_t uid)
2847 dbpath = __get_parser_db_path(uid);
2849 ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
2850 if (ret != SQLITE_OK) {
2851 _LOGE("open db failed: %d", ret);
2852 return PM_PARSER_R_ERROR;
2855 __BEGIN_TRANSACTION(db);
2856 __DO_TRANSACTION(db, __unregister_all_pkg_update_info(db));
2857 __END_TRANSACTION(db);
2859 sqlite3_close_v2(db);
2861 return PM_PARSER_R_OK;
2864 API int pkgmgr_parser_unregister_all_pkg_update_info_in_db(void)
2866 return pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(