src/location-appman.c

   1 /*
   2  * liblocation-appman
   3  *
   4  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Youngae Kang <youngae.kang@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
   7  *          Genie Kim <daejins.kim@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25 #include <glib.h>
  26 #include <sqlite3.h>
  27 #include <libxml/parser.h>
  28 #include <app_manager.h>
  29 #include "location-appman.h"
  30 #include "location-appman-log.h"
  31
  32 #define LOCATION_APPMAN_QUERY_MAX_LEN                   1024
  33
  34 #define LOCATION_APPMAN_PATH_FILE                       ".location-appman.db"
  35 #define LOCATION_APPMAN_PATH_DBSPACE                    LOCATION_APPMAN_DBDIR
  36 #define LOCATION_APPMAN_PATH_FULL                       LOCATION_APPMAN_PATH_DBSPACE"/"LOCATION_APPMAN_PATH_FILE
  37
  38 #define LOCATION_APPMAN_PKG_NAME        "PKG_NAME"
  39
  40 sqlite3 *db_handle = NULL;
  41
  42 static char *__create_table = "create table if not exists LocationApp(package VARCHAR(64) PRIMARY KEY,\
  43                         icon VARCHAR(256), app_id INTEGER, installed_date INTEGER, recently_used INTEGER, enable BOOL);";
  44
  45 static char *__default_item[] = {
  46         "insert into LocationApp (package, app_id, installed_date, recently_used, enable) values (\"org.tizen.setting\", 0, 0, 0, 1);",
  47         "insert into LocationApp (package, app_id, installed_date, recently_used, enable) values (\"kmcele1k0n.Internet\", 0, 0, 0, 1);",
  48 };
  49
  50 char *location_column_name[6] = { "package", "icon", "app_id", "installed_date", "recently_used", "enable" };
  51
  52 int location_appman_check_developer_mode(void)
  53 {
  54         return FALSE;
  55 }
  56
  57 void location_appman_close(void)
  58 {
  59         sqlite3_close(db_handle);
  60         db_handle = NULL;
  61 }
  62
  63 int location_appman_open(void)
  64 {
  65         int rc = SQLITE_OK;
  66         int idx = 0;
  67
  68         if (NULL != db_handle) {
  69                 LOCATION_APPMAN_LOG("location_appman_open & close\n");
  70                 location_appman_close();
  71         }
  72
  73         rc = sqlite3_open_v2(LOCATION_APPMAN_PATH_FULL, &db_handle, SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE, NULL);
  74         if (SQLITE_OK != rc) {
  75                 // DB Recovery
  76                 if (SQLITE_CANTOPEN == rc) {
  77                         rc = sqlite3_open_v2(LOCATION_APPMAN_PATH_FULL, &db_handle, SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
  78                         if (SQLITE_OK == rc) {
  79                                 rc = sqlite3_exec (db_handle, __create_table, NULL, NULL, NULL);
  80                                 if (SQLITE_OK != rc) {
  81                                         LOCATION_APPMAN_LOG("Failed to create table : Error[%s]\n", sqlite3_errmsg(db_handle));
  82                                         sqlite3_close (db_handle);
  83                                         db_handle = NULL;
  84                                         return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
  85                                 }
  86
  87                                 for (idx = 0; idx < sizeof(__default_item) / sizeof(char*); idx++) {
  88                                         rc = sqlite3_exec (db_handle, __default_item[idx], NULL, NULL, NULL);
  89                                         if (SQLITE_OK != rc) {
  90                                                 LOCATION_APPMAN_LOG("Failed to insert default item : Error[%s]\n", sqlite3_errmsg(db_handle));
  91                                                 sqlite3_close (db_handle);
  92                                                 db_handle = NULL;
  93                                                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
  94                                         }
  95                                 }
  96                                 return LOCATION_APPMAN_ERROR_NONE;
  97                         }
  98                 }
  99
 100                 LOCATION_APPMAN_LOG("Failed to open : Error[%s]\n", sqlite3_errmsg(db_handle));
 101                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 102         }
 103
 104         return LOCATION_APPMAN_ERROR_NONE;
 105 }
 106
 107 int location_appman_query(char *dest, const char *src)
 108 {
 109         if (NULL == dest || NULL == src) {
 110                 LOCATION_APPMAN_LOG("location_appman_query : NULL\n");
 111                 return FALSE;
 112         }
 113
 114         g_strlcat(dest, src, strlen(src) + 1);
 115         return TRUE;
 116 }
 117
 118 int location_appman_drop(void)
 119 {
 120         int rc = SQLITE_OK;
 121         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 122
 123         rc = location_appman_query(query, "DROP TABLE IF EXISTS LocationApp");
 124         if (FALSE == rc) {
 125                 location_appman_close();
 126                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 127         }
 128
 129         rc = sqlite3_exec(db_handle, query, NULL, NULL, NULL);
 130         if (SQLITE_OK != rc) {
 131                 LOCATION_APPMAN_LOG("Fail to connect to table. Error[%s]\n", sqlite3_errmsg(db_handle));
 132                 location_appman_close();
 133                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 134         }
 135
 136         return LOCATION_APPMAN_ERROR_NONE;
 137 }
 138
 139 int location_appman_insert(location_appman_s * appman)
 140 {
 141         LOCATION_APPMAN_NULL_ARG_CHECK(appman);
 142         sqlite3_stmt *state;
 143         int rc = SQLITE_OK;
 144         int sql_param_index = 1;
 145         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 146         const char *tail;
 147
 148         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 149                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 150
 151         rc = location_appman_query(query,
 152                                    "INSERT INTO LocationApp(package, icon, app_id, installed_date, recently_used, enable)"
 153                                    "VALUES (?, ?, ?, ?, ?, ?)");
 154         if (FALSE == rc) {
 155                 location_appman_close();
 156                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 157         }
 158
 159         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, &tail);
 160         if (SQLITE_OK != rc) {
 161                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]\n", sqlite3_errmsg(db_handle));
 162                 location_appman_close();
 163                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 164         }
 165
 166         sqlite3_bind_text(state, sql_param_index, appman->package, strlen(appman->package), SQLITE_STATIC);
 167         sqlite3_bind_text(state, ++sql_param_index, appman->appicon, strlen(appman->appicon), SQLITE_STATIC);
 168         sqlite3_bind_int(state, ++sql_param_index, appman->appid);
 169         sqlite3_bind_int(state, ++sql_param_index, appman->installed_date);
 170         sqlite3_bind_int(state, ++sql_param_index, appman->recently_used);
 171         sqlite3_bind_int(state, ++sql_param_index, appman->enable);
 172
 173         sqlite3_step(state);
 174         sqlite3_reset(state);
 175
 176         sqlite3_finalize(state);
 177         location_appman_close();
 178
 179         return LOCATION_APPMAN_ERROR_NONE;
 180 }
 181
 182 int location_appman_delete(const char *package)
 183 {
 184         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 185         sqlite3_stmt *state = NULL;
 186         int rc = SQLITE_OK;
 187         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 188
 189         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 190                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 191
 192         rc = location_appman_query(query, "DELETE from LocationApp where package = ?");
 193         if (FALSE == rc) {
 194                 LOCATION_APPMAN_LOG("location_app_delete. Error[%d]\n", rc);
 195                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 196         }
 197
 198         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, NULL);
 199         if (SQLITE_OK != rc) {
 200                 LOCATION_APPMAN_LOG("Fail to connect to table. Error[%s]\n", sqlite3_errmsg(db_handle));
 201                 location_appman_close();
 202                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 203         }
 204         // bind the values
 205         rc = sqlite3_bind_text(state, 1, package, strlen(package), SQLITE_STATIC);
 206         if (SQLITE_OK != rc) {
 207                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 208                 sqlite3_finalize(state);
 209                 location_appman_close();
 210                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 211         }
 212         // step
 213         rc = sqlite3_step(state);
 214         if (SQLITE_DONE != rc) {
 215                 LOCATION_APPMAN_LOG("Fail to step. Error[%d]", rc);
 216                 sqlite3_finalize(state);
 217                 location_appman_close();
 218                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 219         }
 220         sqlite3_finalize(state);
 221         location_appman_close();
 222
 223         return LOCATION_APPMAN_ERROR_NONE;
 224 }
 225
 226 int location_appman_reset(void)
 227 {
 228         int rc = SQLITE_OK;
 229         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 230
 231         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 232                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 233
 234         if (location_appman_drop() != LOCATION_APPMAN_ERROR_NONE)
 235                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 236
 237         rc = location_appman_query(query, "CREATE TABLE LocationApp(\n "
 238                                    "package VARCHAR(64) PRIMARY KEY,\n"
 239                                    "name VARChAR(32),\n"
 240                                    "icon VARCHAR(256),\n"
 241                                    "app_id INTEGER,\n" "installed_date INTEGER,\n" "recently_used INTEGER,\n" "enable BOOL);");
 242
 243         if (FALSE == rc) {
 244                 LOCATION_APPMAN_LOG("location_appman_reset. Error[%d]\n", rc);
 245                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 246         }
 247
 248         rc = sqlite3_exec(db_handle, query, NULL, NULL, NULL);
 249         if (SQLITE_OK != rc) {
 250                 LOCATION_APPMAN_LOG("Fail to connect to table. Error[%s]\n", sqlite3_errmsg(db_handle));
 251                 location_appman_close();
 252                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 253         }
 254
 255         location_appman_close();
 256
 257         return LOCATION_APPMAN_ERROR_NONE;
 258 }
 259
 260 int location_appman_update(location_appman_s * appman)
 261 {
 262         LOCATION_APPMAN_NULL_ARG_CHECK(appman);
 263         sqlite3_stmt *state = NULL;
 264         int rc = SQLITE_OK;
 265         int sql_param_index = 1;
 266         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 267
 268         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 269                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 270
 271         rc = location_appman_query(query,
 272                                    "UPDATE LocationApp SET icon = ?, app_id = ?, installed_date = ?, recently_used = ?, enable = ? where package = ? ");
 273         if (FALSE == rc) {
 274                 location_appman_close();
 275                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 276         }
 277
 278         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, NULL);
 279         if (SQLITE_OK != rc) {
 280                 LOCATION_APPMAN_LOG("Fail to connect to table. Error[%s]\n", sqlite3_errmsg(db_handle));
 281                 location_appman_close();
 282                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 283         }
 284         // bind the values
 285         // Icon
 286         rc = sqlite3_bind_text(state, sql_param_index++, appman->appicon, strlen(appman->appicon), SQLITE_STATIC);
 287         if (SQLITE_OK != rc) {
 288                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 289                 sqlite3_finalize(state);
 290                 location_appman_close();
 291                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 292         }
 293         // App ID
 294         rc = sqlite3_bind_int(state, sql_param_index++, appman->appid);
 295         if (SQLITE_OK != rc) {
 296                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 297                 sqlite3_finalize(state);
 298                 location_appman_close();
 299                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 300         }
 301         // Installed Date
 302         rc = sqlite3_bind_int(state, sql_param_index++, appman->installed_date);
 303         if (SQLITE_OK != rc) {
 304                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 305                 sqlite3_finalize(state);
 306                 location_appman_close();
 307                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 308         }
 309         // Recently used
 310         rc = sqlite3_bind_int(state, sql_param_index++, appman->recently_used);
 311         if (SQLITE_OK != rc) {
 312                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 313                 sqlite3_finalize(state);
 314                 location_appman_close();
 315                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 316         }
 317         // Enable
 318         rc = sqlite3_bind_int(state, sql_param_index++, appman->enable);
 319         if (SQLITE_OK != rc) {
 320                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 321                 sqlite3_finalize(state);
 322                 location_appman_close();
 323                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 324         }
 325         // Package
 326         rc = sqlite3_bind_text(state, sql_param_index++, appman->package, strlen(appman->package), SQLITE_STATIC);
 327         if (SQLITE_OK != rc) {
 328                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 329                 sqlite3_finalize(state);
 330                 location_appman_close();
 331                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 332         }
 333         // step
 334         rc = sqlite3_step(state);
 335         if (SQLITE_DONE != rc) {
 336                 LOCATION_APPMAN_LOG("Fail to step. Error[%d]", rc);
 337                 sqlite3_finalize(state);
 338                 location_appman_close();
 339                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 340         }
 341         sqlite3_finalize(state);
 342         location_appman_close();
 343
 344         return LOCATION_APPMAN_ERROR_NONE;
 345 }
 346
 347 int location_appman_get_total_count(int *count)
 348 {
 349         sqlite3_stmt *state;
 350         int rc = SQLITE_OK;
 351         int num_data;
 352         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 353         const char *tail;
 354
 355         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 356                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 357
 358         rc = location_appman_query(query, "SELECT count(*) FROM LocationApp");
 359         if (FALSE == rc) {
 360                 location_appman_close();
 361                 *count = -1;
 362                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 363         }
 364
 365         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, &tail);
 366         if (SQLITE_OK != rc) {
 367                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 368                 *count = -1;
 369                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 370         }
 371
 372         rc = sqlite3_step(state);
 373         if (SQLITE_ROW == rc) {
 374                 num_data = sqlite3_column_int(state, 0);
 375                 *count = num_data;
 376         }
 377
 378         sqlite3_finalize(state);
 379         location_appman_close();
 380
 381         return LOCATION_APPMAN_ERROR_NONE;
 382 }
 383
 384 int location_appman_get_app_list(location_appman_column_e sort_by, int *list_count, location_appman_s ** apps)
 385 {
 386         sqlite3_stmt *state;
 387         int rc = SQLITE_OK;
 388         int column_index = 0;
 389         int i = 0;
 390         int count = 0;
 391         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 392         const char *tail;
 393
 394         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 395                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 396
 397         if (LOCATION_APPMAN_COLUMN_PACKAGE > sort_by || LOCATION_APPMAN_COLUMN_ENABLE < sort_by) {
 398                 sort_by = LOCATION_APPMAN_COLUMN_INSTALLED_DATE;
 399                 g_snprintf(query, LOCATION_APPMAN_QUERY_MAX_LEN, "SELECT * FROM LocationApp ORDER BY %s",
 400                            location_column_name[sort_by]);
 401         } else {
 402                 g_snprintf(query, LOCATION_APPMAN_QUERY_MAX_LEN, "SELECT * FROM LocationApp ORDER BY %s",
 403                            location_column_name[sort_by]);
 404         }
 405
 406         if (LOCATION_APPMAN_COLUMN_RECENTLY_USED == sort_by || LOCATION_APPMAN_COLUMN_ENABLE == sort_by) {
 407
 408                 rc = location_appman_query(query, " DESC");
 409                 if (FALSE == rc) {
 410                         location_appman_close();
 411                         return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 412                 }
 413         }
 414
 415         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, &tail);
 416         if (SQLITE_OK != rc) {
 417                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 418                 location_appman_close();
 419                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 420         }
 421
 422         location_appman_get_total_count(&count);
 423         LOCATION_APPMAN_LOG("count [%d]", count);
 424         *apps = (location_appman_s *) g_malloc0(sizeof(location_appman_s) * count);
 425
 426         for (i = 0; i < count; i++) {
 427                 char *name;
 428                 rc = sqlite3_step(state);
 429                 g_strlcpy((*apps + i)->package, (char *)sqlite3_column_text(state, column_index++), 64);
 430                 g_strlcpy((*apps + i)->appicon, (char *)sqlite3_column_text(state, column_index++), 256);
 431
 432                 (*apps + i)->appid = sqlite3_column_int(state, column_index++);
 433                 (*apps + i)->installed_date = sqlite3_column_int(state, column_index++);
 434                 (*apps + i)->recently_used = sqlite3_column_int(state, column_index++);
 435                 (*apps + i)->enable = (gboolean) sqlite3_column_int(state, column_index++);
 436                 column_index = 0;
 437
 438                 location_appman_get_name((*apps + i)->package, &name);
 439                 g_strlcpy((*apps + i)->appname, name, 64);
 440
 441                 if (SQLITE_ROW != rc) {
 442                         break;
 443                 }
 444         }
 445
 446         *list_count = i;
 447
 448         sqlite3_finalize(state);
 449         location_appman_close();
 450
 451         return LOCATION_APPMAN_ERROR_NONE;
 452 }
 453
 454 // GET
 455 int location_appman_get_column_text(const char *package, location_appman_column_e type, char **data)
 456 {
 457         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 458         sqlite3_stmt *state;
 459         int rc = LOCATION_APPMAN_ERROR_NONE;
 460         const char *tail;
 461         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 462
 463         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 464                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 465
 466         g_snprintf(query, LOCATION_APPMAN_QUERY_MAX_LEN, "SELECT %s FROM LocationApp WHERE package = ?",
 467                    location_column_name[type]);
 468
 469         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, &tail);
 470         if (SQLITE_OK != rc) {
 471                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 472                 location_appman_close();
 473                 data = NULL;
 474                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 475         }
 476
 477         rc = sqlite3_bind_text(state, 1, package, strlen(package), SQLITE_STATIC);
 478         if (SQLITE_OK != rc) {
 479                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 480                 sqlite3_finalize(state);
 481                 location_appman_close();
 482                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 483         }
 484
 485         rc = sqlite3_step(state);
 486
 487         if (SQLITE_ROW == rc) {
 488                 *data = g_strdup((char *)sqlite3_column_text(state, 0));
 489         }
 490
 491         sqlite3_finalize(state);
 492         location_appman_close();
 493
 494         return LOCATION_APPMAN_ERROR_NONE;
 495 }
 496
 497 int location_appman_get_column_int(const char *package, location_appman_column_e type, unsigned int *data)
 498 {
 499         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 500         sqlite3_stmt *state;
 501         int rc = LOCATION_APPMAN_ERROR_NONE;
 502         int num_data = 0;
 503         const char *tail;
 504         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 505
 506         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 507                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 508
 509         g_snprintf(query, LOCATION_APPMAN_QUERY_MAX_LEN, "SELECT %s FROM LocationApp WHERE package = ?",
 510                    location_column_name[type]);
 511
 512         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, &tail);
 513         if (SQLITE_OK != rc) {
 514                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 515                 location_appman_close();
 516                 data = NULL;
 517                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 518         }
 519
 520         rc = sqlite3_bind_text(state, 1, package, strlen(package), SQLITE_STATIC);
 521         if (SQLITE_OK != rc) {
 522                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 523                 sqlite3_finalize(state);
 524                 location_appman_close();
 525                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 526         }
 527
 528         rc = sqlite3_step(state);
 529
 530         if (SQLITE_ROW == rc) {
 531                 num_data = sqlite3_column_int(state, 0);
 532                 *data = num_data;
 533         }
 534
 535         sqlite3_finalize(state);
 536         location_appman_close();
 537
 538         return LOCATION_APPMAN_ERROR_NONE;
 539 }
 540
 541 int location_appman_get_name(const char *package, char **appname)
 542 {
 543         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 544         app_info_h app_info;
 545         char *name = NULL;
 546         int ret = 0;
 547
 548         ret = app_manager_get_app_info(package, &app_info);
 549         if (ret != APP_MANAGER_ERROR_NONE) {
 550                 if (package) {
 551                         LOCATION_APPMAN_LOG("Can't get application information: [%s]", package);
 552                         name = strdup (package);
 553                 }
 554                 else {
 555                         LOCATION_APPMAN_LOG("Can't get application information: [%s]", package);
 556                         return LOCATION_APPMAN_ERROR_INTERNAL;
 557                 }
 558         }
 559         else {
 560
 561                 app_info_get_label(app_info, &name);
 562                 if (name == NULL || g_strcmp0 (name, "(NULL)") == 0) {
 563                         LOCATION_APPMAN_LOG("name of application[%s] is NULL", package);
 564                         name = strdup (package);
 565                 }
 566         }
 567
 568         *appname = (char *) g_malloc0(sizeof(char)*64);
 569         g_strlcpy(*appname, name, 64);
 570         g_free(name);
 571
 572         return LOCATION_APPMAN_ERROR_NONE;
 573 }
 574
 575 int location_appman_get_icon(const char *package, char **appicon)
 576 {
 577         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 578         int rc = LOCATION_APPMAN_ERROR_NONE;
 579
 580         rc = location_appman_get_column_text(package, LOCATION_APPMAN_COLUMN_APPICON, appicon);
 581         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 582                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 583                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 584         }
 585
 586         return LOCATION_APPMAN_ERROR_NONE;
 587 }
 588
 589 int location_appman_get_appid(const char *package, int *appid)
 590 {
 591         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 592         int rc = LOCATION_APPMAN_ERROR_NONE;
 593
 594         rc = location_appman_get_column_int(package, LOCATION_APPMAN_COLUMN_APPID, (unsigned int *)appid);
 595         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 596                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 597                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 598         }
 599
 600         return LOCATION_APPMAN_ERROR_NONE;
 601 }
 602
 603 int location_appman_get_installed_date(const char *package, unsigned int *installed_date)
 604 {
 605         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 606         int rc = LOCATION_APPMAN_ERROR_NONE;
 607
 608         rc = location_appman_get_column_int(package, LOCATION_APPMAN_COLUMN_INSTALLED_DATE, installed_date);
 609         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 610                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 611                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 612         }
 613
 614         return LOCATION_APPMAN_ERROR_NONE;
 615 }
 616
 617 int location_appman_get_recently_used(const char *package, unsigned int *recently_used)
 618 {
 619         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 620         int rc = LOCATION_APPMAN_ERROR_NONE;
 621
 622         rc = location_appman_get_column_int(package, LOCATION_APPMAN_COLUMN_RECENTLY_USED, recently_used);
 623         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 624                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 625                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 626         }
 627
 628         return LOCATION_APPMAN_ERROR_NONE;
 629 }
 630
 631 int location_appman_is_enabled(const char *package, int *enable)
 632 {
 633         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 634         int rc = SQLITE_OK;
 635
 636         rc = location_appman_get_column_int(package, LOCATION_APPMAN_COLUMN_ENABLE, (unsigned int *)enable);
 637         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 638                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 639                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 640         }
 641
 642         return LOCATION_APPMAN_ERROR_NONE;
 643 }
 644
 645 // SET
 646 int location_appman_set_column_text(const char *package, location_appman_column_e type, char *data)
 647 {
 648         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 649         sqlite3_stmt *state = NULL;
 650         int rc = SQLITE_OK;
 651         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 652
 653         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 654                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 655
 656         g_snprintf(query, LOCATION_APPMAN_QUERY_MAX_LEN, "UPDATE LocationApp SET %s = ? WHERE package = ?",
 657                    location_column_name[type]);
 658
 659         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, NULL);
 660         if (SQLITE_OK != rc) {
 661                 LOCATION_APPMAN_LOG("Fail to connect to table. Error[%s]\n", sqlite3_errmsg(db_handle));
 662                 location_appman_close();
 663                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 664         }
 665
 666         rc = sqlite3_bind_text(state, 1, data, strlen(data), SQLITE_STATIC);
 667         if (SQLITE_OK != rc) {
 668                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 669                 sqlite3_finalize(state);
 670                 location_appman_close();
 671                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 672         }
 673
 674         rc = sqlite3_bind_text(state, 2, package, strlen(package), SQLITE_STATIC);
 675         if (SQLITE_OK != rc) {
 676                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 677                 sqlite3_finalize(state);
 678                 location_appman_close();
 679                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 680         }
 681
 682         rc = sqlite3_step(state);
 683         if (SQLITE_DONE != rc) {
 684                 LOCATION_APPMAN_LOG("Fail to step. rc[%d]", rc);
 685                 sqlite3_finalize(state);
 686                 location_appman_close();
 687                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 688         }
 689
 690         sqlite3_finalize(state);
 691         location_appman_close();
 692
 693         return LOCATION_APPMAN_ERROR_NONE;
 694 }
 695
 696 // SET
 697 int location_appman_set_column_int(const char *package, location_appman_column_e type, int data)
 698 {
 699         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 700         sqlite3_stmt *state = NULL;
 701         int rc = SQLITE_OK;
 702         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 703
 704         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 705                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 706
 707         g_snprintf(query, LOCATION_APPMAN_QUERY_MAX_LEN, "UPDATE LocationApp SET %s = ? WHERE package = ?",
 708                    location_column_name[type]);
 709
 710         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, NULL);
 711         if (SQLITE_OK != rc) {
 712                 LOCATION_APPMAN_LOG("Fail to connect to table. Error[%s]\n", sqlite3_errmsg(db_handle));
 713                 location_appman_close();
 714                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 715         }
 716
 717         rc = sqlite3_bind_int(state, 1, data);
 718         if (SQLITE_OK != rc) {
 719                 LOCATION_APPMAN_LOG("Fail to bind int to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 720                 sqlite3_finalize(state);
 721                 location_appman_close();
 722                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 723         }
 724
 725         rc = sqlite3_bind_text(state, 2, package, strlen(package), SQLITE_STATIC);
 726         if (SQLITE_OK != rc) {
 727                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 728                 sqlite3_finalize(state);
 729                 location_appman_close();
 730                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 731         }
 732
 733         rc = sqlite3_step(state);
 734         if (SQLITE_DONE != rc) {
 735                 LOCATION_APPMAN_LOG("Fail to step. rc[%d]", rc);
 736                 sqlite3_finalize(state);
 737                 location_appman_close();
 738                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 739         }
 740
 741         sqlite3_finalize(state);
 742         location_appman_close();
 743
 744         return LOCATION_APPMAN_ERROR_NONE;
 745 }
 746
 747 int location_appman_set_icon(const char *package, char *appicon)
 748 {
 749         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 750         LOCATION_APPMAN_NULL_ARG_CHECK(appicon);
 751         int rc = LOCATION_APPMAN_ERROR_NONE;
 752
 753         rc = location_appman_set_column_text(package, LOCATION_APPMAN_COLUMN_APPICON, appicon);
 754         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 755                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 756                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 757         }
 758         return LOCATION_APPMAN_ERROR_NONE;
 759 }
 760
 761 int location_appman_set_appid(const char *package, int appid)
 762 {
 763         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 764         int rc = LOCATION_APPMAN_ERROR_NONE;
 765
 766         rc = location_appman_set_column_int(package, LOCATION_APPMAN_COLUMN_APPID, appid);
 767         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 768                 LOCATION_APPMAN_LOG("Fail to bind int to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 769                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 770         }
 771         return LOCATION_APPMAN_ERROR_NONE;
 772 }
 773
 774 int location_appman_set_installed_date(const char *package, unsigned int installed_date)
 775 {
 776         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 777         int rc = LOCATION_APPMAN_ERROR_NONE;
 778
 779         rc = location_appman_set_column_int(package, LOCATION_APPMAN_COLUMN_INSTALLED_DATE, installed_date);
 780         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 781                 LOCATION_APPMAN_LOG("Fail to bind int to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 782                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 783         }
 784         return LOCATION_APPMAN_ERROR_NONE;
 785 }
 786
 787 int location_appman_set_recently_used(const char *package, unsigned int recently_used)
 788 {
 789         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 790         int rc = LOCATION_APPMAN_ERROR_NONE;
 791
 792         rc = location_appman_set_column_int(package, LOCATION_APPMAN_COLUMN_RECENTLY_USED, recently_used);
 793         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 794                 LOCATION_APPMAN_LOG("Fail to bind int to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 795                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 796         }
 797         return LOCATION_APPMAN_ERROR_NONE;
 798 }
 799
 800 int location_appman_set_on(const char *package, int onoff)
 801 {
 802         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 803         int rc = LOCATION_APPMAN_ERROR_NONE;
 804
 805         rc = location_appman_set_column_int(package, LOCATION_APPMAN_COLUMN_ENABLE, onoff);
 806         if (LOCATION_APPMAN_ERROR_NONE != rc) {
 807                 LOCATION_APPMAN_LOG("Fail to bind int to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 808                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 809         }
 810         return LOCATION_APPMAN_ERROR_NONE;
 811 }
 812
 813 int location_appamn_parse_manifest(const char *xml, location_appman_s ** appman)
 814 {
 815         LOCATION_APPMAN_NULL_ARG_CHECK(xml);
 816
 817         xmlDocPtr doc;
 818         xmlNodePtr cur;
 819         xmlChar *key;
 820         location_appman_s *tmp;
 821
 822         char *element[4] = { "Location", "Package", "Appid", "Enable" };
 823
 824         doc = xmlParseDoc(BAD_CAST(xml));
 825
 826         if (NULL == doc) {
 827                 LOCATION_APPMAN_LOG("Document not parsed successfully.\n");
 828                 return LOCATION_APPMAN_ERROR_INVALID_XML;
 829         }
 830
 831         cur = xmlDocGetRootElement(doc);
 832         if (NULL == cur) {
 833                 LOCATION_APPMAN_LOG("empty document\n");
 834                 xmlFreeDoc(doc);
 835                 return LOCATION_APPMAN_ERROR_INVALID_XML;
 836         }
 837
 838         if (xmlStrcmp(cur->name, (const xmlChar *)element[0]) != 0) {
 839                 LOCATION_APPMAN_LOG("document of the wrong type, root node != LocationApp\n");
 840                 xmlFreeDoc(doc);
 841                 return LOCATION_APPMAN_ERROR_INVALID_XML;
 842         }
 843
 844         tmp = (location_appman_s *) g_malloc0(sizeof(location_appman_s));
 845         cur = cur->xmlChildrenNode;
 846         while (NULL != cur) {
 847                 if (xmlStrcmp(cur->name, (const xmlChar *)element[1]) == 0) {
 848                         key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
 849
 850                         g_strlcpy(tmp->package, (char *)key, 64);
 851                         LOCATION_APPMAN_LOG("tmp->package = [%s]", tmp->package);
 852                         xmlFree(key);
 853                 } else if (xmlStrcmp(cur->name, (const xmlChar *)element[2]) == 0) {
 854                         key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
 855
 856                         tmp->appid = atoi((char *)key);
 857                         LOCATION_APPMAN_LOG("tmp->appid  = [%d]", tmp->appid);
 858                         xmlFree(key);
 859                 } else if (xmlStrcmp(cur->name, (const xmlChar *)element[3]) == 0) {
 860                         key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
 861
 862                         tmp->enable = atoi((char *)key);
 863                         LOCATION_APPMAN_LOG("tmp->enable  = [%d]", tmp->enable);
 864                         xmlFree(key);
 865                 }
 866                 cur = cur->next;
 867         }
 868
 869         *appman = tmp;
 870
 871         xmlFreeDoc(doc);
 872         return LOCATION_APPMAN_ERROR_NONE;
 873 }
 874
 875 int location_appman_get_package_by_pid(pid_t pid, location_appman_s ** appman)
 876 {
 877         if (pid <= 0) {
 878                 LOCATION_APPMAN_LOG("Invalid PID : [%ld]", pid);
 879                 return LOCATION_APPMAN_ERROR_INVALID_PARAMETER;
 880         }
 881
 882         location_appman_s *tmp = NULL;
 883         char *package = NULL;
 884         int ret = 0;
 885
 886         ret = app_manager_get_app_id(pid, &package);
 887         if (ret != APP_MANAGER_ERROR_NONE) {
 888                 const char *pkg_name = g_getenv(LOCATION_APPMAN_PKG_NAME);
 889                 if (!pkg_name) {
 890                         LOCATION_APPMAN_LOG("Can't find package name : [%ld]", pid);
 891                         return LOCATION_APPMAN_ERROR_INVALID_PARAMETER;
 892                 }
 893                 package = g_strdup(pkg_name);
 894         }
 895
 896         tmp = (location_appman_s *) g_malloc0(sizeof(location_appman_s));
 897         g_strlcpy(tmp->package, package, 64);
 898         *appman = tmp;
 899
 900         g_free(package);
 901
 902         return LOCATION_APPMAN_ERROR_NONE;
 903 }
 904
 905 int location_appman_find_package(const char *package, int *findpackage)
 906 {
 907         LOCATION_APPMAN_NULL_ARG_CHECK(package);
 908         sqlite3_stmt *state;
 909         int rc = LOCATION_APPMAN_ERROR_NONE;
 910         int enable = 0;
 911         const char *tail;
 912         char query[LOCATION_APPMAN_QUERY_MAX_LEN] = { 0, };
 913
 914         if (location_appman_open() != LOCATION_APPMAN_ERROR_NONE)
 915                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 916
 917         g_snprintf(query, LOCATION_APPMAN_QUERY_MAX_LEN, "SELECT enable FROM LocationApp WHERE package = ?");
 918
 919         rc = sqlite3_prepare_v2(db_handle, query, strlen(query), &state, &tail);
 920         if (SQLITE_OK != rc) {
 921                 LOCATION_APPMAN_LOG("sqlite3_prepare_v2 failed : Error[%s]", sqlite3_errmsg(db_handle));
 922                 location_appman_close();
 923                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 924         }
 925
 926         rc = sqlite3_bind_text(state, 1, package, strlen(package), SQLITE_STATIC);
 927         if (SQLITE_OK != rc) {
 928                 LOCATION_APPMAN_LOG("Fail to bind string to query. Error[%s]\n", sqlite3_errmsg(db_handle));
 929                 sqlite3_finalize(state);
 930                 location_appman_close();
 931
 932                 return LOCATION_APPMAN_ERROR_SQLITE_FAIL;
 933         }
 934
 935         rc = sqlite3_step(state);
 936         if (SQLITE_ROW == rc) {
 937                 enable = sqlite3_column_int(state, 0);
 938                 if (enable == 0) {
 939                         *findpackage = LOCATION_APPMAN_ENABLE_OFF;
 940                 } else {
 941                         *findpackage = LOCATION_APPMAN_ENABLE_ON;
 942                 }
 943         } else if (SQLITE_DONE) {
 944                 *findpackage = LOCATION_APPMAN_PACKAGE_NOTFOUND;
 945         }
 946
 947         sqlite3_finalize(state);
 948         location_appman_close();
 949
 950         return LOCATION_APPMAN_ERROR_NONE;
 951 }
 952
 953 int location_appman_register_package(location_appman_s * appman)
 954 {
 955         LOCATION_APPMAN_NULL_ARG_CHECK(appman);
 956         LOCATION_APPMAN_NULL_ARG_CHECK(appman->package);
 957
 958         app_info_h app_info;
 959         time_t timestamp;
 960         char *name = NULL;
 961         int ret = 0;
 962
 963         ret = app_manager_get_app_info(appman->package, &app_info);
 964         if (ret == APP_MANAGER_ERROR_NONE) {
 965                 app_info_get_label(app_info, &name);
 966                 if (name != NULL) {
 967                         g_strlcpy(appman->appname, name, 64);
 968                         g_free(name);
 969                 }
 970                 app_info_get_icon(app_info, &name);
 971                 if (name != NULL) {
 972                         g_strlcpy(appman->appicon, name, 256);
 973                         g_free(name);
 974                 }
 975         } else {
 976                 LOCATION_APPMAN_LOG("Can't get application information: [%s]", appman->package);
 977                 return LOCATION_APPMAN_ERROR_INTERNAL;
 978         }
 979
 980         // wait for a new api.
 981         //if(0 == appman->appid)
 982         //      appman->appid = 0;
 983
 984         time(&timestamp);
 985         appman->installed_date = timestamp;
 986         appman->recently_used = timestamp;
 987
 988         location_appman_insert(appman);
 989
 990         app_info_destroy(app_info);
 991
 992         return LOCATION_APPMAN_ERROR_NONE;
 993 }