2 * Copyright 2013 Samsung Electronics Co., Ltd
4 * Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
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.
19 #include <stdlib.h> /* malloc */
20 #include <string.h> /* strdup, strerror */
21 #include <sys/types.h>
29 #include <com-core_packet.h>
33 #include <package-manager.h>
34 #include <pkgmgr-info.h>
36 #include <vconf-keys.h>
38 #include <unicode/uloc.h>
43 #include "livebox-service.h"
44 #include "livebox-errno.h"
46 #define SAMSUNG_PREFIX "com.samsung."
47 #define EAPI __attribute__((visibility("default")))
48 #define DEFAULT_TIMEOUT 2.0
51 static struct supported_size_list {
54 } SIZE_LIST[NR_OF_SIZE_LIST] = {
55 { 175, 175 }, /*!< 1x1 */
56 { 354, 175 }, /*!< 2x1 */
57 { 354, 354 }, /*!< 2x2 */
58 { 712, 175 }, /*!< 4x1 */
59 { 712, 354 }, /*!< 4x2 */
60 { 712, 533 }, /*!< 4x3 */
61 { 712, 712 }, /*!< 4x4 */
62 { 712, 891 }, /*!< 4x5 */
63 { 712, 1070 }, /*!< 4x6 */
64 { 224, 215 }, /*!< 21x21 */
65 { 680, 215 }, /*!< 23x21 */
66 { 680, 653 }, /*!< 23x23 */
67 { 720, 1280 }, /*!< 0x0 */
70 struct pkglist_handle {
72 PKGLIST_TYPE_LB_LIST = 0x00beef00,
73 PKGLIST_TYPE_UNKNOWN = 0x00dead00
82 const char *conf_file;
87 char country[ULOC_COUNTRY_CAPACITY];
92 .dbfile = "/opt/dbspace/.livebox.db",
93 .conf_file = "/usr/share/data-provider-master/resolution.ini",
103 static inline int update_info(int width_type, int height_type, int width, int height)
107 if (width_type == 1 && height_type == 1) {
109 } else if (width_type == 2 && height_type == 1) {
111 } else if (width_type == 2 && height_type == 2) {
113 } else if (width_type == 4 && height_type == 1) {
115 } else if (width_type == 4 && height_type == 2) {
117 } else if (width_type == 4 && height_type == 3) {
119 } else if (width_type == 4 && height_type == 4) {
121 } else if (width_type == 4 && height_type == 5) {
123 } else if (width_type == 4 && height_type == 6) {
125 } else if (width_type == 21 && height_type == 21) {
127 } else if (width_type == 23 && height_type == 21) {
129 } else if (width_type == 23 && height_type == 23) {
131 } else if (width_type == 0 && height_type == 0) {
134 ErrPrint("Unknown size type: %dx%d (%dx%d)\n", width_type, height_type, width, height);
138 SIZE_LIST[idx].w = width;
139 SIZE_LIST[idx].h = height;
143 static inline int update_from_file(void)
151 char buffer[MAX_COLUMN];
165 fp = fopen(s_info.conf_file, "r");
167 ErrPrint("Open failed: %s\n", strerror(errno));
168 return LB_STATUS_ERROR_IO;
177 if (idx == MAX_COLUMN) {
178 ErrPrint("Buffer overflow. Too long line. LINE MUST BE SHOT THAN %d\n", MAX_COLUMN);
184 if (isspace(ch) || ch == EOF)
199 if (sscanf(buffer, "%dx%d", &width_type, &height_type) != 2) {
200 ErrPrint("Invalid syntax: [%s]\n", buffer);
204 } else if (ch == '=') {
207 if (sscanf(buffer, "%dx%d", &width_type, &height_type) != 2) {
208 ErrPrint("Invalid syntax: [%s]\n", buffer);
212 } else if (ch == EOF) {
213 ErrPrint("Invalid Syntax\n");
224 if (isspace(ch) || ch == EOF)
232 if (isspace(ch) || ch == EOF) {
236 if (sscanf(buffer, "%dx%d", &width, &height) != 2) {
237 ErrPrint("Invalid syntax: [%s]\n", buffer);
239 } else if (ch == EOF) {
240 updated += update_info(width_type, height_type, width, height);
247 updated += update_info(width_type, height_type, width, height);
252 if (ch == '\n' || ch == '\r' || ch == '\f')
256 if (ch == '\n' || ch == '\r' || ch == '\f')
260 ErrPrint("Unknown status. couldn't be reach to here\n");
266 return NR_OF_SIZE_LIST - updated;
269 static int update_resolution(void)
281 if (s_info.res_resolved)
282 return LB_STATUS_SUCCESS;
284 disp = XOpenDisplay(NULL);
286 ErrPrint("Failed to open a display\n");
287 return LB_STATUS_ERROR_FAULT;
290 root = XDefaultRootWindow(disp);
291 if (!XGetGeometry(disp, root, &dummy, &x, &y, &width, &height, &border, &depth)) {
293 return LB_STATUS_ERROR_FAULT;
296 if (update_from_file() == 0)
297 DbgPrint("Resolution info is all updated by file\n");
299 for (i = 0; i < NR_OF_SIZE_LIST; i++) {
300 SIZE_LIST[i].w = (unsigned int)((double)SIZE_LIST[i].w * (double)width / 720.0f);
301 SIZE_LIST[i].h = (unsigned int)((double)SIZE_LIST[i].h * (double)width / 720.0f);
305 s_info.res_resolved = 1;
306 return LB_STATUS_SUCCESS;
309 static sqlite3 *open_db(void)
313 if (!s_info.handle) {
316 ret = db_util_open(s_info.dbfile, &handle, DB_UTIL_REGISTER_HOOK_METHOD);
317 if (ret != SQLITE_OK) {
318 ErrPrint("Failed to open a DB\n");
322 handle = s_info.handle;
328 static inline __attribute__((always_inline)) void close_db(sqlite3 *handle)
331 db_util_close(handle);
334 static inline int convert_size_from_type(enum livebox_size_type type, int *width, int *height)
339 case LB_SIZE_TYPE_1x1: /*!< 175x175 */
342 case LB_SIZE_TYPE_2x1: /*!< 354x175 */
345 case LB_SIZE_TYPE_2x2: /*!< 354x354 */
348 case LB_SIZE_TYPE_4x1: /*!< 712x175 */
351 case LB_SIZE_TYPE_4x2: /*!< 712x354 */
354 case LB_SIZE_TYPE_4x3: /*!< 712x533 */
357 case LB_SIZE_TYPE_4x4: /*!< 712x712 */
360 case LB_SIZE_TYPE_4x5: /*!< 712x891 */
363 case LB_SIZE_TYPE_4x6: /*!< 712x1070 */
366 case LB_SIZE_TYPE_EASY_1x1: /*< 224x215 */
369 case LB_SIZE_TYPE_EASY_3x1: /*!< 680x215 */
372 case LB_SIZE_TYPE_EASY_3x3: /*!< 680x653 */
375 case LB_SIZE_TYPE_0x0: /*!< 720x1280 */
379 return LB_STATUS_ERROR_INVALID;
382 if (update_resolution() < 0)
383 ErrPrint("Failed to update resolution\n");
385 *width = SIZE_LIST[idx].w;
386 *height = SIZE_LIST[idx].h;
387 return LB_STATUS_SUCCESS;
390 EAPI int livebox_service_change_period(const char *pkgname, const char *id, double period)
392 struct packet *packet;
393 struct packet *result;
397 if (!pkgname || !id || period < 0.0f) {
398 ErrPrint("Invalid argument\n");
399 return LB_STATUS_ERROR_INVALID;
402 uri = util_id_to_uri(id);
404 return LB_STATUS_ERROR_MEMORY;
406 packet = packet_create("service_change_period", "ssd", pkgname, uri, period);
409 ErrPrint("Failed to create a packet for period changing\n");
410 return LB_STATUS_ERROR_FAULT;
413 result = com_core_packet_oneshot_send(SERVICE_SOCKET, packet, DEFAULT_TIMEOUT);
414 packet_unref(packet);
417 if (packet_get(result, "i", &ret) != 1) {
418 ErrPrint("Failed to parse a result packet\n");
419 ret = LB_STATUS_ERROR_INVALID;
421 packet_unref(result);
423 ErrPrint("Failed to get result packet\n");
424 ret = LB_STATUS_ERROR_FAULT;
430 EAPI int livebox_service_trigger_update(const char *pkgname, const char *id, const char *cluster, const char *category, int force)
432 struct packet *packet;
433 struct packet *result;
438 ErrPrint("Invalid argument\n");
439 return LB_STATUS_ERROR_INVALID;
442 if (!force && access("/tmp/.live.paused", R_OK) == 0) {
443 DbgPrint("Provider is paused\n");
444 return LB_STATUS_ERROR_CANCEL;
447 uri = util_id_to_uri(id);
449 return LB_STATUS_ERROR_MEMORY;
452 cluster = "user,created";
455 category = "default";
457 packet = packet_create("service_update", "ssss", pkgname, uri, cluster, category);
460 ErrPrint("Failed to create a packet for service_update\n");
461 return LB_STATUS_ERROR_FAULT;
464 result = com_core_packet_oneshot_send(SERVICE_SOCKET, packet, DEFAULT_TIMEOUT);
465 packet_unref(packet);
468 if (packet_get(result, "i", &ret) != 1) {
469 ErrPrint("Failed to parse a result packet\n");
470 ret = LB_STATUS_ERROR_INVALID;
473 packet_unref(result);
475 ErrPrint("Failed to get result packet\n");
476 ret = LB_STATUS_ERROR_FAULT;
483 * pkgid == Package Id (not the livebox id)
485 EAPI struct pkglist_handle *livebox_service_pkglist_create(const char *pkgid, struct pkglist_handle *handle)
490 if (handle->type != PKGLIST_TYPE_LB_LIST) {
491 ErrPrint("Invalid handle\n");
496 ErrPrint("pkgid should be NULL\n");
500 sqlite3_reset(handle->stmt);
504 handle = calloc(1, sizeof(*handle));
506 ErrPrint("Heap: %s\n", strerror(errno));
510 handle->type = PKGLIST_TYPE_LB_LIST;
512 handle->handle = open_db();
513 if (!handle->handle) {
519 ret = sqlite3_prepare_v2(handle->handle, "SELECT appid, pkgid, prime FROM pkgmap", -1, &handle->stmt, NULL);
520 if (ret != SQLITE_OK) {
521 ErrPrint("Error: %s\n", sqlite3_errmsg(handle->handle));
522 close_db(handle->handle);
527 ret = sqlite3_prepare_v2(handle->handle, "SELECT appid, pkgid, prime FROM pkgmap WHERE appid = ?", -1, &handle->stmt, NULL);
528 if (ret != SQLITE_OK) {
529 ErrPrint("Error: %s\n", sqlite3_errmsg(handle->handle));
530 close_db(handle->handle);
535 ret = sqlite3_bind_text(handle->stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
536 if (ret != SQLITE_OK) {
537 ErrPrint("Error: %s\n", sqlite3_errmsg(handle->handle));
538 sqlite3_finalize(handle->stmt);
539 close_db(handle->handle);
548 EAPI int livebox_service_get_pkglist_item(struct pkglist_handle *handle, char **appid, char **pkgname, int *is_prime)
552 char *_pkgname = NULL;
554 if (!handle || handle->type != PKGLIST_TYPE_LB_LIST)
555 return LB_STATUS_ERROR_INVALID;
557 if (sqlite3_step(handle->stmt) != SQLITE_ROW)
558 return LB_STATUS_ERROR_NOT_EXIST;
561 tmp = (const char *)sqlite3_column_text(handle->stmt, 0);
562 if (tmp && strlen(tmp)) {
563 _appid = strdup(tmp);
565 ErrPrint("Heap: %s\n", strerror(errno));
566 return LB_STATUS_ERROR_MEMORY;
572 tmp = (const char *)sqlite3_column_text(handle->stmt, 1);
573 if (tmp && strlen(tmp)) {
574 _pkgname = strdup(tmp);
576 ErrPrint("Heap: %s\n", strerror(errno));
578 return LB_STATUS_ERROR_MEMORY;
584 *is_prime = sqlite3_column_int(handle->stmt, 2);
592 return LB_STATUS_SUCCESS;
595 EAPI int livebox_service_pkglist_destroy(struct pkglist_handle *handle)
597 if (!handle || handle->type != PKGLIST_TYPE_LB_LIST)
598 return LB_STATUS_ERROR_INVALID;
600 handle->type = PKGLIST_TYPE_UNKNOWN;
601 sqlite3_reset(handle->stmt);
602 sqlite3_finalize(handle->stmt);
603 close_db(handle->handle);
605 return LB_STATUS_SUCCESS;
608 EAPI int livebox_service_get_pkglist(int (*cb)(const char *appid, const char *pkgname, int is_prime, void *data), void *data)
618 return LB_STATUS_ERROR_INVALID;
622 return LB_STATUS_ERROR_IO;
624 ret = sqlite3_prepare_v2(handle, "SELECT appid, pkgid, prime FROM pkgmap", -1, &stmt, NULL);
625 if (ret != SQLITE_OK) {
626 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
627 ret = LB_STATUS_ERROR_IO;
632 while (sqlite3_step(stmt) == SQLITE_ROW) {
633 appid = (char *)sqlite3_column_text(stmt, 0);
634 if (!appid || !strlen(appid)) {
635 ErrPrint("APPID is not valid\n");
639 pkgid = (char *)sqlite3_column_text(stmt, 1);
640 if (!pkgid || !strlen(pkgid)) {
641 ErrPrint("pkgid is not valid\n");
645 is_prime = sqlite3_column_int(stmt, 2);
649 if (cb(appid, pkgid, is_prime, data) < 0) {
650 DbgPrint("Callback stopped package crawling\n");
656 sqlite3_finalize(stmt);
663 EAPI int livebox_service_get_pkglist_by_pkgid(const char *pkgid, int (*cb)(const char *lbid, int is_prime, void *data), void *data)
672 return LB_STATUS_ERROR_INVALID;
676 return LB_STATUS_ERROR_IO;
678 ret = sqlite3_prepare_v2(handle, "SELECT pkgid, prime FROM pkgmap WHERE appid = ?", -1, &stmt, NULL);
679 if (ret != SQLITE_OK) {
680 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
681 ret = LB_STATUS_ERROR_IO;
685 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
686 if (ret != SQLITE_OK) {
687 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
689 sqlite3_finalize(stmt);
690 ret = LB_STATUS_ERROR_IO;
695 while (sqlite3_step(stmt) == SQLITE_ROW) {
696 lbid = (const char *)sqlite3_column_text(stmt, 0);
697 if (!lbid || !strlen(lbid)) {
698 ErrPrint("LBID is not valid\n");
702 is_prime = sqlite3_column_int(stmt, 1);
706 if (cb(lbid, is_prime, data) < 0) {
707 DbgPrint("Callback stopped package crawling\n");
713 sqlite3_finalize(stmt);
720 struct pkgmgr_cbdata {
722 void (*cb)(const char *lbid, const char *appid, void *data);
726 static int pkgmgr_cb(const pkgmgrinfo_appinfo_h handle, void *user_data)
728 struct pkgmgr_cbdata *cbdata = (struct pkgmgr_cbdata *)user_data;
732 ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
734 ErrPrint("Unable to get appid\n");
736 cbdata->cb(cbdata->lbid, appid, cbdata->cbdata);
741 static inline char *pkgmgr_get_mainapp(const char *pkgid)
743 pkgmgrinfo_pkginfo_h handle;
746 if (pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle) != PMINFO_R_OK) {
747 ErrPrint("Unable to get mainapp: %s\n", pkgid);
751 if (pkgmgrinfo_pkginfo_get_mainappid(handle, &ret) == PMINFO_R_OK) {
754 ErrPrint("Failed to get mainappid\n");
755 ret = NULL; /* I cannot believe the pkgmgrinfo_pkginfo_get_mainappid. it maybe able to touch my "ret" even though it fails */
759 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
763 static inline int pkgmgr_get_applist(const char *pkgid, const char *lbid, void (*cb)(const char *lbid, const char *appid, void *data), void *data)
765 struct pkgmgr_cbdata cbdata;
766 pkgmgrinfo_pkginfo_h handle;
769 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
771 ErrPrint("Unable to get pkginfo: %s\n", pkgid);
777 cbdata.cbdata = data;
779 ret = pkgmgrinfo_appinfo_get_list(handle, PM_UI_APP, pkgmgr_cb, &cbdata);
781 ErrPrint("Failed to get applist\n");
783 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
787 EAPI int livebox_service_get_applist(const char *lbid, void (*cb)(const char *lbid, const char *appid, void *data), void *data)
796 return LB_STATUS_ERROR_INVALID;
800 return LB_STATUS_ERROR_IO;
802 ret = sqlite3_prepare_v2(handle, "SELECT appid FROM pkgmap WHERE (pkgid = ?) or (appid = ?)", -1, &stmt, NULL);
803 if (ret != SQLITE_OK) {
804 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
805 ret = LB_STATUS_ERROR_IO;
809 ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
810 if (ret != SQLITE_OK) {
811 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
812 ret = LB_STATUS_ERROR_IO;
816 ret = sqlite3_bind_text(stmt, 2, lbid, -1, SQLITE_TRANSIENT);
817 if (ret != SQLITE_OK) {
818 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
819 ret = LB_STATUS_ERROR_IO;
823 if (sqlite3_step(stmt) != SQLITE_ROW) {
824 ret = LB_STATUS_ERROR_INVALID;
826 sqlite3_finalize(stmt);
830 tmp = (const char *)sqlite3_column_text(stmt, 0);
831 if (!tmp || !strlen(tmp)) {
832 ErrPrint("Invalid package name (%s)\n", lbid);
833 ret = LB_STATUS_ERROR_INVALID;
835 sqlite3_finalize(stmt);
841 ErrPrint("Error: %s\n", strerror(errno));
842 ret = LB_STATUS_ERROR_MEMORY;
844 sqlite3_finalize(stmt);
849 sqlite3_finalize(stmt);
851 ret = pkgmgr_get_applist(pkgid, lbid, cb, data);
859 EAPI char *livebox_service_mainappid(const char *lbid)
874 if (sqlite3_prepare_v2(handle, "SELECT appid, uiapp FROM pkgmap WHERE (pkgid = ?) or (appid = ? and prime = 1)", -1, &stmt, NULL) != SQLITE_OK) {
875 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
879 if (sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
880 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
884 if (sqlite3_bind_text(stmt, 2, lbid, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
885 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
889 if (sqlite3_step(stmt) != SQLITE_ROW) {
891 sqlite3_finalize(stmt);
895 tmp = (const char *)sqlite3_column_text(stmt, 0);
896 if (!tmp || !strlen(tmp)) {
897 ErrPrint("Invalid package name (%s)\n", lbid);
899 sqlite3_finalize(stmt);
903 pkgid = (const char *)sqlite3_column_text(stmt, 1);
904 if (!pkgid || !strlen(pkgid)) {
906 * This record has no uiapp.
907 * Try to find the main ui-app id.
909 ret = pkgmgr_get_mainapp(tmp);
913 ErrPrint("Error: %s\n", strerror(errno));
917 sqlite3_finalize(stmt);
924 EAPI int livebox_service_get_supported_size_types(const char *pkgid, int *cnt, int *types)
931 if (!types || !cnt || !pkgid)
932 return LB_STATUS_ERROR_INVALID;
936 return LB_STATUS_ERROR_IO;
938 ret = sqlite3_prepare_v2(handle, "SELECT size_type FROM box_size WHERE pkgid = ? ORDER BY size_type ASC", -1, &stmt, NULL);
939 if (ret != SQLITE_OK) {
940 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
941 ret = LB_STATUS_ERROR_IO;
945 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
946 if (ret != SQLITE_OK) {
947 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
949 sqlite3_finalize(stmt);
950 ret = LB_STATUS_ERROR_IO;
954 if (*cnt > NR_OF_SIZE_LIST)
955 *cnt = NR_OF_SIZE_LIST;
958 while (sqlite3_step(stmt) == SQLITE_ROW && ret < *cnt) {
959 size = sqlite3_column_int(stmt, 0);
966 sqlite3_finalize(stmt);
973 static inline char *cur_locale(void)
976 language = vconf_get_str(VCONFKEY_LANGSET);
993 language = strdup("en-us");
995 ErrPrint("Heap: %s\n", strerror(errno));
1001 static inline char *get_default_name(const char *pkgid)
1012 ret = sqlite3_prepare_v2(handle, "SELECT name FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1013 if (ret != SQLITE_OK) {
1014 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1019 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1020 if (ret != SQLITE_OK) {
1021 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1025 ret = sqlite3_step(stmt);
1026 if (ret == SQLITE_ROW) {
1029 tmp = (const char *)sqlite3_column_text(stmt, 0);
1030 if (tmp && strlen(tmp)) {
1033 ErrPrint("Heap: %s\n", strerror(errno));
1038 sqlite3_reset(stmt);
1039 sqlite3_finalize(stmt);
1044 static inline char *get_default_icon(const char *pkgid)
1055 ret = sqlite3_prepare_v2(handle, "SELECT icon FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1056 if (ret != SQLITE_OK) {
1057 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1062 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1063 if (ret != SQLITE_OK) {
1064 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1068 ret = sqlite3_step(stmt);
1069 if (ret == SQLITE_ROW) {
1072 tmp = (const char *)sqlite3_column_text(stmt, 0);
1073 if (tmp && strlen(tmp)) {
1076 ErrPrint("Heap: %s\n", strerror(errno));
1081 sqlite3_reset(stmt);
1082 sqlite3_finalize(stmt);
1087 EAPI char *livebox_service_content(const char *pkgid)
1091 char *content = NULL;
1098 ret = sqlite3_prepare_v2(handle, "SELECT content FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1099 if (ret != SQLITE_OK) {
1100 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1105 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1106 if (ret != SQLITE_OK) {
1107 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1111 ret = sqlite3_step(stmt);
1112 if (ret == SQLITE_ROW) {
1115 tmp = (const char *)sqlite3_column_text(stmt, 0);
1116 if (tmp && strlen(tmp)) {
1117 content = strdup(tmp);
1119 ErrPrint("Heap: %s\n", strerror(errno));
1124 sqlite3_reset(stmt);
1125 sqlite3_finalize(stmt);
1130 EAPI char *livebox_service_setup_appid(const char *lbid)
1141 ret = sqlite3_prepare_v2(handle, "SELECT setup FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1142 if (ret != SQLITE_OK) {
1143 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1149 ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1150 if (ret != SQLITE_OK) {
1151 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1155 ret = sqlite3_step(stmt);
1156 if (ret == SQLITE_ROW) {
1159 tmp = (const char *)sqlite3_column_text(stmt, 0);
1160 if (!tmp || !strlen(tmp))
1163 appid = strdup(tmp);
1165 ErrPrint("Error: %s\n", strerror(errno));
1169 sqlite3_reset(stmt);
1170 sqlite3_finalize(stmt);
1175 EAPI int livebox_service_nodisplay(const char *pkgid)
1185 ret = sqlite3_prepare_v2(handle, "SELECT nodisplay FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1186 if (ret != SQLITE_OK) {
1187 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1192 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1193 if (ret != SQLITE_OK) {
1194 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1199 ret = sqlite3_step(stmt);
1200 if (ret == SQLITE_ROW)
1201 ret = !!sqlite3_column_int(stmt, 0);
1206 sqlite3_reset(stmt);
1207 sqlite3_finalize(stmt);
1212 static inline char *get_lb_pkgname_by_appid(const char *appid)
1228 ret = sqlite3_prepare_v2(handle, "SELECT pkgid FROM pkgmap WHERE (appid = ? AND prime = 1) OR pkgid = ?", -1, &stmt, NULL);
1229 if (ret != SQLITE_OK) {
1230 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1235 ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_TRANSIENT);
1236 if (ret != SQLITE_OK) {
1237 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1241 ret = sqlite3_bind_text(stmt, 2, appid, -1, SQLITE_TRANSIENT);
1242 if (ret != SQLITE_OK) {
1243 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1247 if (sqlite3_step(stmt) != SQLITE_ROW) {
1248 ErrPrint("Error: %s (has no record? - %s)\n", sqlite3_errmsg(handle), appid);
1252 tmp = (char *)sqlite3_column_text(stmt, 0);
1253 if (tmp && strlen(tmp)) {
1254 pkgid = strdup(tmp);
1256 ErrPrint("Heap: %s\n", strerror(errno));
1260 sqlite3_reset(stmt);
1261 sqlite3_finalize(stmt);
1266 EAPI int livebox_service_need_frame(const char *pkgid, int size_type)
1275 ErrPrint("Unable to open a DB\n");
1279 ret = sqlite3_prepare_v2(handle, "SELECT need_frame FROM box_size WHERE pkgid = ? AND size_type = ?", -1, &stmt, NULL);
1280 if (ret != SQLITE_OK) {
1281 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1288 lbid = livebox_service_pkgname(pkgid);
1290 ErrPrint("Invalid appid (%s)\n", pkgid);
1295 ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1297 if (ret != SQLITE_OK) {
1298 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1303 ret = sqlite3_bind_int(stmt, 2, size_type);
1304 if (ret != SQLITE_OK) {
1305 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1310 ret = sqlite3_step(stmt);
1311 if (ret == SQLITE_ROW) {
1312 ret = !!sqlite3_column_int(stmt, 0);
1315 ErrPrint("There is no such result\n");
1318 sqlite3_reset(stmt);
1319 sqlite3_finalize(stmt);
1324 EAPI int livebox_service_touch_effect(const char *pkgid, int size_type)
1333 ErrPrint("Unable to open a DB\n");
1337 ret = sqlite3_prepare_v2(handle, "SELECT touch_effect FROM box_size WHERE pkgid = ? AND size_type = ?", -1, &stmt, NULL);
1338 if (ret != SQLITE_OK) {
1339 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1346 * This function will validate the "pkgid"
1347 * call the exported API in the exported API is not recomended
1350 lbid = livebox_service_pkgname(pkgid);
1352 ErrPrint("Invalid appid (%s)\n", pkgid);
1357 ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1359 if (ret != SQLITE_OK) {
1360 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1365 ret = sqlite3_bind_int(stmt, 2, size_type);
1366 if (ret != SQLITE_OK) {
1367 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1372 ret = sqlite3_step(stmt);
1373 if (ret == SQLITE_ROW) {
1374 ret = !!sqlite3_column_int(stmt, 0);
1376 ret = 1; /*!< Default true: In this case the DB is corrupted. */
1377 ErrPrint("There is no result\n");
1381 sqlite3_reset(stmt);
1382 sqlite3_finalize(stmt);
1387 EAPI int livebox_service_mouse_event(const char *pkgid)
1398 ret = sqlite3_prepare_v2(handle, "SELECT mouse_event FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1399 if (ret != SQLITE_OK) {
1400 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1405 lbid = livebox_service_pkgname(pkgid);
1407 ErrPrint("Failed to get lbid: %s\n", pkgid);
1412 ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1414 if (ret != SQLITE_OK) {
1415 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1420 ret = sqlite3_step(stmt);
1421 if (ret == SQLITE_ROW) {
1422 ret = !!sqlite3_column_int(stmt, 0);
1424 ret = 0; /*!< Default is false, In this case the DB is corrupted */
1425 ErrPrint("There is no result.\n");
1429 sqlite3_reset(stmt);
1430 sqlite3_finalize(stmt);
1435 static inline int update_lang_info(void)
1440 syslang = vconf_get_str(VCONFKEY_LANGSET);
1442 ErrPrint("Failed to get vconf-lang\n");
1446 if (s_info.syslang && !strcmp(s_info.syslang, syslang)) {
1447 DbgPrint("Syslang is not changed: %s\n", syslang);
1452 free(s_info.syslang);
1453 s_info.syslang = syslang;
1456 uloc_setDefault((const char *)s_info.syslang, &err);
1457 if (!U_SUCCESS(err)) {
1458 ErrPrint("Failed to set default lang: %s\n", u_errorName(err));
1459 free(s_info.syslang);
1460 s_info.syslang = NULL;
1464 s_info.iso3lang = uloc_getISO3Language(uloc_getDefault());
1465 if (!s_info.iso3lang || !strlen(s_info.iso3lang)) {
1466 ErrPrint("Failed to get iso3lang\n");
1467 free(s_info.syslang);
1468 s_info.syslang = NULL;
1473 s_info.country_len = uloc_getCountry(uloc_getDefault(), s_info.country, ULOC_COUNTRY_CAPACITY, &err);
1474 if (!U_SUCCESS(err) || s_info.country_len <= 0) {
1475 ErrPrint("Failed to get locale: %s, %s, %d (%s)\n", u_errorName(err), s_info.iso3lang, s_info.country_len, s_info.country);
1476 free(s_info.syslang);
1477 s_info.syslang = NULL;
1484 EAPI char *livebox_service_preview(const char *pkgid, int size_type)
1489 char *preview = NULL;
1500 ret = sqlite3_prepare_v2(handle, "SELECT preview FROM box_size WHERE pkgid = ? AND size_type = ?", -1, &stmt, NULL);
1501 if (ret != SQLITE_OK) {
1502 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1507 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1508 if (ret != SQLITE_OK) {
1509 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1513 ret = sqlite3_bind_int(stmt, 2, size_type);
1514 if (ret != SQLITE_OK) {
1515 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1519 ret = sqlite3_step(stmt);
1520 if (ret != SQLITE_ROW) {
1521 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1525 tmp = (const char *)sqlite3_column_text(stmt, 0);
1526 if (!tmp || !(tmp_len = strlen(tmp))) {
1527 ErrPrint("Failed to get data (%s)\n", pkgid);
1531 if (update_lang_info() != 0) {
1532 preview = strdup(tmp);
1534 ErrPrint("Heap: %s\n", strerror(errno));
1539 buf_len = tmp_len + strlen(s_info.iso3lang) + s_info.country_len + 3; /* '/' '-' '/' */
1540 preview = malloc(buf_len + 1);
1542 ErrPrint("Heap: %s\n", strerror(errno));
1546 for (i = tmp_len; i >= 0 && tmp[i] != '/'; i--);
1549 strncpy(preview, tmp, i);
1550 printed = snprintf(preview + i, buf_len - i, "%s-%s/%s", s_info.iso3lang, s_info.country, tmp + i);
1551 if (preview[i + printed] != '\0') {
1552 ErrPrint("Path is truncated\n");
1553 preview[i + printed] = '\0';
1556 if (access(preview, R_OK) != 0) {
1557 DbgPrint("Access failed: %s, %s\n", preview, strerror(errno));
1560 preview = strdup(tmp);
1562 ErrPrint("Heap: %s\n", strerror(errno));
1567 sqlite3_reset(stmt);
1568 sqlite3_finalize(stmt);
1573 EAPI char *livebox_service_i18n_icon(const char *pkgid, const char *lang)
1582 language = strdup(lang);
1584 ErrPrint("Heap: %s\n", strerror(errno));
1588 language = cur_locale();
1599 ret = sqlite3_prepare_v2(handle, "SELECT icon FROM i18n WHERE pkgid = ? AND lang = ?", -1, &stmt, NULL);
1600 if (ret != SQLITE_OK) {
1601 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1607 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1608 if (ret != SQLITE_OK) {
1609 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1613 ret = sqlite3_bind_text(stmt, 2, language, -1, SQLITE_TRANSIENT);
1614 if (ret != SQLITE_OK) {
1615 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1619 ret = sqlite3_step(stmt);
1620 if (ret == SQLITE_ROW) {
1622 tmp = (const char *)sqlite3_column_text(stmt, 0);
1623 if (!tmp || !strlen(tmp)) {
1624 icon = get_default_icon(pkgid);
1628 ErrPrint("Heap: %s\n", strerror(errno));
1631 icon = get_default_icon(pkgid);
1635 sqlite3_reset(stmt);
1636 sqlite3_finalize(stmt);
1642 EAPI char *livebox_service_i18n_name(const char *pkgid, const char *lang)
1651 language = strdup(lang);
1653 ErrPrint("Error: %s\n", strerror(errno));
1657 language = cur_locale();
1668 ret = sqlite3_prepare_v2(handle, "SELECT name FROM i18n WHERE pkgid = ? AND lang = ?", -1, &stmt, NULL);
1669 if (ret != SQLITE_OK) {
1670 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1676 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1677 if (ret != SQLITE_OK) {
1678 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1682 ret = sqlite3_bind_text(stmt, 2, language, -1, SQLITE_TRANSIENT);
1683 if (ret != SQLITE_OK) {
1684 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1688 ret = sqlite3_step(stmt);
1689 if (ret == SQLITE_ROW) {
1691 tmp = (const char *)sqlite3_column_text(stmt, 0);
1692 if (!tmp || !strlen(tmp)) {
1693 name = get_default_name(pkgid);
1697 ErrPrint("Heap: %s\n", strerror(errno));
1700 name = get_default_name(pkgid);
1704 sqlite3_reset(stmt);
1705 sqlite3_finalize(stmt);
1711 EAPI int livebox_service_get_supported_sizes(const char *pkgid, int *cnt, int *w, int *h)
1718 if (!w || !h || !cnt || !pkgid)
1719 return LB_STATUS_ERROR_INVALID;
1723 return LB_STATUS_ERROR_IO;
1725 ret = sqlite3_prepare_v2(handle, "SELECT size_type FROM box_size WHERE pkgid = ? ORDER BY size_type ASC", -1, &stmt, NULL);
1726 if (ret != SQLITE_OK) {
1727 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1728 ret = LB_STATUS_ERROR_IO;
1732 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1733 if (ret != SQLITE_OK) {
1734 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1735 sqlite3_reset(stmt);
1736 sqlite3_finalize(stmt);
1737 ret = LB_STATUS_ERROR_IO;
1741 if (*cnt > NR_OF_SIZE_LIST)
1742 *cnt = NR_OF_SIZE_LIST;
1745 while (sqlite3_step(stmt) == SQLITE_ROW && ret < *cnt) {
1746 size = sqlite3_column_int(stmt, 0);
1747 ret += (convert_size_from_type(size, w + ret, h + ret) == 0);
1751 sqlite3_reset(stmt);
1752 sqlite3_finalize(stmt);
1759 EAPI char *livebox_service_libexec(const char *pkgid)
1776 ret = sqlite3_prepare_v2(handle, "SELECT pkgmap.appid, provider.libexec FROM pkgmap, provider WHERE pkgmap.pkgid = ? AND provider.pkgid = ?", -1, &stmt, NULL);
1777 if (ret != SQLITE_OK) {
1778 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1782 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1783 if (ret != SQLITE_OK) {
1784 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1785 sqlite3_finalize(stmt);
1789 ret = sqlite3_bind_text(stmt, 2, pkgid, -1, SQLITE_TRANSIENT);
1790 if (ret != SQLITE_OK) {
1791 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1792 sqlite3_finalize(stmt);
1796 if (sqlite3_step(stmt) != SQLITE_ROW) {
1797 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1798 sqlite3_reset(stmt);
1799 sqlite3_finalize(stmt);
1801 libexec = util_conf_get_libexec(pkgid);
1802 DbgPrint("Fallback to conf checker: %s\n", libexec);
1806 appid = (char *)sqlite3_column_text(stmt, 0);
1807 if (!appid || !strlen(appid)) {
1808 ErrPrint("Invalid appid: %s\n", sqlite3_errmsg(handle));
1809 sqlite3_reset(stmt);
1810 sqlite3_finalize(stmt);
1814 path = (char *)sqlite3_column_text(stmt, 1);
1815 if (!path || !strlen(path)) {
1816 ErrPrint("Invalid libexec: %s\n", sqlite3_errmsg(handle));
1817 sqlite3_reset(stmt);
1818 sqlite3_finalize(stmt);
1822 libexec = strdup(path);
1824 ErrPrint("Heap: %s\n", strerror(errno));
1825 sqlite3_reset(stmt);
1826 sqlite3_finalize(stmt);
1830 DbgPrint("libexec: %s\n", libexec);
1832 sqlite3_reset(stmt);
1833 sqlite3_finalize(stmt);
1839 EAPI char *livebox_service_pkgname(const char *appid)
1842 pkgmgr_appinfo_h handle;
1849 lb_pkgname = get_lb_pkgname_by_appid(appid);
1855 * Try to get the package id using given appid
1857 ret = pkgmgr_appinfo_get_appinfo(appid, &handle);
1858 if (ret != PKGMGR_R_OK) {
1859 ErrPrint("Failed to get appinfo\n");
1863 ret = pkgmgr_appinfo_get_pkgname(handle, &new_appid);
1864 if (ret != PKGMGR_R_OK) {
1865 pkgmgr_appinfo_destroy_appinfo(handle);
1866 ErrPrint("Failed to get pkgname for (%s)\n", appid);
1870 lb_pkgname = get_lb_pkgname_by_appid(new_appid);
1871 pkgmgr_appinfo_destroy_appinfo(handle);
1873 if (!lb_pkgname && util_validate_livebox_package(appid) == 0)
1874 return strdup(appid);
1879 EAPI char *livebox_service_provider_name(const char *lbid)
1885 char *str = SAMSUNG_PREFIX;
1890 while (str[idx] && lbid[idx] && lbid[idx] == str[idx]) {
1892 if (seq < 2 && lbid[idx] == '.') {
1898 if (!str[idx] && lbid[idx]) {
1900 return strdup(lbid);
1901 } else if (seq < 2) {
1903 if (lbid[idx] == '.') {
1905 } else if (!lbid[idx]) {
1906 ErrPrint("Invalid lbid: %s\n", lbid);
1918 ret = strdup(lbid + stage);
1920 ErrPrint("Error: %s\n", strerror(errno));
1927 EAPI int livebox_service_is_enabled(const char *lbid)
1936 pkgname = livebox_service_appid(lbid);
1940 ret = ail_get_appinfo(pkgname, &ai);
1941 if (ret != AIL_ERROR_OK) {
1946 if (ail_appinfo_get_bool(ai, AIL_PROP_X_SLP_ENABLED_BOOL, &enabled) != AIL_ERROR_OK)
1949 ail_destroy_appinfo(ai);
1951 return enabled == true;
1955 EAPI int livebox_service_is_primary(const char *lbid)
1968 ret = sqlite3_prepare_v2(handle, "SELECT prime FROM pkgmap WHERE pkgid = ?", -1, &stmt, NULL);
1969 if (ret != SQLITE_OK) {
1970 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1975 ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1976 if (ret != SQLITE_OK) {
1977 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1981 ret = sqlite3_step(stmt);
1982 if (ret != SQLITE_ROW) {
1983 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1987 ret = sqlite3_column_int(stmt, 0);
1990 sqlite3_reset(stmt);
1991 sqlite3_finalize(stmt);
1997 * appid == Package ID
1998 * pkgid == Livebox ID
2000 EAPI char *livebox_service_appid(const char *pkgname)
2006 int is_prime __attribute__((__unused__));
2017 ret = sqlite3_prepare_v2(handle, "SELECT appid, prime FROM pkgmap WHERE pkgid = ? OR appid = ?", -1, &stmt, NULL);
2018 if (ret != SQLITE_OK) {
2019 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2023 ret = sqlite3_bind_text(stmt, 1, pkgname, -1, SQLITE_TRANSIENT);
2024 if (ret != SQLITE_OK) {
2025 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2026 sqlite3_reset(stmt);
2027 sqlite3_finalize(stmt);
2031 ret = sqlite3_bind_text(stmt, 2, pkgname, -1, SQLITE_TRANSIENT);
2032 if (ret != SQLITE_OK) {
2033 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2034 sqlite3_reset(stmt);
2035 sqlite3_finalize(stmt);
2039 ret = sqlite3_step(stmt);
2040 if (ret != SQLITE_ROW) {
2041 pkgmgr_appinfo_h pkg_handle;
2044 ErrPrint("Has no record?: %s\n", sqlite3_errmsg(handle));
2045 sqlite3_reset(stmt);
2046 sqlite3_finalize(stmt);
2048 ret = pkgmgr_appinfo_get_appinfo(pkgname, &pkg_handle);
2049 if (ret != PKGMGR_R_OK) {
2050 ErrPrint("Failed to get appinfo: %s\n", pkgname);
2054 ret = pkgmgr_appinfo_get_pkgname(pkg_handle, &new_appid);
2055 if (ret != PKGMGR_R_OK) {
2056 ErrPrint("Failed to get pkgname for (%s)\n", appid);
2057 pkgmgr_appinfo_destroy_appinfo(pkg_handle);
2061 appid = strdup(new_appid);
2063 ErrPrint("Heap: %s\n", strerror(errno));
2065 pkgmgr_appinfo_destroy_appinfo(pkg_handle);
2069 tmp = (char *)sqlite3_column_text(stmt, 0);
2070 if (!tmp || !strlen(tmp)) {
2071 ErrPrint("APPID is NIL\n");
2072 sqlite3_reset(stmt);
2073 sqlite3_finalize(stmt);
2077 appid = strdup(tmp);
2079 ErrPrint("Heap: %s\n", strerror(errno));
2080 sqlite3_reset(stmt);
2081 sqlite3_finalize(stmt);
2085 is_prime = sqlite3_column_int(stmt, 1);
2087 sqlite3_reset(stmt);
2088 sqlite3_finalize(stmt);
2094 EAPI char *livebox_service_lb_script_path(const char *pkgid)
2111 ret = sqlite3_prepare_v2(handle, "SELECT pkgmap.appid, provider.box_src FROM provider, pkgmap WHERE pkgmap.pkgid = ? AND provider.pkgid = ?", -1, &stmt, NULL);
2112 if (ret != SQLITE_OK) {
2113 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2117 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2118 if (ret != SQLITE_OK) {
2119 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2120 sqlite3_finalize(stmt);
2124 ret = sqlite3_bind_text(stmt, 2, pkgid, -1, SQLITE_TRANSIENT);
2125 if (ret != SQLITE_OK) {
2126 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2127 sqlite3_finalize(stmt);
2131 ret = sqlite3_step(stmt);
2132 if (ret != SQLITE_ROW) {
2133 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2134 sqlite3_reset(stmt);
2135 sqlite3_finalize(stmt);
2139 appid = (char *)sqlite3_column_text(stmt, 0);
2140 if (!appid || !strlen(appid)) {
2141 ErrPrint("Invalid appid : %s\n", sqlite3_errmsg(handle));
2142 sqlite3_reset(stmt);
2143 sqlite3_finalize(stmt);
2147 lb_src = (char *)sqlite3_column_text(stmt, 1);
2148 if (!lb_src || !strlen(lb_src)) {
2149 ErrPrint("No records for lb src : %s\n", sqlite3_errmsg(handle));
2150 sqlite3_reset(stmt);
2151 sqlite3_finalize(stmt);
2155 path = strdup(lb_src);
2157 ErrPrint("Heap: %s\n", strerror(errno));
2158 sqlite3_reset(stmt);
2159 sqlite3_finalize(stmt);
2163 DbgPrint("LB Src: %s\n", path);
2164 sqlite3_reset(stmt);
2165 sqlite3_finalize(stmt);
2171 EAPI char *livebox_service_lb_script_group(const char *pkgid)
2187 ret = sqlite3_prepare_v2(handle, "SELECT box_group FROM provider WHERE pkgid = ?", -1, &stmt, NULL);
2188 if (ret != SQLITE_OK) {
2189 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2193 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2194 if (ret != SQLITE_OK) {
2195 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2196 sqlite3_finalize(stmt);
2200 ret = sqlite3_step(stmt);
2201 if (ret != SQLITE_ROW) {
2202 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2203 sqlite3_reset(stmt);
2204 sqlite3_finalize(stmt);
2208 tmp = (char *)sqlite3_column_text(stmt, 0);
2209 if (tmp && strlen(tmp)) {
2210 group = strdup(tmp);
2212 ErrPrint("Heap: %s\n", strerror(errno));
2215 sqlite3_reset(stmt);
2216 sqlite3_finalize(stmt);
2222 EAPI char *livebox_service_pd_script_path(const char *pkgid)
2239 ret = sqlite3_prepare_v2(handle, "SELECT pkgmap.appid, provider.pd_src FROM provider, pkgmap WHERE provider.pkgid = ? AND pkgmap.pkgid = ?", -1, &stmt, NULL);
2240 if (ret != SQLITE_OK) {
2241 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2245 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2246 if (ret != SQLITE_OK) {
2247 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2248 sqlite3_finalize(stmt);
2252 ret = sqlite3_bind_text(stmt, 2, pkgid, -1, SQLITE_TRANSIENT);
2253 if (ret != SQLITE_OK) {
2254 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2255 sqlite3_finalize(stmt);
2259 ret = sqlite3_step(stmt);
2260 if (ret != SQLITE_ROW) {
2261 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2262 sqlite3_reset(stmt);
2263 sqlite3_finalize(stmt);
2267 appid = (char *)sqlite3_column_text(stmt, 0);
2268 if (!appid || !strlen(appid)) {
2269 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2270 sqlite3_reset(stmt);
2271 sqlite3_finalize(stmt);
2275 pd_src = (char *)sqlite3_column_text(stmt, 1);
2276 if (!pd_src || !strlen(pd_src)) {
2277 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2278 sqlite3_reset(stmt);
2279 sqlite3_finalize(stmt);
2283 path = strdup(pd_src);
2285 ErrPrint("Heap: %s\n", strerror(errno));
2286 sqlite3_reset(stmt);
2287 sqlite3_finalize(stmt);
2291 DbgPrint("PD Src: %s\n", path);
2292 sqlite3_reset(stmt);
2293 sqlite3_finalize(stmt);
2299 EAPI char *livebox_service_pd_script_group(const char *pkgid)
2315 ret = sqlite3_prepare_v2(handle, "SELECT pd_group FROM provider WHERE pkgid = ?", -1, &stmt, NULL);
2316 if (ret != SQLITE_OK) {
2317 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2321 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2322 if (ret != SQLITE_OK) {
2323 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2324 sqlite3_finalize(stmt);
2328 ret = sqlite3_step(stmt);
2329 if (ret != SQLITE_ROW) {
2330 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2331 sqlite3_reset(stmt);
2332 sqlite3_finalize(stmt);
2336 tmp = (char *)sqlite3_column_text(stmt, 0);
2337 if (tmp && strlen(tmp)) {
2338 group = strdup(tmp);
2340 ErrPrint("Heap: %s\n", strerror(errno));
2342 sqlite3_reset(stmt);
2343 sqlite3_finalize(stmt);
2349 EAPI int livebox_service_enumerate_cluster_list(int (*cb)(const char *cluster, void *data), void *data)
2353 const char *cluster;
2358 return LB_STATUS_ERROR_INVALID;
2362 return LB_STATUS_ERROR_IO;
2365 ret = sqlite3_prepare_v2(handle, "SELECT DISTINCT cluster FROM groupinfo", -1, &stmt, NULL);
2366 if (ret != SQLITE_OK) {
2367 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2368 cnt = LB_STATUS_ERROR_IO;
2372 while (sqlite3_step(stmt) == SQLITE_ROW) {
2373 cluster = (const char *)sqlite3_column_text(stmt, 0);
2374 if (!cluster || !strlen(cluster))
2377 if (cb(cluster, data) < 0)
2383 sqlite3_reset(stmt);
2384 sqlite3_finalize(stmt);
2390 EAPI int livebox_service_enumerate_category_list(const char *cluster, int (*cb)(const char *cluster, const char *category, void *data), void *data)
2394 const char *category;
2398 if (!cluster || !cb)
2399 return LB_STATUS_ERROR_INVALID;
2403 return LB_STATUS_ERROR_IO;
2405 ret = sqlite3_prepare_v2(handle, "SELECT DISTINCT category FROM groupinfo WHERE cluster = ?", -1, &stmt, NULL);
2406 if (ret != SQLITE_OK) {
2407 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2408 cnt = LB_STATUS_ERROR_IO;
2413 while (sqlite3_step(stmt) == SQLITE_ROW) {
2414 category = (const char *)sqlite3_column_text(stmt, 0);
2415 if (!category || !strlen(category))
2418 if (cb(cluster, category, data) < 0)
2424 sqlite3_reset(stmt);
2425 sqlite3_finalize(stmt);
2431 EAPI int livebox_service_init(void)
2433 if (s_info.handle) {
2434 DbgPrint("Already initialized\n");
2435 s_info.init_count++;
2439 s_info.handle = open_db();
2440 if (s_info.handle) {
2441 s_info.init_count++;
2445 return LB_STATUS_ERROR_IO;
2448 EAPI int livebox_service_fini(void)
2450 if (!s_info.handle || s_info.init_count <= 0) {
2451 ErrPrint("Service is not initialized\n");
2452 return LB_STATUS_ERROR_IO;
2455 s_info.init_count--;
2456 if (s_info.init_count > 0) {
2457 DbgPrint("Init count %d\n", s_info.init_count);
2461 db_util_close(s_info.handle);
2462 s_info.handle = NULL;
2466 EAPI int livebox_service_get_size(int type, int *width, int *height)
2477 return convert_size_from_type(type, width, height);
2480 EAPI int livebox_service_size_type(int width, int height)
2484 if (update_resolution() < 0)
2485 ErrPrint("Failed to update the size list\n");
2487 for (idx = 0; idx < NR_OF_SIZE_LIST; idx++) {
2488 if (SIZE_LIST[idx].w == width && SIZE_LIST[idx].h == height)
2494 return LB_SIZE_TYPE_1x1;
2496 return LB_SIZE_TYPE_2x1;
2498 return LB_SIZE_TYPE_2x2;
2500 return LB_SIZE_TYPE_4x1;
2502 return LB_SIZE_TYPE_4x2;
2504 return LB_SIZE_TYPE_4x3;
2506 return LB_SIZE_TYPE_4x4;
2508 return LB_SIZE_TYPE_4x5;
2510 return LB_SIZE_TYPE_4x6;
2512 return LB_SIZE_TYPE_EASY_1x1;
2514 return LB_SIZE_TYPE_EASY_3x1;
2516 return LB_SIZE_TYPE_EASY_3x3;
2518 return LB_SIZE_TYPE_0x0;
2523 return LB_SIZE_TYPE_UNKNOWN;