src/livebox-service.c

   1 /*
   2  * Copyright 2013  Samsung Electronics Co., Ltd
   3  *
   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
   7  *
   8  * http://floralicense.org/license/
   9  *
  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.
  15  */
  16
  17 #include <stdio.h>
  18 #include <errno.h>
  19 #include <stdlib.h> /* malloc */
  20 #include <string.h> /* strdup, strerror */
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <unistd.h>
  24 #include <sqlite3.h>
  25 #include <ctype.h>
  26
  27 #include <com-core_packet.h>
  28 #include <packet.h>
  29 #include <dlog.h>
  30 #include <db-util.h>
  31 #include <package-manager.h>
  32 #include <pkgmgr-info.h>
  33 #include <vconf.h>
  34 #include <vconf-keys.h>
  35 #include <ail.h>
  36 #include <unicode/uloc.h>
  37 #include <tzplatform_config.h>
  38
  39 #include "dlist.h"
  40 #include "util.h"
  41 #include "debug.h"
  42 #include "livebox-service.h"
  43 #include "livebox-errno.h"
  44
  45 #define SAMSUNG_PREFIX  "com.samsung."
  46 #define EAPI __attribute__((visibility("default")))
  47 #define DEFAULT_TIMEOUT 2.0
  48 #define SERVICE_SOCKET tzplatform_mkpath(TZ_USER_SHARE,"live_magazine/.service.socket")
  49
  50 static struct supported_size_list SIZE_LIST[NR_OF_SIZE_LIST] = {
  51         { 175, 175 }, /*!< 1x1 */
  52         { 354, 175 }, /*!< 2x1 */
  53         { 354, 354 }, /*!< 2x2 */
  54         { 712, 175 }, /*!< 4x1 */
  55         { 712, 354 }, /*!< 4x2 */
  56         { 712, 533 }, /*!< 4x3 */
  57         { 712, 712 }, /*!< 4x4 */
  58         { 712, 891 }, /*!< 4x5 */
  59         { 712, 1070 }, /*!< 4x6 */
  60         { 224, 215 }, /*!< 21x21 */
  61         { 680, 215 }, /*!< 23x21 */
  62         { 680, 653 }, /*!< 23x23 */
  63         { 720, 1280 }, /*!< 0x0 */
  64 };
  65
  66 struct pkglist_handle {
  67         enum pkglist_type {
  68                 PKGLIST_TYPE_LB_LIST = 0x00beef00,
  69                 PKGLIST_TYPE_UNKNOWN = 0x00dead00
  70         } type;
  71         sqlite3 *handle;
  72         sqlite3_stmt *stmt;
  73 };
  74
  75 static struct service_info s_info = {
  76         .handle = NULL,
  77         .conf_file = RESOLUTION_FILE,
  78         .init_count = 0,
  79
  80         .iso3lang = NULL,
  81         .country = { 0, },
  82         .syslang = NULL,
  83         .country_len = 0,
  84
  85         .base_w = 720,
  86         .base_h = 1280,
  87
  88         .base_parse = 0,
  89 };
  90
  91 static sqlite3 *open_db(void)
  92 {
  93         sqlite3 *handle;
  94
  95         if (!s_info.handle) {
  96                 int ret;
  97
  98                 ret = db_util_open_with_options(tzplatform_mkpath(TZ_SYS_DB,".livebox.db"), &handle, SQLITE_OPEN_READONLY, NULL);
  99                 if (ret != SQLITE_OK) {
 100                         ErrPrint("Failed to open a DB\n");
 101                         return NULL;
 102                 }
 103         } else {
 104                 handle = s_info.handle;
 105         }
 106
 107         return handle;
 108 }
 109
 110 static inline __attribute__((always_inline)) void close_db(sqlite3 *handle)
 111 {
 112         if (!s_info.handle) {
 113                 db_util_close(handle);
 114         }
 115 }
 116
 117 static int convert_size_from_type(enum livebox_size_type type, int *width, int *height)
 118 {
 119         int idx;
 120
 121         switch (type) {
 122         case LB_SIZE_TYPE_1x1: /*!< 175x175 */
 123                 idx = 0;
 124                 break;
 125         case LB_SIZE_TYPE_2x1: /*!< 354x175 */
 126                 idx = 1;
 127                 break;
 128         case LB_SIZE_TYPE_2x2: /*!< 354x354 */
 129                 idx = 2;
 130                 break;
 131         case LB_SIZE_TYPE_4x1: /*!< 712x175 */
 132                 idx = 3;
 133                 break;
 134         case LB_SIZE_TYPE_4x2: /*!< 712x354 */
 135                 idx = 4;
 136                 break;
 137         case LB_SIZE_TYPE_4x3: /*!< 712x533 */
 138                 idx = 5;
 139                 break;
 140         case LB_SIZE_TYPE_4x4: /*!< 712x712 */
 141                 idx = 6;
 142                 break;
 143         case LB_SIZE_TYPE_4x5: /*!< 712x891 */
 144                 idx = 7;
 145                 break;
 146         case LB_SIZE_TYPE_4x6: /*!< 712x1070 */
 147                 idx = 8;
 148                 break;
 149         case LB_SIZE_TYPE_EASY_1x1: /*< 224x215 */
 150                 idx = 9;
 151                 break;
 152         case LB_SIZE_TYPE_EASY_3x1: /*!< 680x215 */
 153                 idx = 10;
 154                 break;
 155         case LB_SIZE_TYPE_EASY_3x3: /*!< 680x653 */
 156                 idx = 11;
 157                 break;
 158         case LB_SIZE_TYPE_0x0: /*!< 720x1280 */
 159                 idx = 12;
 160                 break;
 161         default:
 162                 return LB_STATUS_ERROR_INVALID;
 163         }
 164
 165         if (util_update_resolution(&s_info, SIZE_LIST) < 0) {
 166                 ErrPrint("Failed to update resolution\n");
 167         }
 168
 169         *width = SIZE_LIST[idx].w;
 170         *height = SIZE_LIST[idx].h;
 171         return LB_STATUS_SUCCESS;
 172 }
 173
 174 EAPI int livebox_service_change_period(const char *pkgname, const char *id, double period)
 175 {
 176         struct packet *packet;
 177         struct packet *result;
 178         char *uri;
 179         int ret;
 180
 181         if (!pkgname || !id || period < 0.0f) {
 182                 ErrPrint("Invalid argument\n");
 183                 return LB_STATUS_ERROR_INVALID;
 184         }
 185
 186         uri = util_id_to_uri(id);
 187         if (!uri) {
 188                 return LB_STATUS_ERROR_MEMORY;
 189         }
 190
 191         packet = packet_create("service_change_period", "ssd", pkgname, uri, period);
 192         free(uri);
 193         if (!packet) {
 194                 ErrPrint("Failed to create a packet for period changing\n");
 195                 return LB_STATUS_ERROR_FAULT;
 196         }
 197
 198         result = com_core_packet_oneshot_send(SERVICE_SOCKET, packet, DEFAULT_TIMEOUT);
 199         packet_unref(packet);
 200
 201         if (result) {
 202                 if (packet_get(result, "i", &ret) != 1) {
 203                         ErrPrint("Failed to parse a result packet\n");
 204                         ret = LB_STATUS_ERROR_INVALID;
 205                 }
 206                 packet_unref(result);
 207         } else {
 208                 ErrPrint("Failed to get result packet\n");
 209                 ret = LB_STATUS_ERROR_FAULT;
 210         }
 211
 212         return ret;
 213 }
 214
 215 EAPI int livebox_service_trigger_update_with_content(const char *pkgname, const char *id, const char *cluster, const char *category, const char *content, int force)
 216 {
 217         struct packet *packet;
 218         struct packet *result;
 219         char *uri;
 220         int ret;
 221
 222         if (!pkgname) {
 223                 ErrPrint("Invalid argument\n");
 224                 return LB_STATUS_ERROR_INVALID;
 225         }
 226
 227         if (!force && access("/tmp/.live.paused", R_OK) == 0) {
 228                 DbgPrint("Provider is paused\n");
 229                 return LB_STATUS_ERROR_CANCEL;
 230         }
 231
 232         if (id) {
 233                 uri = util_id_to_uri(id);
 234                 if (!uri) {
 235                         return LB_STATUS_ERROR_MEMORY;
 236                 }
 237         } else {
 238                 uri = NULL;
 239         }
 240
 241         if (!cluster) {
 242                 cluster = "user,created";
 243         }
 244
 245         if (!category) {
 246                 category = "default";
 247         }
 248
 249         packet = packet_create("service_update", "sssssi", pkgname, uri, cluster, category, content, force);
 250         /*!
 251          * \note
 252          * "free" function accepts NULL
 253          */
 254         free(uri);
 255         if (!packet) {
 256                 ErrPrint("Failed to create a packet for service_update\n");
 257                 return LB_STATUS_ERROR_FAULT;
 258         }
 259
 260         result = com_core_packet_oneshot_send(SERVICE_SOCKET, packet, DEFAULT_TIMEOUT);
 261         packet_unref(packet);
 262
 263         if (result) {
 264                 if (packet_get(result, "i", &ret) != 1) {
 265                         ErrPrint("Failed to parse a result packet\n");
 266                         ret = LB_STATUS_ERROR_INVALID;
 267                 }
 268
 269                 packet_unref(result);
 270         } else {
 271                 ErrPrint("Failed to get result packet\n");
 272                 ret = LB_STATUS_ERROR_FAULT;
 273         }
 274
 275         return ret;
 276 }
 277
 278 EAPI int livebox_service_trigger_update(const char *pkgname, const char *id, const char *cluster, const char *category, int force)
 279 {
 280         return livebox_service_trigger_update_with_content(pkgname, id, cluster, category, NULL, force);
 281 }
 282
 283 /*!
 284  * pkgid == Package Id (not the livebox id)
 285  */
 286 EAPI struct pkglist_handle *livebox_service_pkglist_create(const char *pkgid, struct pkglist_handle *handle)
 287 {
 288         int ret;
 289
 290         if (handle) {
 291                 if (handle->type != PKGLIST_TYPE_LB_LIST) {
 292                         ErrPrint("Invalid handle\n");
 293                         return NULL;
 294                 }
 295
 296                 if (pkgid) {
 297                         ErrPrint("pkgid should be NULL\n");
 298                         return NULL;
 299                 }
 300
 301                 sqlite3_reset(handle->stmt);
 302                 return handle;
 303         }
 304
 305         handle = calloc(1, sizeof(*handle));
 306         if (!handle) {
 307                 ErrPrint("Heap: %s\n", strerror(errno));
 308                 return NULL;
 309         }
 310
 311         handle->type = PKGLIST_TYPE_LB_LIST;
 312
 313         handle->handle = open_db();
 314         if (!handle->handle) {
 315                 free(handle);
 316                 return NULL;
 317         }
 318
 319         if (!pkgid) {
 320                 ret = sqlite3_prepare_v2(handle->handle, "SELECT appid, pkgid, prime FROM pkgmap", -1, &handle->stmt, NULL);
 321                 if (ret != SQLITE_OK) {
 322                         ErrPrint("Error: %s\n", sqlite3_errmsg(handle->handle));
 323                         close_db(handle->handle);
 324                         free(handle);
 325                         return NULL;
 326                 }
 327         } else {
 328                 ret = sqlite3_prepare_v2(handle->handle, "SELECT appid, pkgid, prime FROM pkgmap WHERE appid = ?", -1, &handle->stmt, NULL);
 329                 if (ret != SQLITE_OK) {
 330                         ErrPrint("Error: %s\n", sqlite3_errmsg(handle->handle));
 331                         close_db(handle->handle);
 332                         free(handle);
 333                         return NULL;
 334                 }
 335
 336                 ret = sqlite3_bind_text(handle->stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
 337                 if (ret != SQLITE_OK) {
 338                         ErrPrint("Error: %s\n", sqlite3_errmsg(handle->handle));
 339                         sqlite3_finalize(handle->stmt);
 340                         close_db(handle->handle);
 341                         free(handle);
 342                         return NULL;
 343                 }
 344         }
 345
 346         return handle;
 347 }
 348
 349 EAPI int livebox_service_get_pkglist_item(struct pkglist_handle *handle, char **appid, char **pkgname, int *is_prime)
 350 {
 351         const char *tmp;
 352         char *_appid = NULL;
 353         char *_pkgname = NULL;
 354
 355         if (!handle || handle->type != PKGLIST_TYPE_LB_LIST) {
 356                 return LB_STATUS_ERROR_INVALID;
 357         }
 358
 359         if (sqlite3_step(handle->stmt) != SQLITE_ROW) {
 360                 return LB_STATUS_ERROR_NOT_EXIST;
 361         }
 362
 363         if (appid) {
 364                 tmp = (const char *)sqlite3_column_text(handle->stmt, 0);
 365                 if (tmp && strlen(tmp)) {
 366                         _appid = strdup(tmp);
 367                         if (!_appid) {
 368                                 ErrPrint("Heap: %s\n", strerror(errno));
 369                                 return LB_STATUS_ERROR_MEMORY;
 370                         }
 371                 }
 372         }
 373
 374         if (pkgname) {
 375                 tmp = (const char *)sqlite3_column_text(handle->stmt, 1);
 376                 if (tmp && strlen(tmp)) {
 377                         _pkgname = strdup(tmp);
 378                         if (!_pkgname) {
 379                                 ErrPrint("Heap: %s\n", strerror(errno));
 380                                 free(_appid);
 381                                 return LB_STATUS_ERROR_MEMORY;
 382                         }
 383                 }
 384         }
 385
 386         if (is_prime) {
 387                 *is_prime = sqlite3_column_int(handle->stmt, 2);
 388         }
 389
 390         if (appid) {
 391                 *appid = _appid;
 392         }
 393
 394         if (pkgname) {
 395                 *pkgname = _pkgname;
 396         }
 397
 398         return LB_STATUS_SUCCESS;
 399 }
 400
 401 EAPI int livebox_service_pkglist_destroy(struct pkglist_handle *handle)
 402 {
 403         if (!handle || handle->type != PKGLIST_TYPE_LB_LIST) {
 404                 return LB_STATUS_ERROR_INVALID;
 405         }
 406
 407         handle->type = PKGLIST_TYPE_UNKNOWN;
 408         sqlite3_reset(handle->stmt);
 409         sqlite3_finalize(handle->stmt);
 410         close_db(handle->handle);
 411         free(handle);
 412         return LB_STATUS_SUCCESS;
 413 }
 414
 415 EAPI int livebox_service_get_pkglist(int (*cb)(const char *appid, const char *pkgname, int is_prime, void *data), void *data)
 416 {
 417         int ret;
 418         sqlite3_stmt *stmt;
 419         char *appid;
 420         char *pkgid;
 421         int is_prime;
 422         sqlite3 *handle;
 423
 424         if (!cb) {
 425                 return LB_STATUS_ERROR_INVALID;
 426         }
 427
 428         handle = open_db();
 429         if (!handle) {
 430                 return LB_STATUS_ERROR_IO;
 431         }
 432
 433         ret = sqlite3_prepare_v2(handle, "SELECT appid, pkgid, prime FROM pkgmap", -1, &stmt, NULL);
 434         if (ret != SQLITE_OK) {
 435                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 436                 ret = LB_STATUS_ERROR_IO;
 437                 goto out;
 438         }
 439
 440         ret = 0;
 441         while (sqlite3_step(stmt) == SQLITE_ROW) {
 442                 appid = (char *)sqlite3_column_text(stmt, 0);
 443                 if (!appid || !strlen(appid)) {
 444                         ErrPrint("APPID is not valid\n");
 445                         continue;
 446                 }
 447
 448                 pkgid = (char *)sqlite3_column_text(stmt, 1);
 449                 if (!pkgid || !strlen(pkgid)) {
 450                         ErrPrint("pkgid is not valid\n");
 451                         continue;
 452                 }
 453
 454                 is_prime = sqlite3_column_int(stmt, 2);
 455
 456                 ret++;
 457
 458                 if (cb(appid, pkgid, is_prime, data) < 0) {
 459                         DbgPrint("Callback stopped package crawling\n");
 460                         break;
 461                 }
 462         }
 463
 464         sqlite3_reset(stmt);
 465         sqlite3_finalize(stmt);
 466
 467 out:
 468         close_db(handle);
 469         return ret;
 470 }
 471
 472 EAPI int livebox_service_get_pkglist_by_pkgid(const char *pkgid, int (*cb)(const char *lbid, int is_prime, void *data), void *data)
 473 {
 474         int ret;
 475         sqlite3_stmt *stmt;
 476         const char *lbid;
 477         int is_prime;
 478         sqlite3 *handle;
 479
 480         if (!cb || !pkgid) {
 481                 return LB_STATUS_ERROR_INVALID;
 482         }
 483
 484         handle = open_db();
 485         if (!handle) {
 486                 return LB_STATUS_ERROR_IO;
 487         }
 488
 489         ret = sqlite3_prepare_v2(handle, "SELECT pkgid, prime FROM pkgmap WHERE appid = ?", -1, &stmt, NULL);
 490         if (ret != SQLITE_OK) {
 491                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 492                 ret = LB_STATUS_ERROR_IO;
 493                 goto out;
 494         }
 495
 496         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
 497         if (ret != SQLITE_OK) {
 498                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 499                 sqlite3_reset(stmt);
 500                 sqlite3_finalize(stmt);
 501                 ret = LB_STATUS_ERROR_IO;
 502                 goto out;
 503         }
 504
 505         ret = 0;
 506         while (sqlite3_step(stmt) == SQLITE_ROW) {
 507                 lbid = (const char *)sqlite3_column_text(stmt, 0);
 508                 if (!lbid || !strlen(lbid)) {
 509                         ErrPrint("LBID is not valid\n");
 510                         continue;
 511                 }
 512
 513                 is_prime = sqlite3_column_int(stmt, 1);
 514
 515                 ret++;
 516
 517                 if (cb(lbid, is_prime, data) < 0) {
 518                         DbgPrint("Callback stopped package crawling\n");
 519                         break;
 520                 }
 521         }
 522
 523         sqlite3_reset(stmt);
 524         sqlite3_finalize(stmt);
 525
 526 out:
 527         close_db(handle);
 528         return ret;
 529 }
 530
 531 EAPI int livebox_service_get_pkglist_by_category(const char *category, int (*cb)(const char *lbid, void *data), void *data)
 532 {
 533         int ret;
 534         sqlite3_stmt *stmt;
 535         const char *lbid;
 536         sqlite3 *handle;
 537
 538         if (!cb || !category) {
 539                 return LB_STATUS_ERROR_INVALID;
 540         }
 541
 542         handle = open_db();
 543         if (!handle) {
 544                 return LB_STATUS_ERROR_IO;
 545         }
 546
 547         ret = sqlite3_prepare_v2(handle, "SELECT pkgid FROM pkgmap WHERE category = ?", -1, &stmt, NULL);
 548         if (ret != SQLITE_OK) {
 549                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 550                 ret = LB_STATUS_ERROR_IO;
 551                 goto out;
 552         }
 553
 554         ret = sqlite3_bind_text(stmt, 1, category, -1, SQLITE_TRANSIENT);
 555         if (ret != SQLITE_OK) {
 556                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 557                 sqlite3_reset(stmt);
 558                 sqlite3_finalize(stmt);
 559                 ret = LB_STATUS_ERROR_IO;
 560                 goto out;
 561         }
 562
 563         ret = 0;
 564         while (sqlite3_step(stmt) == SQLITE_ROW) {
 565                 lbid = (const char *)sqlite3_column_text(stmt, 0);
 566                 if (!lbid || !strlen(lbid)) {
 567                         ErrPrint("LBID is not valid\n");
 568                         continue;
 569                 }
 570
 571                 ret++;
 572
 573                 if (cb(lbid, data) < 0) {
 574                         DbgPrint("Callback stopped package crawling\n");
 575                         break;
 576                 }
 577         }
 578
 579         sqlite3_reset(stmt);
 580         sqlite3_finalize(stmt);
 581
 582 out:
 583         close_db(handle);
 584         return ret;
 585 }
 586
 587 struct pkgmgr_cbdata {
 588         const char *lbid;
 589         void (*cb)(const char *lbid, const char *appid, void *data);
 590         void *cbdata;
 591 };
 592
 593 static int pkgmgr_cb(const pkgmgrinfo_appinfo_h handle, void *user_data)
 594 {
 595         struct pkgmgr_cbdata *cbdata = (struct pkgmgr_cbdata *)user_data;
 596         char *appid;
 597         int ret;
 598
 599         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 600         if (ret < 0) {
 601                 ErrPrint("Unable to get appid\n");
 602         } else {
 603                 cbdata->cb(cbdata->lbid, appid, cbdata->cbdata);
 604         }
 605
 606         return 0;
 607 }
 608
 609 static inline char *pkgmgr_get_mainapp(const char *pkgid)
 610 {
 611         pkgmgrinfo_pkginfo_h handle;
 612         char *ret = NULL;
 613
 614         if (pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle) != PMINFO_R_OK) {
 615                 ErrPrint("Unable to get mainapp: %s\n", pkgid);
 616                 return NULL;
 617         }
 618
 619         if (pkgmgrinfo_pkginfo_get_mainappid(handle, &ret) == PMINFO_R_OK) {
 620                 ret = strdup(ret);
 621         } else {
 622                 ErrPrint("Failed to get mainappid\n");
 623                 ret = NULL; /* I cannot believe the pkgmgrinfo_pkginfo_get_mainappid. it maybe able to touch my "ret" even though it fails */
 624
 625         }
 626
 627         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 628         return ret;
 629 }
 630
 631 static inline int pkgmgr_get_applist(const char *pkgid, const char *lbid, void (*cb)(const char *lbid, const char *appid, void *data), void *data)
 632 {
 633         struct pkgmgr_cbdata cbdata;
 634         pkgmgrinfo_pkginfo_h handle;
 635         int ret;
 636
 637         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 638         if (ret < 0) {
 639                 ErrPrint("Unable to get pkginfo: %s\n", pkgid);
 640                 return ret;
 641         }
 642
 643         cbdata.lbid = lbid;
 644         cbdata.cb = cb;
 645         cbdata.cbdata = data;
 646
 647         ret = pkgmgrinfo_appinfo_get_list(handle, PM_UI_APP, pkgmgr_cb, &cbdata);
 648         if (ret < 0) {
 649                 ErrPrint("Failed to get applist\n");
 650         }
 651
 652         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 653         return ret;
 654 }
 655
 656 EAPI int livebox_service_get_applist(const char *lbid, void (*cb)(const char *lbid, const char *appid, void *data), void *data)
 657 {
 658         sqlite3_stmt *stmt;
 659         const char *tmp;
 660         char *pkgid;
 661         sqlite3 *handle;
 662         int ret;
 663
 664         if (!lbid || !cb) {
 665                 return LB_STATUS_ERROR_INVALID;
 666         }
 667
 668         handle = open_db();
 669         if (!handle) {
 670                 return LB_STATUS_ERROR_IO;
 671         }
 672
 673         ret = sqlite3_prepare_v2(handle, "SELECT appid FROM pkgmap WHERE (pkgid = ?) or (appid = ?)", -1, &stmt, NULL);
 674         if (ret != SQLITE_OK) {
 675                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 676                 ret = LB_STATUS_ERROR_IO;
 677                 goto out;
 678         }
 679
 680         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
 681         if (ret != SQLITE_OK) {
 682                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 683                 ret = LB_STATUS_ERROR_IO;
 684                 goto out;
 685         }
 686
 687         ret = sqlite3_bind_text(stmt, 2, lbid, -1, SQLITE_TRANSIENT);
 688         if (ret != SQLITE_OK) {
 689                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 690                 ret = LB_STATUS_ERROR_IO;
 691                 goto out;
 692         }
 693
 694         if (sqlite3_step(stmt) != SQLITE_ROW) {
 695                 ret = LB_STATUS_ERROR_INVALID;
 696                 sqlite3_reset(stmt);
 697                 sqlite3_finalize(stmt);
 698                 goto out;
 699         }
 700
 701         tmp = (const char *)sqlite3_column_text(stmt, 0);
 702         if (!tmp || !strlen(tmp)) {
 703                 ErrPrint("Invalid package name (%s)\n", lbid);
 704                 ret = LB_STATUS_ERROR_INVALID;
 705                 sqlite3_reset(stmt);
 706                 sqlite3_finalize(stmt);
 707                 goto out;
 708         }
 709
 710         pkgid = strdup(tmp);
 711         if (!pkgid) {
 712                 ErrPrint("Error: %s\n", strerror(errno));
 713                 ret = LB_STATUS_ERROR_MEMORY;
 714                 sqlite3_reset(stmt);
 715                 sqlite3_finalize(stmt);
 716                 goto out;
 717         }
 718
 719         sqlite3_reset(stmt);
 720         sqlite3_finalize(stmt);
 721
 722         ret = pkgmgr_get_applist(pkgid, lbid, cb, data);
 723         free(pkgid);
 724
 725         switch (ret) {
 726         case PMINFO_R_EINVAL:
 727                 ret = LB_STATUS_ERROR_INVALID;
 728                 break;
 729         case PMINFO_R_OK:
 730                 ret = LB_STATUS_SUCCESS;
 731                 break;
 732         case PMINFO_R_ERROR:
 733         default:
 734                 ret = LB_STATUS_ERROR_FAULT;
 735                 break;
 736         }
 737
 738 out:
 739         close_db(handle);
 740         return ret;
 741 }
 742
 743 EAPI char *livebox_service_mainappid(const char *lbid)
 744 {
 745         sqlite3_stmt *stmt;
 746         const char *tmp;
 747         const char *pkgid;
 748         sqlite3 *handle;
 749         char *ret = NULL;
 750
 751         if (!lbid) {
 752                 return NULL;
 753         }
 754
 755         handle = open_db();
 756         if (!handle) {
 757                 return NULL;
 758         }
 759
 760         if (sqlite3_prepare_v2(handle, "SELECT appid, uiapp FROM pkgmap WHERE (pkgid = ?) or (appid = ? and prime = 1)", -1, &stmt, NULL) != SQLITE_OK) {
 761                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 762                 goto out;
 763         }
 764
 765         if (sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
 766                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 767                 goto out;
 768         }
 769
 770         if (sqlite3_bind_text(stmt, 2, lbid, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
 771                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 772                 goto out;
 773         }
 774
 775         if (sqlite3_step(stmt) != SQLITE_ROW) {
 776                 sqlite3_reset(stmt);
 777                 sqlite3_finalize(stmt);
 778                 goto out;
 779         }
 780
 781         tmp = (const char *)sqlite3_column_text(stmt, 0);
 782         if (!tmp || !strlen(tmp)) {
 783                 ErrPrint("Invalid package name (%s)\n", lbid);
 784                 sqlite3_reset(stmt);
 785                 sqlite3_finalize(stmt);
 786                 goto out;
 787         }
 788
 789         pkgid = (const char *)sqlite3_column_text(stmt, 1);
 790         if (!pkgid || !strlen(pkgid)) {
 791                 /*
 792                  * This record has no uiapp.
 793                  * Try to find the main ui-app id.
 794                  */
 795                 ret = pkgmgr_get_mainapp(tmp);
 796         } else {
 797                 ret = strdup(pkgid);
 798                 if (!ret) {
 799                         ErrPrint("Error: %s\n", strerror(errno));
 800                 }
 801         }
 802
 803         sqlite3_reset(stmt);
 804         sqlite3_finalize(stmt);
 805
 806 out:
 807         close_db(handle);
 808         return ret;
 809 }
 810
 811 EAPI int livebox_service_get_supported_size_types(const char *pkgid, int *cnt, int *types)
 812 {
 813         sqlite3_stmt *stmt;
 814         sqlite3 *handle;
 815         int size;
 816         int ret;
 817
 818         if (!types || !cnt || !pkgid) {
 819                 return LB_STATUS_ERROR_INVALID;
 820         }
 821
 822         handle = open_db();
 823         if (!handle) {
 824                 return LB_STATUS_ERROR_IO;
 825         }
 826
 827         ret = sqlite3_prepare_v2(handle, "SELECT size_type FROM box_size WHERE pkgid = ? ORDER BY size_type ASC", -1, &stmt, NULL);
 828         if (ret != SQLITE_OK) {
 829                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 830                 ret = LB_STATUS_ERROR_IO;
 831                 goto out;
 832         }
 833
 834         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
 835         if (ret != SQLITE_OK) {
 836                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 837                 sqlite3_reset(stmt);
 838                 sqlite3_finalize(stmt);
 839                 ret = LB_STATUS_ERROR_IO;
 840                 goto out;
 841         }
 842
 843         if (*cnt > NR_OF_SIZE_LIST) {
 844                 *cnt = NR_OF_SIZE_LIST;
 845         }
 846
 847         ret = 0;
 848         while (sqlite3_step(stmt) == SQLITE_ROW && ret < *cnt) {
 849                 size = sqlite3_column_int(stmt, 0);
 850                 types[ret] = size;
 851                 ret++;
 852         }
 853
 854         *cnt = ret;
 855         sqlite3_reset(stmt);
 856         sqlite3_finalize(stmt);
 857         ret = LB_STATUS_SUCCESS;
 858 out:
 859         close_db(handle);
 860         return ret;
 861 }
 862
 863 static char *cur_locale(void)
 864 {
 865         char *language;
 866         language = vconf_get_str(VCONFKEY_LANGSET);
 867         if (language) {
 868                 char *ptr;
 869
 870                 ptr = language;
 871                 while (*ptr) {
 872                         if (*ptr == '.') {
 873                                 *ptr = '\0';
 874                                 break;
 875                         }
 876
 877                         if (*ptr == '_') {
 878                                 *ptr = '-';
 879                         }
 880
 881                         ptr++;
 882                 }
 883         } else {
 884                 language = strdup("en-us");
 885                 if (!language) {
 886                         ErrPrint("Heap: %s\n", strerror(errno));
 887                 }
 888         }
 889
 890         return language;
 891 }
 892
 893 static char *get_default_name(const char *pkgid)
 894 {
 895         sqlite3_stmt *stmt;
 896         sqlite3 *handle;
 897         char *name = NULL;
 898         int ret;
 899
 900         handle = open_db();
 901         if (!handle) {
 902                 return NULL;
 903         }
 904
 905         ret = sqlite3_prepare_v2(handle, "SELECT name FROM client WHERE pkgid = ?", -1, &stmt, NULL);
 906         if (ret != SQLITE_OK) {
 907                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 908                 close_db(handle);
 909                 return NULL;
 910         }
 911
 912         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
 913         if (ret != SQLITE_OK) {
 914                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 915                 goto out;
 916         }
 917
 918         ret = sqlite3_step(stmt);
 919         if (ret ==  SQLITE_ROW) {
 920                 const char *tmp;
 921
 922                 tmp = (const char *)sqlite3_column_text(stmt, 0);
 923                 if (tmp && strlen(tmp)) {
 924                         name = strdup(tmp);
 925                         if (!name) {
 926                                 ErrPrint("Heap: %s\n", strerror(errno));
 927                         }
 928                 }
 929         }
 930
 931 out:
 932         sqlite3_reset(stmt);
 933         sqlite3_finalize(stmt);
 934         close_db(handle);
 935         return name;
 936 }
 937
 938 static char *get_default_icon(const char *pkgid)
 939 {
 940         sqlite3_stmt *stmt;
 941         sqlite3 *handle;
 942         char *icon = NULL;
 943         int ret;
 944
 945         handle = open_db();
 946         if (!handle) {
 947                 return NULL;
 948         }
 949
 950         ret = sqlite3_prepare_v2(handle, "SELECT icon FROM client WHERE pkgid = ?", -1, &stmt, NULL);
 951         if (ret != SQLITE_OK) {
 952                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 953                 close_db(handle);
 954                 return NULL;
 955         }
 956
 957         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
 958         if (ret != SQLITE_OK) {
 959                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 960                 goto out;
 961         }
 962
 963         ret = sqlite3_step(stmt);
 964         if (ret == SQLITE_ROW) {
 965                 const char *tmp;
 966
 967                 tmp = (const char *)sqlite3_column_text(stmt, 0);
 968                 if (tmp && strlen(tmp)) {
 969                         icon = strdup(tmp);
 970                         if (!icon) {
 971                                 ErrPrint("Heap: %s\n", strerror(errno));
 972                         }
 973                 }
 974         }
 975
 976 out:
 977         sqlite3_reset(stmt);
 978         sqlite3_finalize(stmt);
 979         close_db(handle);
 980         return icon;
 981 }
 982
 983 EAPI char *livebox_service_content(const char *pkgid)
 984 {
 985         sqlite3_stmt *stmt;
 986         sqlite3 *handle;
 987         char *content = NULL;
 988         int ret;
 989
 990         handle = open_db();
 991         if (!handle) {
 992                 return NULL;
 993         }
 994
 995         ret = sqlite3_prepare_v2(handle, "SELECT content FROM client WHERE pkgid = ?", -1, &stmt, NULL);
 996         if (ret != SQLITE_OK) {
 997                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
 998                 close_db(handle);
 999                 return NULL;
1000         }
1001
1002         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1003         if (ret != SQLITE_OK) {
1004                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1005                 goto out;
1006         }
1007
1008         ret = sqlite3_step(stmt);
1009         if (ret == SQLITE_ROW) {
1010                 const char *tmp;
1011
1012                 tmp = (const char *)sqlite3_column_text(stmt, 0);
1013                 if (tmp && strlen(tmp)) {
1014                         content = strdup(tmp);
1015                         if (!content) {
1016                                 ErrPrint("Heap: %s\n", strerror(errno));
1017                         }
1018                 }
1019         }
1020
1021 out:
1022         sqlite3_reset(stmt);
1023         sqlite3_finalize(stmt);
1024         close_db(handle);
1025         return content;
1026 }
1027
1028 EAPI char *livebox_service_setup_appid(const char *lbid)
1029 {
1030         sqlite3_stmt *stmt;
1031         sqlite3 *handle;
1032         int ret;
1033         char *appid;
1034
1035         if (!lbid) {
1036                 return NULL;
1037         }
1038
1039         handle = open_db();
1040         if (!handle) {
1041                 return NULL;
1042         }
1043
1044         ret = sqlite3_prepare_v2(handle, "SELECT setup FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1045         if (ret != SQLITE_OK) {
1046                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1047                 close_db(handle);
1048                 return NULL;
1049         }
1050
1051         appid = NULL;
1052         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1053         if (ret != SQLITE_OK) {
1054                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1055                 goto out;
1056         }
1057
1058         ret = sqlite3_step(stmt);
1059         if (ret == SQLITE_ROW) {
1060                 const char *tmp;
1061
1062                 tmp = (const char *)sqlite3_column_text(stmt, 0);
1063                 if (!tmp || !strlen(tmp)) {
1064                         goto out;
1065                 }
1066
1067                 appid = strdup(tmp);
1068                 if (!appid) {
1069                         ErrPrint("Error: %s\n", strerror(errno));
1070                 }
1071         }
1072
1073 out:
1074         sqlite3_reset(stmt);
1075         sqlite3_finalize(stmt);
1076         close_db(handle);
1077         return appid;
1078 }
1079
1080 EAPI int livebox_service_nodisplay(const char *pkgid)
1081 {
1082         sqlite3_stmt *stmt;
1083         sqlite3 *handle;
1084         int ret;
1085
1086         if (!pkgid) {
1087                 return 0;
1088         }
1089
1090         handle = open_db();
1091         if (!handle) {
1092                 return 0;
1093         }
1094
1095         ret = sqlite3_prepare_v2(handle, "SELECT nodisplay FROM client WHERE pkgid = ?", -1, &stmt, NULL);
1096         if (ret != SQLITE_OK) {
1097                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1098                 close_db(handle);
1099                 return 0;
1100         }
1101
1102         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1103         if (ret != SQLITE_OK) {
1104                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1105                 ret = 0;
1106                 goto out;
1107         }
1108
1109         ret = sqlite3_step(stmt);
1110         if (ret == SQLITE_ROW) {
1111                 ret = !!sqlite3_column_int(stmt, 0);
1112         } else {
1113                 ret = 0;
1114         }
1115
1116 out:
1117         sqlite3_reset(stmt);
1118         sqlite3_finalize(stmt);
1119         close_db(handle);
1120         return ret;
1121 }
1122
1123 static char *get_lb_pkgname_by_appid(const char *appid)
1124 {
1125         sqlite3_stmt *stmt;
1126         char *pkgid;
1127         char *tmp;
1128         sqlite3 *handle;
1129         int ret;
1130
1131         if (!appid) {
1132                 return NULL;
1133         }
1134
1135         pkgid = NULL;
1136         handle = open_db();
1137         if (!handle) {
1138                 return NULL;
1139         }
1140
1141         ret = sqlite3_prepare_v2(handle, "SELECT pkgid FROM pkgmap WHERE (appid = ? AND prime = 1) OR (uiapp = ? AND prime = 1) OR pkgid = ?", -1, &stmt, NULL);
1142         if (ret != SQLITE_OK) {
1143                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1144                 close_db(handle);
1145                 return NULL;
1146         }
1147
1148         ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_TRANSIENT);
1149         if (ret != SQLITE_OK) {
1150                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1151                 goto out;
1152         }
1153
1154         ret = sqlite3_bind_text(stmt, 2, appid, -1, SQLITE_TRANSIENT);
1155         if (ret != SQLITE_OK) {
1156                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1157                 goto out;
1158         }
1159
1160         ret = sqlite3_bind_text(stmt, 3, appid, -1, SQLITE_TRANSIENT);
1161         if (ret != SQLITE_OK) {
1162                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1163                 goto out;
1164         }
1165
1166         if (sqlite3_step(stmt) != SQLITE_ROW) {
1167                 ErrPrint("Error: %s (has no record? - %s)\n", sqlite3_errmsg(handle), appid);
1168                 goto out;
1169         }
1170
1171         tmp = (char *)sqlite3_column_text(stmt, 0);
1172         if (tmp && strlen(tmp)) {
1173                 pkgid = strdup(tmp);
1174                 if (!pkgid) {
1175                         ErrPrint("Heap: %s\n", strerror(errno));
1176                 }
1177         }
1178
1179 out:
1180         sqlite3_reset(stmt);
1181         sqlite3_finalize(stmt);
1182         close_db(handle);
1183         return pkgid;
1184 }
1185
1186 EAPI int livebox_service_need_frame(const char *pkgid, int size_type)
1187 {
1188         char *lbid;
1189         sqlite3_stmt *stmt;
1190         sqlite3 *handle;
1191         int ret;
1192
1193         handle = open_db();
1194         if (!handle) {
1195                 ErrPrint("Unable to open a DB\n");
1196                 return 0;
1197         }
1198
1199         ret = sqlite3_prepare_v2(handle, "SELECT need_frame FROM box_size WHERE pkgid = ? AND size_type = ?", -1, &stmt, NULL);
1200         if (ret != SQLITE_OK) {
1201                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1202                 close_db(handle);
1203                 return 0;
1204         }
1205
1206         /*!
1207          */
1208         lbid = livebox_service_pkgname(pkgid);
1209         if (!lbid) {
1210                 ErrPrint("Invalid appid (%s)\n", pkgid);
1211                 ret = 0;
1212                 goto out;
1213         }
1214
1215         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1216         free(lbid);
1217         if (ret != SQLITE_OK) {
1218                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1219                 ret = 0;
1220                 goto out;
1221         }
1222
1223         ret = sqlite3_bind_int(stmt, 2, size_type);
1224         if (ret != SQLITE_OK) {
1225                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1226                 ret = 0;
1227                 goto out;
1228         }
1229
1230         ret = sqlite3_step(stmt);
1231         if (ret == SQLITE_ROW) {
1232                 ret = !!sqlite3_column_int(stmt, 0);
1233         } else {
1234                 ret = 0;
1235                 ErrPrint("There is no such result\n");
1236         }
1237 out:
1238         sqlite3_reset(stmt);
1239         sqlite3_finalize(stmt);
1240         close_db(handle);
1241         return ret;
1242 }
1243
1244 EAPI int livebox_service_touch_effect(const char *pkgid, int size_type)
1245 {
1246         char *lbid;
1247         sqlite3_stmt *stmt;
1248         sqlite3 *handle;
1249         int ret;
1250
1251         handle = open_db();
1252         if (!handle) {
1253                 ErrPrint("Unable to open a DB\n");
1254                 return 1;
1255         }
1256
1257         ret = sqlite3_prepare_v2(handle, "SELECT touch_effect FROM box_size WHERE pkgid = ? AND size_type = ?", -1, &stmt, NULL);
1258         if (ret != SQLITE_OK) {
1259                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1260                 close_db(handle);
1261                 return 1;
1262         }
1263
1264         /*!
1265          * \note
1266          * This function will validate the "pkgid"
1267          * call the exported API in the exported API is not recomended
1268          * but... I used.
1269          */
1270         lbid = livebox_service_pkgname(pkgid);
1271         if (!lbid) {
1272                 ErrPrint("Invalid appid (%s)\n", pkgid);
1273                 ret = 1;
1274                 goto out;
1275         }
1276
1277         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1278         free(lbid);
1279         if (ret != SQLITE_OK) {
1280                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1281                 ret = 1;
1282                 goto out;
1283         }
1284
1285         ret = sqlite3_bind_int(stmt, 2, size_type);
1286         if (ret != SQLITE_OK) {
1287                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1288                 ret = 1;
1289                 goto out;
1290         }
1291
1292         ret = sqlite3_step(stmt);
1293         if (ret == SQLITE_ROW) {
1294                 ret = !!sqlite3_column_int(stmt, 0);
1295         } else {
1296                 ret = 1; /*!< Default true: In this case the DB is corrupted. */
1297                 ErrPrint("There is no result\n");
1298         }
1299
1300 out:
1301         sqlite3_reset(stmt);
1302         sqlite3_finalize(stmt);
1303         close_db(handle);
1304         return ret;
1305 }
1306
1307 EAPI int livebox_service_mouse_event(const char *pkgid, int size_type)
1308 {
1309         sqlite3_stmt *stmt;
1310         sqlite3 *handle;
1311         char *lbid;
1312         int ret;
1313
1314         handle = open_db();
1315         if (!handle) {
1316                 return 0;
1317         }
1318
1319         ret = sqlite3_prepare_v2(handle, "SELECT mouse_event FROM box_size WHERE pkgid = ? AND size_type = ?", -1, &stmt, NULL);
1320         if (ret != SQLITE_OK) {
1321                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1322                 close_db(handle);
1323                 return 0;
1324         }
1325
1326         lbid = livebox_service_pkgname(pkgid);
1327         if (!lbid) {
1328                 ErrPrint("Failed to get lbid: %s\n", pkgid);
1329                 ret = 0;
1330                 goto out;
1331         }
1332
1333         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1334         free(lbid);
1335         if (ret != SQLITE_OK) {
1336                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1337                 ret = 0;
1338                 goto out;
1339         }
1340
1341         ret = sqlite3_bind_int(stmt, 2, size_type);
1342         if (ret != SQLITE_OK) {
1343                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1344                 ret = 0;
1345                 goto out;
1346         }
1347
1348         ret = sqlite3_step(stmt);
1349         if (ret == SQLITE_ROW) {
1350                 ret = !!sqlite3_column_int(stmt, 0);
1351         } else {
1352                 ret = 0; /*!< Default is false, In this case the DB is corrupted */
1353                 ErrPrint("There is no result.\n");
1354         }
1355
1356 out:
1357         sqlite3_reset(stmt);
1358         sqlite3_finalize(stmt);
1359         close_db(handle);
1360         return ret;
1361 }
1362
1363 static inline int update_lang_info(void)
1364 {
1365         char *syslang;
1366         UErrorCode err;
1367
1368         syslang = vconf_get_str(VCONFKEY_LANGSET);
1369         if (!syslang) {
1370                 ErrPrint("Failed to get vconf-lang\n");
1371                 return -EFAULT;
1372         }
1373
1374         if (s_info.syslang && !strcmp(s_info.syslang, syslang)) {
1375                 DbgPrint("Syslang is not changed: %s\n", syslang);
1376                 free(syslang);
1377                 return 0;
1378         }
1379
1380         free(s_info.syslang);
1381         s_info.syslang = syslang;
1382
1383         err = U_ZERO_ERROR;
1384         uloc_setDefault((const char *)s_info.syslang, &err);
1385         if (!U_SUCCESS(err)) {
1386                 ErrPrint("Failed to set default lang: %s\n", u_errorName(err));
1387                 free(s_info.syslang);
1388                 s_info.syslang = NULL;
1389                 return -EFAULT;
1390         }
1391
1392         s_info.iso3lang = uloc_getISO3Language(uloc_getDefault());
1393         if (!s_info.iso3lang || !strlen(s_info.iso3lang)) {
1394                 ErrPrint("Failed to get iso3lang\n");
1395                 free(s_info.syslang);
1396                 s_info.syslang = NULL;
1397                 return -EFAULT;
1398         }
1399
1400         err = U_ZERO_ERROR;
1401         s_info.country_len = uloc_getCountry(uloc_getDefault(), s_info.country, ULOC_COUNTRY_CAPACITY, &err);
1402         if (!U_SUCCESS(err) || s_info.country_len <= 0) {
1403                 ErrPrint("Failed to get locale: %s, %s, %d (%s)\n", u_errorName(err), s_info.iso3lang, s_info.country_len, s_info.country);
1404                 free(s_info.syslang);
1405                 s_info.syslang = NULL;
1406                 return -EFAULT;
1407         }
1408
1409         return 0;
1410 }
1411
1412 EAPI char *livebox_service_preview(const char *pkgid, int size_type)
1413 {
1414         sqlite3_stmt *stmt;
1415         sqlite3 *handle;
1416         int ret;
1417         char *preview = NULL;
1418         const char *tmp;
1419         int tmp_len;
1420         int buf_len;
1421         register int i;
1422         int printed;
1423
1424         handle = open_db();
1425         if (!handle) {
1426                 return NULL;
1427         }
1428
1429         ret = sqlite3_prepare_v2(handle, "SELECT preview FROM box_size WHERE pkgid = ? AND size_type = ?", -1, &stmt, NULL);
1430         if (ret != SQLITE_OK) {
1431                 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1432                 close_db(handle);
1433                 return NULL;
1434         }
1435
1436         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1437         if (ret != SQLITE_OK) {
1438                 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1439                 goto out;
1440         }
1441
1442         ret = sqlite3_bind_int(stmt, 2, size_type);
1443         if (ret != SQLITE_OK) {
1444                 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1445                 goto out;
1446         }
1447
1448         ret = sqlite3_step(stmt);
1449         if (ret != SQLITE_ROW) {
1450                 ErrPrint("Error: %s, %s\n", sqlite3_errmsg(handle), pkgid);
1451                 goto out;
1452         }
1453
1454         tmp = (const char *)sqlite3_column_text(stmt, 0);
1455         if (!tmp || !(tmp_len = strlen(tmp))) {
1456                 ErrPrint("Failed to get data (%s)\n", pkgid);
1457                 goto out;
1458         }
1459
1460         if (update_lang_info() != 0) {
1461                 preview = strdup(tmp);
1462                 if (!preview) {
1463                         ErrPrint("Heap: %s\n", strerror(errno));
1464                 }
1465                 goto out;
1466         }
1467
1468         buf_len = tmp_len + strlen(s_info.iso3lang) + s_info.country_len + 3; /* '/' '-' '/' */
1469         preview = malloc(buf_len + 1);
1470         if (!preview) {
1471                 ErrPrint("Heap: %s\n", strerror(errno));
1472                 goto out;
1473         }
1474
1475         for (i = tmp_len; i >= 0 && tmp[i] != '/'; i--);
1476         i++; /* Skip '/' */
1477
1478         strncpy(preview, tmp, i);
1479         printed = snprintf(preview + i, buf_len - i, "%s-%s/%s", s_info.iso3lang, s_info.country, tmp + i);
1480         if (preview[i + printed] != '\0') {
1481                 ErrPrint("Path is truncated\n");
1482                 preview[i + printed] = '\0';
1483         }
1484
1485         if (access(preview, R_OK) != 0) {
1486                 DbgPrint("Access failed: %s, %s\n", preview, strerror(errno));
1487                 free(preview);
1488
1489                 preview = strdup(tmp);
1490                 if (!preview) {
1491                         ErrPrint("Heap: %s\n", strerror(errno));
1492                 }
1493         }
1494
1495 out:
1496         sqlite3_reset(stmt);
1497         sqlite3_finalize(stmt);
1498         close_db(handle);
1499         return preview;
1500 }
1501
1502 EAPI char *livebox_service_i18n_icon(const char *pkgid, const char *lang)
1503 {
1504         sqlite3_stmt *stmt;
1505         sqlite3 *handle;
1506         char *language;
1507         char *icon = NULL;
1508         int ret;
1509
1510         if (!pkgid) {
1511                 return NULL;
1512         }
1513
1514         if (lang) {
1515                 language = strdup(lang);
1516                 if (!language) {
1517                         ErrPrint("Heap: %s\n", strerror(errno));
1518                         return NULL;
1519                 }
1520         } else {
1521                 language = cur_locale();
1522                 if (!language) {
1523                         return NULL;
1524                 }
1525         }
1526
1527         handle = open_db();
1528         if (!handle) {
1529                 free(language);
1530                 return NULL;
1531         }
1532
1533         ret = sqlite3_prepare_v2(handle, "SELECT icon FROM i18n WHERE pkgid = ? AND lang = ?", -1, &stmt, NULL);
1534         if (ret != SQLITE_OK) {
1535                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1536                 close_db(handle);
1537                 free(language);
1538                 return NULL;
1539         }
1540
1541         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1542         if (ret != SQLITE_OK) {
1543                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1544                 goto out;
1545         }
1546
1547         ret = sqlite3_bind_text(stmt, 2, language, -1, SQLITE_TRANSIENT);
1548         if (ret != SQLITE_OK) {
1549                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1550                 goto out;
1551         }
1552
1553         ret = sqlite3_step(stmt);
1554         if (ret == SQLITE_ROW) {
1555                 const char *tmp;
1556                 tmp = (const char *)sqlite3_column_text(stmt, 0);
1557                 if (!tmp || !strlen(tmp)) {
1558                         icon = get_default_icon(pkgid);
1559                 } else {
1560                         icon = strdup(tmp);
1561                         if (!icon) {
1562                                 ErrPrint("Heap: %s\n", strerror(errno));
1563                         }
1564                 }
1565         } else {
1566                 icon = get_default_icon(pkgid);
1567         }
1568
1569 out:
1570         sqlite3_reset(stmt);
1571         sqlite3_finalize(stmt);
1572         close_db(handle);
1573         free(language);
1574         return icon;
1575 }
1576
1577 EAPI char *livebox_service_i18n_name(const char *pkgid, const char *lang)
1578 {
1579         sqlite3_stmt *stmt;
1580         sqlite3 *handle;
1581         char *language;
1582         char *name = NULL;
1583         int ret;
1584
1585         if (!pkgid) {
1586                 return NULL;
1587         }
1588
1589         if (lang) {
1590                 language = strdup(lang);
1591                 if (!language) {
1592                         ErrPrint("Error: %s\n", strerror(errno));
1593                         return NULL;
1594                 }
1595         } else {
1596                 language = cur_locale();
1597                 if (!language) {
1598                         return NULL;
1599                 }
1600         }
1601
1602         handle = open_db();
1603         if (!handle) {
1604                 free(language);
1605                 return NULL;
1606         }
1607
1608         ret = sqlite3_prepare_v2(handle, "SELECT name FROM i18n WHERE pkgid = ? AND lang = ?", -1, &stmt, NULL);
1609         if (ret != SQLITE_OK) {
1610                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1611                 close_db(handle);
1612                 free(language);
1613                 return NULL;
1614         }
1615
1616         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1617         if (ret != SQLITE_OK) {
1618                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1619                 goto out;
1620         }
1621
1622         ret = sqlite3_bind_text(stmt, 2, language, -1, SQLITE_TRANSIENT);
1623         if (ret != SQLITE_OK) {
1624                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1625                 goto out;
1626         }
1627
1628         ret = sqlite3_step(stmt);
1629         if (ret == SQLITE_ROW) {
1630                 const char *tmp;
1631                 tmp = (const char *)sqlite3_column_text(stmt, 0);
1632                 if (!tmp || !strlen(tmp)) {
1633                         name = get_default_name(pkgid);
1634                 } else {
1635                         name = strdup(tmp);
1636                         if (!name) {
1637                                 ErrPrint("Heap: %s\n", strerror(errno));
1638                         }
1639                 }
1640         } else {
1641                 name = get_default_name(pkgid);
1642         }
1643
1644 out:
1645         sqlite3_reset(stmt);
1646         sqlite3_finalize(stmt);
1647         close_db(handle);
1648         free(language);
1649         return name;
1650 }
1651
1652 EAPI int livebox_service_get_supported_sizes(const char *pkgid, int *cnt, int *w, int *h)
1653 {
1654         sqlite3_stmt *stmt;
1655         sqlite3 *handle;
1656         int size;
1657         int ret;
1658
1659         if (!w || !h || !cnt || !pkgid) {
1660                 return LB_STATUS_ERROR_INVALID;
1661         }
1662
1663         handle = open_db();
1664         if (!handle) {
1665                 return LB_STATUS_ERROR_IO;
1666         }
1667
1668         ret = sqlite3_prepare_v2(handle, "SELECT size_type FROM box_size WHERE pkgid = ? ORDER BY size_type ASC", -1, &stmt, NULL);
1669         if (ret != SQLITE_OK) {
1670                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1671                 ret = LB_STATUS_ERROR_IO;
1672                 goto out;
1673         }
1674
1675         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1676         if (ret != SQLITE_OK) {
1677                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1678                 sqlite3_reset(stmt);
1679                 sqlite3_finalize(stmt);
1680                 ret = LB_STATUS_ERROR_IO;
1681                 goto out;
1682         }
1683
1684         if (*cnt > NR_OF_SIZE_LIST) {
1685                 *cnt = NR_OF_SIZE_LIST;
1686         }
1687
1688         ret = 0;
1689         while (sqlite3_step(stmt) == SQLITE_ROW && ret < *cnt) {
1690                 size = sqlite3_column_int(stmt, 0);
1691                 ret += (convert_size_from_type(size, w + ret, h + ret) == 0);
1692         }
1693
1694         *cnt = ret;
1695         sqlite3_reset(stmt);
1696         sqlite3_finalize(stmt);
1697         ret = 0;
1698 out:
1699         close_db(handle);
1700         return ret;
1701 }
1702
1703 EAPI char *livebox_service_abi(const char *lbid)
1704 {
1705         sqlite3_stmt *stmt;
1706         sqlite3 *handle;
1707         int ret;
1708         char *abi;
1709         char *tmp;
1710
1711         if (!lbid) {
1712                 ErrPrint("Invalid argument\n");
1713                 return NULL;
1714         }
1715
1716         abi = NULL;
1717         handle = open_db();
1718         if (!handle) {
1719                 return NULL;
1720         }
1721
1722         ret = sqlite3_prepare_v2(handle, "SELECT abi FROM provider WHERE pkgid = ?", -1, &stmt, NULL);
1723         if (ret != SQLITE_OK) {
1724                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1725                 goto out;
1726         }
1727
1728         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
1729         if (ret != SQLITE_OK) {
1730                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1731                 sqlite3_finalize(stmt);
1732                 goto out;
1733         }
1734
1735         ret = sqlite3_step(stmt);
1736         if (ret != SQLITE_ROW) {
1737                 ErrPrint("Error: %s (%d)\n", sqlite3_errmsg(handle), ret);
1738                 sqlite3_reset(stmt);
1739                 sqlite3_finalize(stmt);
1740                 goto out;
1741         }
1742
1743         tmp = (char *)sqlite3_column_text(stmt, 0);
1744         if (!tmp || !strlen(tmp)) {
1745                 ErrPrint("Invalid abi: %s\n", sqlite3_errmsg(handle));
1746                 sqlite3_reset(stmt);
1747                 sqlite3_finalize(stmt);
1748                 goto out;
1749         }
1750
1751         abi = strdup(tmp);
1752         if (!abi) {
1753                 ErrPrint("strdup: %s\n", strerror(errno));
1754                 sqlite3_reset(stmt);
1755                 sqlite3_finalize(stmt);
1756                 goto out;
1757         }
1758
1759         DbgPrint("abi: %s\n", abi);
1760
1761         sqlite3_reset(stmt);
1762         sqlite3_finalize(stmt);
1763 out:
1764         close_db(handle);
1765         return abi;
1766 }
1767
1768 EAPI char *livebox_service_pkgname_by_libexec(const char *libexec)
1769 {
1770         sqlite3_stmt *stmt;
1771         sqlite3 *handle;
1772         int ret;
1773         char *pkgid;
1774         char *tmp;
1775         char *_libexec;
1776         int len;
1777
1778         if (!libexec) {
1779                 ErrPrint("Invalid argument\n");
1780                 return NULL;
1781         }
1782
1783         pkgid = NULL;
1784         handle = open_db();
1785         if (!handle) {
1786                 return NULL;
1787         }
1788
1789         len = strlen(libexec) + 3;
1790
1791         _libexec = malloc(len);
1792         if (!_libexec) {
1793                 ErrPrint("Heap: %s\n", strerror(errno));
1794                 close_db(handle);
1795                 return NULL;
1796         }
1797
1798         snprintf(_libexec, len - 1, "%%%s", libexec);
1799
1800         ret = sqlite3_prepare_v2(handle, "SELECT pkgid FROM provider WHERE libexec like ?", -1, &stmt, NULL);
1801         if (ret != SQLITE_OK) {
1802                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1803                 goto out;
1804         }
1805
1806         ret = sqlite3_bind_text(stmt, 1, _libexec, -1, SQLITE_TRANSIENT);
1807         if (ret != SQLITE_OK) {
1808                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1809                 sqlite3_finalize(stmt);
1810                 goto out;
1811         }
1812
1813         if (sqlite3_step(stmt) != SQLITE_ROW) {
1814                 ErrPrint("No records (%s) for (%s)\n", sqlite3_errmsg(handle), libexec);
1815                 sqlite3_reset(stmt);
1816                 sqlite3_finalize(stmt);
1817                 goto out;
1818         }
1819
1820         tmp = (char *)sqlite3_column_text(stmt, 0);
1821         if (!tmp || !strlen(tmp)) {
1822                 ErrPrint("Invalid pkgid: %s\n", sqlite3_errmsg(handle));
1823                 sqlite3_reset(stmt);
1824                 sqlite3_finalize(stmt);
1825                 goto out;
1826         }
1827
1828         pkgid = strdup(tmp);
1829         if (!pkgid) {
1830                 ErrPrint("Heap: %s\n", strerror(errno));
1831         }
1832
1833         DbgPrint("pkgid: %s\n", pkgid);
1834
1835         sqlite3_reset(stmt);
1836         sqlite3_finalize(stmt);
1837 out:
1838         close_db(handle);
1839         free(_libexec);
1840         return pkgid;
1841 }
1842
1843 EAPI char *livebox_service_libexec(const char *pkgid)
1844 {
1845         sqlite3_stmt *stmt;
1846         sqlite3 *handle;
1847         int ret;
1848         char *libexec;
1849         char *appid;
1850         char *path;
1851
1852         if (!pkgid) {
1853                 ErrPrint("Invalid argument\n");
1854                 return NULL;
1855         }
1856
1857         libexec = NULL;
1858         handle = open_db();
1859         if (!handle) {
1860                 return NULL;
1861         }
1862
1863         ret = sqlite3_prepare_v2(handle, "SELECT pkgmap.appid, provider.libexec FROM pkgmap, provider WHERE pkgmap.pkgid = ? AND provider.pkgid = ?", -1, &stmt, NULL);
1864         if (ret != SQLITE_OK) {
1865                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1866                 goto out;
1867         }
1868
1869         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
1870         if (ret != SQLITE_OK) {
1871                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1872                 sqlite3_finalize(stmt);
1873                 goto out;
1874         }
1875
1876         ret = sqlite3_bind_text(stmt, 2, pkgid, -1, SQLITE_TRANSIENT);
1877         if (ret != SQLITE_OK) {
1878                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1879                 sqlite3_finalize(stmt);
1880                 goto out;
1881         }
1882
1883         if (sqlite3_step(stmt) != SQLITE_ROW) {
1884                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
1885                 sqlite3_reset(stmt);
1886                 sqlite3_finalize(stmt);
1887
1888                 libexec = util_conf_get_libexec(pkgid);
1889                 DbgPrint("Fallback to conf checker: %s\n", libexec);
1890                 goto out;
1891         }
1892
1893         appid = (char *)sqlite3_column_text(stmt, 0);
1894         if (!appid || !strlen(appid)) {
1895                 ErrPrint("Invalid appid: %s\n", sqlite3_errmsg(handle));
1896                 sqlite3_reset(stmt);
1897                 sqlite3_finalize(stmt);
1898                 goto out;
1899         }
1900
1901         path = (char *)sqlite3_column_text(stmt, 1);
1902         if (!path || !strlen(path)) {
1903                 ErrPrint("Invalid libexec: %s\n", sqlite3_errmsg(handle));
1904                 sqlite3_reset(stmt);
1905                 sqlite3_finalize(stmt);
1906                 goto out;
1907         }
1908
1909         libexec = strdup(path);
1910         if (!libexec) {
1911                 ErrPrint("Heap: %s\n", strerror(errno));
1912                 sqlite3_reset(stmt);
1913                 sqlite3_finalize(stmt);
1914                 goto out;
1915         }
1916
1917         DbgPrint("libexec: %s\n", libexec);
1918
1919         sqlite3_reset(stmt);
1920         sqlite3_finalize(stmt);
1921 out:
1922         close_db(handle);
1923         return libexec;
1924 }
1925
1926 EAPI char *livebox_service_pkgname(const char *appid)
1927 {
1928         char *lb_pkgname;
1929         pkgmgr_appinfo_h handle;
1930         int ret;
1931         char *new_appid;
1932
1933         if (!appid) {
1934                 return NULL;
1935         }
1936
1937         lb_pkgname = get_lb_pkgname_by_appid(appid);
1938         if (lb_pkgname) {
1939                 return lb_pkgname;
1940         }
1941
1942         /*!
1943          * \note
1944          * Try to get the package id using given appid
1945          */
1946         ret = pkgmgr_appinfo_get_appinfo(appid, &handle);
1947         if (ret != PKGMGR_R_OK) {
1948                 ErrPrint("Failed to get appinfo\n");
1949                 return NULL;
1950         }
1951
1952         ret = pkgmgr_appinfo_get_pkgname(handle, &new_appid);
1953         if (ret != PKGMGR_R_OK) {
1954                 pkgmgr_appinfo_destroy_appinfo(handle);
1955                 ErrPrint("Failed to get pkgname for (%s)\n", appid);
1956                 return NULL;
1957         }
1958
1959         lb_pkgname = get_lb_pkgname_by_appid(new_appid);
1960         pkgmgr_appinfo_destroy_appinfo(handle);
1961
1962         if (!lb_pkgname && util_validate_livebox_package(appid) == 0) {
1963                 return strdup(appid);
1964         }
1965
1966         return lb_pkgname;
1967 }
1968
1969 EAPI char *livebox_service_provider_name(const char *lbid)
1970 {
1971         char *ret;
1972         int stage = 0;
1973         int seq = 0;
1974         int idx = 0;
1975         char *str = SAMSUNG_PREFIX;
1976
1977         if (!lbid) {
1978                 return NULL;
1979         }
1980
1981         while (str[idx] && lbid[idx] && lbid[idx] == str[idx]) {
1982                 idx++;
1983                 if (seq < 2 && lbid[idx] == '.') {
1984                         stage = idx;
1985                         seq++;
1986                 }
1987         }
1988
1989         if (!str[idx] && lbid[idx]) {
1990                 /* Inhouse */
1991                 return strdup(lbid);
1992         } else if (seq < 2) {
1993                 while (seq < 2) {
1994                         if (lbid[idx] == '.') {
1995                                 seq++;
1996                         } else if (!lbid[idx]) {
1997                                 ErrPrint("Invalid lbid: %s\n", lbid);
1998                                 return NULL;
1999                         }
2000
2001                         idx++;
2002                 }
2003
2004                 stage = idx;
2005         } else {
2006                 stage++;
2007         }
2008
2009         ret = strdup(lbid + stage);
2010         if (!ret) {
2011                 ErrPrint("Error: %s\n", strerror(errno));
2012                 return NULL;
2013         }
2014
2015         return ret;
2016 }
2017
2018 EAPI int livebox_service_is_enabled(const char *lbid)
2019 {
2020         return 1;
2021         /*
2022         ail_appinfo_h ai;
2023         char *pkgname;
2024         bool enabled;
2025         int ret;
2026
2027         pkgname = livebox_service_appid(lbid);
2028         if (!pkgname)
2029                 return 0;
2030
2031         ret = ail_get_appinfo(pkgname, &ai);
2032         if (ret != AIL_ERROR_OK) {
2033                 free(pkgname);
2034                 return 0;
2035         }
2036
2037         if (ail_appinfo_get_bool(ai, AIL_PROP_X_SLP_ENABLED_BOOL, &enabled) != AIL_ERROR_OK)
2038                 enabled = false;
2039
2040         ail_destroy_appinfo(ai);
2041         free(pkgname);
2042         return enabled == true;
2043         */
2044 }
2045
2046 EAPI int livebox_service_is_primary(const char *lbid)
2047 {
2048         sqlite3_stmt *stmt;
2049         sqlite3 *handle;
2050         int ret = 0;
2051
2052         if (!lbid) {
2053                 return 0;
2054         }
2055
2056         handle = open_db();
2057         if (!handle) {
2058                 return 0;
2059         }
2060
2061         ret = sqlite3_prepare_v2(handle, "SELECT prime FROM pkgmap WHERE pkgid = ?", -1, &stmt, NULL);
2062         if (ret != SQLITE_OK) {
2063                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2064                 close_db(handle);
2065                 return 0;
2066         }
2067
2068         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
2069         if (ret != SQLITE_OK) {
2070                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2071                 goto out;
2072         }
2073
2074         ret = sqlite3_step(stmt);
2075         if (ret != SQLITE_ROW) {
2076                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2077                 goto out;
2078         }
2079
2080         ret = sqlite3_column_int(stmt, 0);
2081
2082 out:
2083         sqlite3_reset(stmt);
2084         sqlite3_finalize(stmt);
2085         close_db(handle);
2086         return ret;
2087 }
2088
2089 EAPI char *livebox_service_category(const char *lbid)
2090 {
2091         sqlite3_stmt *stmt;
2092         char *category = NULL;
2093         char *tmp;
2094         sqlite3 *handle;
2095         int ret;
2096
2097         if (!lbid) {
2098                 return NULL;
2099         }
2100
2101         category = NULL;
2102         handle = open_db();
2103         if (!handle) {
2104                 return NULL;
2105         }
2106
2107         ret = sqlite3_prepare_v2(handle, "SELECT category FROM pkgmap WHERE pkgid = ? OR appid = ?", -1, &stmt, NULL);
2108         if (ret != SQLITE_OK) {
2109                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2110                 goto out;
2111         }
2112
2113         ret = sqlite3_bind_text(stmt, 1, lbid, -1, SQLITE_TRANSIENT);
2114         if (ret != SQLITE_OK) {
2115                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2116                 sqlite3_reset(stmt);
2117                 sqlite3_finalize(stmt);
2118                 goto out;
2119         }
2120
2121         ret = sqlite3_bind_text(stmt, 2, lbid, -1, SQLITE_TRANSIENT);
2122         if (ret != SQLITE_OK) {
2123                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2124                 sqlite3_reset(stmt);
2125                 sqlite3_finalize(stmt);
2126                 goto out;
2127         }
2128
2129         ret = sqlite3_step(stmt);
2130         if (ret != SQLITE_ROW) {
2131                 ErrPrint("Has no record?: %s\n", sqlite3_errmsg(handle));
2132                 sqlite3_reset(stmt);
2133                 sqlite3_finalize(stmt);
2134                 goto out;
2135         }
2136
2137         tmp = (char *)sqlite3_column_text(stmt, 0);
2138         if (!tmp || !strlen(tmp)) {
2139                 ErrPrint("APPID is NIL\n");
2140                 sqlite3_reset(stmt);
2141                 sqlite3_finalize(stmt);
2142                 goto out;
2143         }
2144
2145         category = strdup(tmp);
2146         if (!category) {
2147                 ErrPrint("Heap: %s\n", strerror(errno));
2148                 sqlite3_reset(stmt);
2149                 sqlite3_finalize(stmt);
2150                 goto out;
2151         }
2152
2153         sqlite3_reset(stmt);
2154         sqlite3_finalize(stmt);
2155 out:
2156         close_db(handle);
2157         return category;
2158 }
2159
2160 EAPI char *livebox_service_appid(const char *pkgname)
2161 {
2162         sqlite3_stmt *stmt;
2163         char *appid;
2164         char *tmp;
2165         sqlite3 *handle;
2166         int is_prime __attribute__((__unused__));
2167         int ret;
2168
2169         if (!pkgname) {
2170                 return NULL;
2171         }
2172
2173         appid = NULL;
2174         handle = open_db();
2175         if (!handle) {
2176                 return NULL;
2177         }
2178
2179         ret = sqlite3_prepare_v2(handle, "SELECT appid, prime FROM pkgmap WHERE pkgid = ? OR appid = ?", -1, &stmt, NULL);
2180         if (ret != SQLITE_OK) {
2181                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2182                 goto out;
2183         }
2184
2185         ret = sqlite3_bind_text(stmt, 1, pkgname, -1, SQLITE_TRANSIENT);
2186         if (ret != SQLITE_OK) {
2187                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2188                 sqlite3_reset(stmt);
2189                 sqlite3_finalize(stmt);
2190                 goto out;
2191         }
2192
2193         ret = sqlite3_bind_text(stmt, 2, pkgname, -1, SQLITE_TRANSIENT);
2194         if (ret != SQLITE_OK) {
2195                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2196                 sqlite3_reset(stmt);
2197                 sqlite3_finalize(stmt);
2198                 goto out;
2199         }
2200
2201         ret = sqlite3_step(stmt);
2202         if (ret != SQLITE_ROW) {
2203                 pkgmgr_appinfo_h pkg_handle;
2204                 char *new_appid;
2205
2206                 ErrPrint("Has no record?: %s\n", sqlite3_errmsg(handle));
2207                 sqlite3_reset(stmt);
2208                 sqlite3_finalize(stmt);
2209
2210                 ret = pkgmgr_appinfo_get_appinfo(pkgname, &pkg_handle);
2211                 if (ret != PKGMGR_R_OK) {
2212                         ErrPrint("Failed to get appinfo: %s\n", pkgname);
2213                         goto out;
2214                 }
2215
2216                 ret = pkgmgr_appinfo_get_pkgname(pkg_handle, &new_appid);
2217                 if (ret != PKGMGR_R_OK) {
2218                         ErrPrint("Failed to get pkgname for (%s)\n", appid);
2219                         pkgmgr_appinfo_destroy_appinfo(pkg_handle);
2220                         goto out;
2221                 }
2222
2223                 appid = strdup(new_appid);
2224                 if (!appid) {
2225                         ErrPrint("Heap: %s\n", strerror(errno));
2226                 }
2227
2228                 pkgmgr_appinfo_destroy_appinfo(pkg_handle);
2229                 goto out;
2230         }
2231
2232         tmp = (char *)sqlite3_column_text(stmt, 0);
2233         if (!tmp || !strlen(tmp)) {
2234                 ErrPrint("APPID is NIL\n");
2235                 sqlite3_reset(stmt);
2236                 sqlite3_finalize(stmt);
2237                 goto out;
2238         }
2239
2240         appid = strdup(tmp);
2241         if (!appid) {
2242                 ErrPrint("Heap: %s\n", strerror(errno));
2243                 sqlite3_reset(stmt);
2244                 sqlite3_finalize(stmt);
2245                 goto out;
2246         }
2247
2248         is_prime = sqlite3_column_int(stmt, 1);
2249
2250         sqlite3_reset(stmt);
2251         sqlite3_finalize(stmt);
2252 out:
2253         close_db(handle);
2254         return appid;
2255 }
2256
2257 EAPI char *livebox_service_lb_script_path(const char *pkgid)
2258 {
2259         sqlite3_stmt *stmt;
2260         sqlite3 *handle;
2261         int ret;
2262         char *path;
2263         char *appid;
2264         char *lb_src;
2265
2266         if (!pkgid) {
2267                 return NULL;
2268         }
2269
2270         path = NULL;
2271         handle = open_db();
2272         if (!handle) {
2273                 return NULL;
2274         }
2275
2276         ret = sqlite3_prepare_v2(handle, "SELECT pkgmap.appid, provider.box_src FROM provider, pkgmap WHERE pkgmap.pkgid = ? AND provider.pkgid = ?", -1, &stmt, NULL);
2277         if (ret != SQLITE_OK) {
2278                 ErrPrint("Error: %s, pkgid(%s), ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2279                 goto out;
2280         }
2281
2282         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2283         if (ret != SQLITE_OK) {
2284                 ErrPrint("Error: %s, pkgid(%s), ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2285                 sqlite3_finalize(stmt);
2286                 goto out;
2287         }
2288
2289         ret = sqlite3_bind_text(stmt, 2, pkgid, -1, SQLITE_TRANSIENT);
2290         if (ret != SQLITE_OK) {
2291                 ErrPrint("Error: %s, pkgid(%s), ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2292                 sqlite3_finalize(stmt);
2293                 goto out;
2294         }
2295
2296         ret = sqlite3_step(stmt);
2297         if (ret != SQLITE_ROW) {
2298                 ErrPrint("Error: %s, pkgid(%s), ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2299                 sqlite3_reset(stmt);
2300                 sqlite3_finalize(stmt);
2301                 goto out;
2302         }
2303
2304         appid = (char *)sqlite3_column_text(stmt, 0);
2305         if (!appid || !strlen(appid)) {
2306                 ErrPrint("Invalid appid : %s, pkgid(%s)\n", sqlite3_errmsg(handle), pkgid);
2307                 sqlite3_reset(stmt);
2308                 sqlite3_finalize(stmt);
2309                 goto out;
2310         }
2311
2312         lb_src = (char *)sqlite3_column_text(stmt, 1);
2313         if (!lb_src || !strlen(lb_src)) {
2314                 ErrPrint("No records for lb src : %s, pkgid(%s), appid(%s)\n", sqlite3_errmsg(handle), pkgid, appid);
2315                 sqlite3_reset(stmt);
2316                 sqlite3_finalize(stmt);
2317                 goto out;
2318         }
2319
2320         path = strdup(lb_src);
2321         if (!path) {
2322                 ErrPrint("Heap: %s\n", strerror(errno));
2323                 sqlite3_reset(stmt);
2324                 sqlite3_finalize(stmt);
2325                 goto out;
2326         }
2327
2328         DbgPrint("LB Src: %s\n", path);
2329         sqlite3_reset(stmt);
2330         sqlite3_finalize(stmt);
2331 out:
2332         close_db(handle);
2333         return path;
2334 }
2335
2336 EAPI char *livebox_service_lb_script_group(const char *pkgid)
2337 {
2338         sqlite3_stmt *stmt;
2339         sqlite3 *handle;
2340         int ret;
2341         char *group;
2342         char *tmp;
2343
2344         if (!pkgid) {
2345                 return NULL;
2346         }
2347
2348         group = NULL;
2349         handle = open_db();
2350         if (!handle) {
2351                 return NULL;
2352         }
2353
2354         ret = sqlite3_prepare_v2(handle, "SELECT box_group FROM provider WHERE pkgid = ?", -1, &stmt, NULL);
2355         if (ret != SQLITE_OK) {
2356                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2357                 goto out;
2358         }
2359
2360         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2361         if (ret != SQLITE_OK) {
2362                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2363                 sqlite3_finalize(stmt);
2364                 goto out;
2365         }
2366
2367         ret = sqlite3_step(stmt);
2368         if (ret != SQLITE_ROW) {
2369                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2370                 sqlite3_reset(stmt);
2371                 sqlite3_finalize(stmt);
2372                 goto out;
2373         }
2374
2375         tmp = (char *)sqlite3_column_text(stmt, 0);
2376         if (tmp && strlen(tmp)) {
2377                 group = strdup(tmp);
2378                 if (!group) {
2379                         ErrPrint("Heap: %s\n", strerror(errno));
2380                 }
2381         }
2382
2383         sqlite3_reset(stmt);
2384         sqlite3_finalize(stmt);
2385 out:
2386         close_db(handle);
2387         return group;
2388 }
2389
2390 EAPI char *livebox_service_pd_script_path(const char *pkgid)
2391 {
2392         sqlite3_stmt *stmt;
2393         sqlite3 *handle;
2394         int ret;
2395         char *path;
2396         char *pd_src;
2397         const char *appid;
2398
2399         if (!pkgid) {
2400                 return NULL;
2401         }
2402
2403         path = NULL;
2404         handle = open_db();
2405         if (!handle) {
2406                 return NULL;
2407         }
2408
2409         ret = sqlite3_prepare_v2(handle, "SELECT pkgmap.appid, provider.pd_src FROM provider, pkgmap WHERE provider.pkgid = ? AND pkgmap.pkgid = ?", -1, &stmt, NULL);
2410         if (ret != SQLITE_OK) {
2411                 ErrPrint("Error: %s pkgid(%s) ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2412                 goto out;
2413         }
2414
2415         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2416         if (ret != SQLITE_OK) {
2417                 ErrPrint("Error: %s pkgid(%s) ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2418                 sqlite3_finalize(stmt);
2419                 goto out;
2420         }
2421
2422         ret = sqlite3_bind_text(stmt, 2, pkgid, -1, SQLITE_TRANSIENT);
2423         if (ret != SQLITE_OK) {
2424                 ErrPrint("Error: %s pkgid(%s) ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2425                 sqlite3_finalize(stmt);
2426                 goto out;
2427         }
2428
2429         ret = sqlite3_step(stmt);
2430         if (ret != SQLITE_ROW) {
2431                 ErrPrint("Error: %s pkgid(%s) ret(%d)\n", sqlite3_errmsg(handle), pkgid, ret);
2432                 sqlite3_reset(stmt);
2433                 sqlite3_finalize(stmt);
2434                 goto out;
2435         }
2436
2437         appid = (char *)sqlite3_column_text(stmt, 0);
2438         if (!appid || !strlen(appid)) {
2439                 ErrPrint("Error: %s pkgid(%s)\n", sqlite3_errmsg(handle), pkgid);
2440                 sqlite3_reset(stmt);
2441                 sqlite3_finalize(stmt);
2442                 goto out;
2443         }
2444
2445         pd_src = (char *)sqlite3_column_text(stmt, 1);
2446         if (!pd_src || !strlen(pd_src)) {
2447                 ErrPrint("Error: %s pkgid(%s) appid(%s)\n", sqlite3_errmsg(handle), pkgid, appid);
2448                 sqlite3_reset(stmt);
2449                 sqlite3_finalize(stmt);
2450                 goto out;
2451         }
2452
2453         path = strdup(pd_src);
2454         if (!path) {
2455                 ErrPrint("Heap: %s\n", strerror(errno));
2456                 sqlite3_reset(stmt);
2457                 sqlite3_finalize(stmt);
2458                 goto out;
2459         }
2460
2461         DbgPrint("PD Src: %s\n", path);
2462         sqlite3_reset(stmt);
2463         sqlite3_finalize(stmt);
2464 out:
2465         close_db(handle);
2466         return path;
2467 }
2468
2469 EAPI char *livebox_service_pd_script_group(const char *pkgid)
2470 {
2471         sqlite3_stmt *stmt;
2472         sqlite3 *handle;
2473         int ret;
2474         char *group;
2475         char *tmp;
2476
2477         if (!pkgid) {
2478                 return NULL;
2479         }
2480
2481         group = NULL;
2482         handle = open_db();
2483         if (!handle) {
2484                 return NULL;
2485         }
2486
2487         ret = sqlite3_prepare_v2(handle, "SELECT pd_group FROM provider WHERE pkgid = ?", -1, &stmt, NULL);
2488         if (ret != SQLITE_OK) {
2489                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2490                 goto out;
2491         }
2492
2493         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
2494         if (ret != SQLITE_OK) {
2495                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2496                 sqlite3_finalize(stmt);
2497                 goto out;
2498         }
2499
2500         ret = sqlite3_step(stmt);
2501         if (ret != SQLITE_ROW) {
2502                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2503                 sqlite3_reset(stmt);
2504                 sqlite3_finalize(stmt);
2505                 goto out;
2506         }
2507
2508         tmp = (char *)sqlite3_column_text(stmt, 0);
2509         if (tmp && strlen(tmp)) {
2510                 group = strdup(tmp);
2511                 if (!group) {
2512                         ErrPrint("Heap: %s\n", strerror(errno));
2513                 }
2514         }
2515         sqlite3_reset(stmt);
2516         sqlite3_finalize(stmt);
2517 out:
2518         close_db(handle);
2519         return group;
2520 }
2521
2522 EAPI int livebox_service_enumerate_cluster_list(int (*cb)(const char *cluster, void *data), void *data)
2523 {
2524         sqlite3_stmt *stmt;
2525         sqlite3 *handle;
2526         const char *cluster;
2527         int cnt;
2528         int ret;
2529
2530         if (!cb) {
2531                 return LB_STATUS_ERROR_INVALID;
2532         }
2533
2534         handle = open_db();
2535         if (!handle) {
2536                 return LB_STATUS_ERROR_IO;
2537         }
2538
2539         cnt = 0;
2540         ret = sqlite3_prepare_v2(handle, "SELECT DISTINCT cluster FROM groupinfo", -1, &stmt, NULL);
2541         if (ret != SQLITE_OK) {
2542                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2543                 cnt = LB_STATUS_ERROR_IO;
2544                 goto out;
2545         }
2546
2547         while (sqlite3_step(stmt) == SQLITE_ROW) {
2548                 cluster = (const char *)sqlite3_column_text(stmt, 0);
2549                 if (!cluster || !strlen(cluster)) {
2550                         continue;
2551                 }
2552
2553                 if (cb(cluster, data) < 0) {
2554                         break;
2555                 }
2556
2557                 cnt++;
2558         }
2559
2560         sqlite3_reset(stmt);
2561         sqlite3_finalize(stmt);
2562 out:
2563         close_db(handle);
2564         return cnt;
2565 }
2566
2567 EAPI int livebox_service_enumerate_category_list(const char *cluster, int (*cb)(const char *cluster, const char *category, void *data), void *data)
2568 {
2569         sqlite3_stmt *stmt;
2570         sqlite3 *handle;
2571         const char *category;
2572         int cnt;
2573         int ret;
2574
2575         if (!cluster || !cb) {
2576                 return LB_STATUS_ERROR_INVALID;
2577         }
2578
2579         handle = open_db();
2580         if (!handle) {
2581                 return LB_STATUS_ERROR_IO;
2582         }
2583
2584         ret = sqlite3_prepare_v2(handle, "SELECT DISTINCT category FROM groupinfo WHERE cluster = ?", -1, &stmt, NULL);
2585         if (ret != SQLITE_OK) {
2586                 ErrPrint("Error: %s\n", sqlite3_errmsg(handle));
2587                 cnt = LB_STATUS_ERROR_IO;
2588                 goto out;
2589         }
2590
2591         cnt = 0;
2592         while (sqlite3_step(stmt) == SQLITE_ROW) {
2593                 category = (const char *)sqlite3_column_text(stmt, 0);
2594                 if (!category || !strlen(category)) {
2595                         continue;
2596                 }
2597
2598                 if (cb(cluster, category, data) < 0) {
2599                         break;
2600                 }
2601
2602                 cnt++;
2603         }
2604
2605         sqlite3_reset(stmt);
2606         sqlite3_finalize(stmt);
2607 out:
2608         close_db(handle);
2609         return cnt;
2610 }
2611
2612 EAPI int livebox_service_init(void)
2613 {
2614         if (s_info.handle) {
2615                 DbgPrint("Already initialized\n");
2616                 s_info.init_count++;
2617                 return 0;
2618         }
2619
2620         s_info.handle = open_db();
2621         if (s_info.handle) {
2622                 s_info.init_count++;
2623                 return 0;
2624         }
2625
2626         return LB_STATUS_ERROR_IO;
2627 }
2628
2629 EAPI int livebox_service_fini(void)
2630 {
2631         if (!s_info.handle || s_info.init_count <= 0) {
2632                 ErrPrint("Service is not initialized\n");
2633                 return LB_STATUS_ERROR_IO;
2634         }
2635
2636         s_info.init_count--;
2637         if (s_info.init_count > 0) {
2638                 DbgPrint("Init count %d\n", s_info.init_count);
2639                 return 0;
2640         }
2641
2642         db_util_close(s_info.handle);
2643         s_info.handle = NULL;
2644         return 0;
2645 }
2646
2647 EAPI int livebox_service_get_size(int type, int *width, int *height)
2648 {
2649         int _width;
2650         int _height;
2651
2652         if (!width) {
2653                 width = &_width;
2654         }
2655
2656         if (!height) {
2657                 height = &_height;
2658         }
2659
2660         return convert_size_from_type(type, width, height);
2661 }
2662
2663 EAPI int livebox_service_size_type(int width, int height)
2664 {
2665         int idx;
2666
2667         if (util_update_resolution(&s_info, SIZE_LIST) < 0) {
2668                 ErrPrint("Failed to update the size list\n");
2669         }
2670
2671         for (idx = 0; idx < NR_OF_SIZE_LIST; idx++) {
2672                 if (SIZE_LIST[idx].w == width && SIZE_LIST[idx].h == height) {
2673                         break;
2674                 }
2675         }
2676
2677         switch (idx) {
2678         case 0:
2679                 return LB_SIZE_TYPE_1x1;
2680         case 1:
2681                 return LB_SIZE_TYPE_2x1;
2682         case 2:
2683                 return LB_SIZE_TYPE_2x2;
2684         case 3:
2685                 return LB_SIZE_TYPE_4x1;
2686         case 4:
2687                 return LB_SIZE_TYPE_4x2;
2688         case 5:
2689                 return LB_SIZE_TYPE_4x3;
2690         case 6:
2691                 return LB_SIZE_TYPE_4x4;
2692         case 7:
2693                 return LB_SIZE_TYPE_4x5;
2694         case 8:
2695                 return LB_SIZE_TYPE_4x6;
2696         case 9:
2697                 return LB_SIZE_TYPE_EASY_1x1;
2698         case 10:
2699                 return LB_SIZE_TYPE_EASY_3x1;
2700         case 11:
2701                 return LB_SIZE_TYPE_EASY_3x3;
2702         case 12:
2703                 return LB_SIZE_TYPE_0x0;
2704         default:
2705                 break;
2706         }
2707
2708         return LB_SIZE_TYPE_UNKNOWN;
2709 }
2710
2711 /* End of a file */