src/common/media-svc-media-folder.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <glib/gstdio.h>
  23 #include <media-util-err.h>
  24 #include "media-svc-media-folder.h"
  25 #include "media-svc-debug.h"
  26 #include "media-svc-env.h"
  27 #include "media-svc-util.h"
  28 #include "media-svc-db-utils.h"
  29
  30 #define FOLDER_SCAN_DONE 4
  31
  32 extern __thread GList *g_media_svc_move_item_query_list;
  33 static __thread GList *g_media_svc_insert_folder_query_list;
  34
  35 static int __media_svc_is_root_path(const char *folder_path, bool *is_root, uid_t uid)
  36 {
  37         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
  38
  39         *is_root = FALSE;
  40         int i = 0;
  41         int start_len = 0;
  42         int path_len = 0;
  43         char *internal_path = _media_svc_get_path(uid);
  44
  45         if (STRING_VALID(internal_path) && (strcmp(folder_path, internal_path) == 0)) {
  46                 media_svc_debug("ROOT PATH [%s]", folder_path);
  47                 *is_root = TRUE;
  48
  49                 SAFE_FREE(internal_path);
  50
  51                 return MS_MEDIA_ERR_NONE;
  52         }
  53         SAFE_FREE(internal_path);
  54
  55         if ((STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && strncmp(folder_path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0) ||
  56                 (STRING_VALID(MEDIA_ROOT_PATH_CLOUD) && strncmp(folder_path, MEDIA_ROOT_PATH_CLOUD, strlen(MEDIA_ROOT_PATH_CLOUD)) == 0)) {
  57
  58                 start_len = strlen(MEDIA_ROOT_PATH_SDCARD);
  59                 path_len = strlen(folder_path);
  60
  61                 for (i = start_len; i < path_len; i++) {
  62                         if (folder_path[i] == '/')
  63                                 return MS_MEDIA_ERR_NONE;
  64                 }
  65
  66                 media_svc_debug("ROOT PATH [%s]", folder_path);
  67                 *is_root = TRUE;
  68         }
  69
  70         return MS_MEDIA_ERR_NONE;
  71 }
  72
  73 static int __media_svc_parent_is_ext_root_path(const char *folder_path, bool *is_root)
  74 {
  75         char *parent_folder_path = NULL;
  76
  77         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
  78
  79         *is_root = FALSE;
  80
  81         parent_folder_path = g_path_get_dirname(folder_path);
  82
  83         if (!STRING_VALID(parent_folder_path)) {
  84                 media_svc_error("error : g_path_get_dirname falied");
  85                 SAFE_FREE(parent_folder_path);
  86                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
  87         }
  88
  89         if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (strcmp(parent_folder_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
  90                 media_svc_debug("parent folder is ROOT PATH [%s]", parent_folder_path);
  91                 *is_root = TRUE;
  92         }
  93
  94         SAFE_FREE(parent_folder_path);
  95
  96         return MS_MEDIA_ERR_NONE;
  97 }
  98
  99 int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, uid_t uid)
 100 {
 101         int ret = MS_MEDIA_ERR_NONE;
 102         sqlite3_stmt *sql_stmt = NULL;
 103         char *sql = NULL;
 104         char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
 105         char *temp_parent_uuid = NULL;
 106         char *parent_folder_path = NULL;
 107
 108         sql = sqlite3_mprintf("SELECT folder_uuid, parent_folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
 109
 110         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 111
 112         if (ret != MS_MEDIA_ERR_NONE) {
 113                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 114                         media_svc_debug("there is no folder.");
 115                 } else {
 116                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
 117                 }
 118                 return ret;
 119         }
 120
 121         memset(parent_folder_uuid, 0, sizeof(parent_folder_uuid));
 122
 123         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
 124         if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1)))       /*root path can be null*/
 125                 _strncpy_safe(parent_folder_uuid, (const char *)sqlite3_column_text(sql_stmt, 1), MEDIA_SVC_UUID_SIZE+1);
 126
 127         SQLITE3_FINALIZE(sql_stmt);
 128
 129         /*root path can be null*/
 130         if (!STRING_VALID(parent_folder_uuid)) {
 131                 bool is_root = FALSE;
 132
 133                 ret = __media_svc_is_root_path(folder_name, &is_root, uid);
 134                 if (is_root)
 135                         return MS_MEDIA_ERR_NONE;
 136
 137                 ret = __media_svc_parent_is_ext_root_path(folder_name, &is_root);
 138                 if (is_root)
 139                         return MS_MEDIA_ERR_NONE;
 140         }
 141
 142         /* Notice : Below code is the code only for inserting parent folder uuid when upgrade the media db version 3 to 4 */
 143         /* Check parent folder uuid */
 144         if (!STRING_VALID(parent_folder_uuid)) {
 145                 /* update parent_uuid */
 146                 media_svc_error("[No-Error] there is no parent folder uuid. PLEASE CHECK IT");
 147
 148                 parent_folder_path = g_path_get_dirname(folder_name);
 149                 if (!STRING_VALID(parent_folder_path)) {
 150                         media_svc_error("error : g_path_get_dirname falied.");
 151                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
 152                 }
 153
 154                 if (STRING_VALID(storage_id))
 155                         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, parent_folder_path);
 156                 else
 157                         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_path);
 158
 159                 SAFE_FREE(parent_folder_path);
 160
 161                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 162                 if (ret == MS_MEDIA_ERR_NONE) {
 163                         temp_parent_uuid = (char *)sqlite3_column_text(sql_stmt, 0);
 164                         if (temp_parent_uuid != NULL) {
 165                                 _strncpy_safe(parent_folder_uuid, temp_parent_uuid, MEDIA_SVC_UUID_SIZE+1);
 166                         }
 167
 168                         SQLITE3_FINALIZE(sql_stmt);
 169                 }
 170
 171                 if (STRING_VALID(parent_folder_uuid)) {
 172                         if (STRING_VALID(storage_id))
 173                                 sql = sqlite3_mprintf("UPDATE %q SET parent_folder_uuid = '%q' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_uuid, storage_id, folder_name);
 174                         else
 175                                 sql = sqlite3_mprintf("UPDATE %q SET parent_folder_uuid = '%q' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_uuid, folder_name);
 176                         ret = _media_svc_sql_query(sql, uid);
 177                         sqlite3_free(sql);
 178                 } else {
 179                         media_svc_error("error when get parent folder uuid");
 180                 }
 181         }
 182
 183         return ret;
 184 }
 185
 186 static int __media_svc_append_folder(const char *storage_id, media_svc_storage_type_e storage_type,
 187                         const char *folder_id, const char *folder_path, const char *parent_folder_uuid, bool stack_query, uid_t uid)
 188 {
 189         int ret = MS_MEDIA_ERR_NONE;
 190         char *folder_name = NULL;
 191         int folder_modified_date = 0;
 192
 193         folder_name = g_path_get_basename(folder_path);
 194         folder_modified_date = _media_svc_get_file_time(folder_path);
 195
 196         /*Update Pinyin If Support Pinyin*/
 197         char *folder_name_pinyin = NULL;
 198         if (_media_svc_check_pinyin_support())
 199                 _media_svc_get_pinyin_str(folder_name, &folder_name_pinyin);
 200
 201         char *sql = sqlite3_mprintf("INSERT INTO %s (folder_uuid, path, name, storage_uuid, storage_type, modified_time, name_pinyin, parent_folder_uuid) \
 202                                                         values (%Q, %Q, %Q, %Q, '%d', '%d', %Q, %Q); ",
 203                                                         MEDIA_SVC_DB_TABLE_FOLDER, folder_id, folder_path, folder_name, storage_id, storage_type, folder_modified_date, folder_name_pinyin, parent_folder_uuid);
 204
 205         if (!stack_query) {
 206                 ret = _media_svc_sql_query(sql, uid);
 207                 sqlite3_free(sql);
 208         } else {
 209                 _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 210         }
 211
 212         SAFE_FREE(folder_name);
 213         SAFE_FREE(folder_name_pinyin);
 214
 215         return ret;
 216 }
 217
 218 int _media_svc_update_folder_modified_time_by_folder_uuid(const char *folder_uuid, const char *folder_path, bool stack_query, uid_t uid)
 219 {
 220         int ret = MS_MEDIA_ERR_NONE;
 221         int modified_time = 0;
 222
 223         modified_time = _media_svc_get_file_time(folder_path);
 224
 225         char *sql = sqlite3_mprintf("UPDATE %s SET modified_time=%d WHERE folder_uuid=%Q;", MEDIA_SVC_DB_TABLE_FOLDER, modified_time, folder_uuid);
 226
 227         if (!stack_query) {
 228                 ret = _media_svc_sql_query(sql, uid);
 229                 sqlite3_free(sql);
 230         } else {
 231                 _media_svc_sql_query_add(&g_media_svc_move_item_query_list, &sql);
 232         }
 233
 234         return ret;
 235 }
 236
 237 static int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
 238 {
 239         int ret = MS_MEDIA_ERR_NONE;
 240         unsigned int next_pos = 0;
 241         char *next = NULL;
 242         char *dir_path = NULL;
 243         const char *token = "/";
 244         char *folder_uuid = NULL;
 245         char parent_folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 246         bool folder_search_end = FALSE;
 247         char *internal_path = NULL;
 248
 249         memset(parent_folder_uuid, 0, sizeof(parent_folder_uuid));
 250         internal_path = _media_svc_get_path(uid);
 251
 252         if (STRING_VALID(internal_path) && (strncmp(path, internal_path, strlen(internal_path)) == 0))
 253                 next_pos = strlen(internal_path);
 254         else if (STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && strncmp(path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0)
 255                 next_pos = strlen(MEDIA_ROOT_PATH_SDCARD);
 256         else if (STRING_VALID(MEDIA_ROOT_PATH_CLOUD) && (strncmp(path, MEDIA_ROOT_PATH_CLOUD, strlen(MEDIA_ROOT_PATH_CLOUD)) == 0))
 257                 next_pos = strlen(MEDIA_ROOT_PATH_CLOUD);
 258         else if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && strncmp(path, MEDIA_ROOT_PATH_EXTERNAL, strlen(MEDIA_ROOT_PATH_EXTERNAL)) == 0)
 259                 next_pos = strlen(MEDIA_ROOT_PATH_EXTERNAL);
 260         else {
 261                 media_svc_error("Invalid Path");
 262                 SAFE_FREE(internal_path);
 263                 return MS_MEDIA_ERR_INTERNAL;
 264         }
 265
 266         SAFE_FREE(internal_path);
 267
 268         while (!folder_search_end) {
 269                 next = strstr(path + next_pos, token);
 270                 if (next != NULL) {
 271                         next_pos = (next - path);
 272                         dir_path = strndup(path, next_pos);
 273                         next_pos++;
 274                 } else {
 275                         dir_path = strndup(path, strlen(path));
 276                         folder_search_end = TRUE;
 277                         media_svc_error("[No-Error] End Path [%s]", dir_path);
 278                 }
 279
 280                 if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (strcmp(dir_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
 281                         /*To avoid insert MEDIA_ROOT_PATH_EXTERNAL path*/
 282                         continue;
 283                 }
 284
 285                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, dir_path, parent_folder_uuid, uid);
 286                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 287                         folder_uuid = _media_info_generate_uuid();
 288                         if (folder_uuid == NULL) {
 289                                 media_svc_error("Invalid UUID");
 290                                 SAFE_FREE(dir_path);
 291                                 return MS_MEDIA_ERR_INTERNAL;
 292                         }
 293
 294                         ret = __media_svc_append_folder(storage_id, storage_type, folder_uuid, dir_path, parent_folder_uuid, FALSE, uid);
 295                         if (ret != MS_MEDIA_ERR_NONE) {
 296                                 media_svc_error("__media_svc_append_folder is failed");
 297                         }
 298
 299                         media_svc_error("[No-Error] New Appended folder path [%s], folder_uuid [%s], parent_folder_uuid [%s]", dir_path, folder_uuid, parent_folder_uuid);
 300                         _strncpy_safe(parent_folder_uuid, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
 301                 } else {
 302                         media_svc_error("EXIST dir path : %s\n", dir_path);
 303                 }
 304
 305                 SAFE_FREE(dir_path);
 306         }
 307
 308         if (STRING_VALID(folder_uuid)) {
 309                 _strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
 310         } else {
 311                 media_svc_error("Fail to get folder_uuid");
 312                 return MS_MEDIA_ERR_INTERNAL;
 313         }
 314
 315         return MS_MEDIA_ERR_NONE;
 316 }
 317
 318 int _media_svc_get_and_append_folder(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
 319 {
 320         int ret = MS_MEDIA_ERR_NONE;
 321
 322         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path, folder_id, uid);
 323
 324         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 325                 ret = __media_svc_get_and_append_parent_folder(handle, storage_id, path, storage_type, folder_id, uid);
 326         }
 327
 328         return ret;
 329 }
 330
 331 int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
 332 {
 333         char *dir_path = NULL;
 334         int ret = MS_MEDIA_ERR_NONE;
 335
 336         dir_path = g_path_get_dirname(path);
 337
 338         ret = _media_svc_get_and_append_folder(handle, storage_id, dir_path, storage_type, folder_id, uid);
 339
 340         SAFE_FREE(dir_path);
 341
 342         return ret;
 343 }
 344
 345 int _media_svc_update_folder_table(const char *storage_id, uid_t uid)
 346 {
 347         int ret = MS_MEDIA_ERR_NONE;
 348         char *sql = NULL;
 349
 350         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE folder_uuid IN (SELECT folder_uuid FROM '%s' WHERE folder_uuid NOT IN (SELECT folder_uuid FROM '%s'));",
 351                 MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, storage_id);
 352
 353         ret = _media_svc_sql_query(sql, uid);
 354         sqlite3_free(sql);
 355
 356         return ret;
 357 }
 358
 359 static int __media_svc_count_all_folders(sqlite3 *handle, char *start_path, int *count)
 360 {
 361         int ret = MS_MEDIA_ERR_NONE;
 362         sqlite3_stmt *sql_stmt = NULL;
 363         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 364
 365         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 366         if (ret != MS_MEDIA_ERR_NONE) {
 367                 media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
 368                 return ret;
 369         }
 370
 371         *count = sqlite3_column_int(sql_stmt, 0);
 372
 373         SQLITE3_FINALIZE(sql_stmt);
 374
 375         return MS_MEDIA_ERR_NONE;
 376 }
 377
 378 int _media_svc_get_all_folders(sqlite3 *handle, char *start_path, char ***folder_list, time_t **modified_time_list, int **item_num_list, int *count)
 379 {
 380         int ret = MS_MEDIA_ERR_NONE;
 381         int idx = 0;
 382         sqlite3_stmt *sql_stmt = NULL;
 383         char *sql = NULL;
 384         int cnt = 0;
 385         char **folder_uuid = NULL;
 386         int i = 0;
 387
 388         ret = __media_svc_count_all_folders(handle, start_path, &cnt);
 389         if (ret != MS_MEDIA_ERR_NONE) {
 390                 media_svc_error("error when __media_svc_count_all_folders. err = [%d]", ret);
 391                 return ret;
 392         }
 393
 394         if (cnt > 0) {
 395                 sql = sqlite3_mprintf("SELECT path, modified_time, folder_uuid FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 396         } else {
 397                 *folder_list = NULL;
 398                 *modified_time_list = NULL;
 399                 *item_num_list = NULL;
 400                 return MS_MEDIA_ERR_NONE;
 401         }
 402
 403         *folder_list = malloc(sizeof(char *) * cnt);
 404         *modified_time_list = malloc(sizeof(int) * cnt);
 405         *item_num_list = malloc(sizeof(int) * cnt);
 406         folder_uuid = malloc(sizeof(char *) * cnt);
 407
 408         if ((*folder_list == NULL) || (*modified_time_list == NULL) || (*item_num_list == NULL) || (folder_uuid == NULL)) {
 409                 media_svc_error("Out of memory");
 410                 goto ERROR;
 411         }
 412         memset(folder_uuid, 0x0, sizeof(char *) * cnt);
 413         memset(*folder_list, 0x0, sizeof(char *) * cnt);
 414
 415         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 416         if (ret != MS_MEDIA_ERR_NONE) {
 417                 media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 418                 goto ERROR;
 419         }
 420
 421         media_svc_debug("QEURY OK");
 422
 423         while (1) {
 424                 (*folder_list)[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 0));
 425                 (*modified_time_list)[idx] = (int)sqlite3_column_int(sql_stmt, 1);
 426
 427                 /* get the folder's id */
 428                 folder_uuid[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 2));
 429
 430                 idx++;
 431
 432                 if (sqlite3_step(sql_stmt) != SQLITE_ROW)
 433                         break;
 434         }
 435         SQLITE3_FINALIZE(sql_stmt);
 436
 437         /*get the numbder of item in the folder by using folder's id */
 438         for (i = 0; i < idx; i++) {
 439                 if (STRING_VALID(folder_uuid[i])) {
 440                         sql = sqlite3_mprintf("SELECT COUNT(*) FROM %s WHERE (folder_uuid='%q' AND validity = 1)", MEDIA_SVC_DB_TABLE_MEDIA, folder_uuid[i]);
 441                         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 442                         if (ret != MS_MEDIA_ERR_NONE) {
 443                                 media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 444                                 goto ERROR;
 445                         }
 446
 447                         (*item_num_list)[i] = (int)sqlite3_column_int(sql_stmt, 0);
 448
 449                         SQLITE3_FINALIZE(sql_stmt);
 450                 } else {
 451                         media_svc_error("Invalid Folder Id");
 452                 }
 453         }
 454
 455         if (cnt == idx) {
 456                 *count = cnt;
 457                 media_svc_debug("Get Folder is OK");
 458         } else {
 459                 media_svc_error("Fail to get folder");
 460                 ret = MS_MEDIA_ERR_INTERNAL;
 461                 goto ERROR;
 462         }
 463
 464         /* free all data */
 465         for (i = 0; i < idx; i++) {
 466                 SAFE_FREE(folder_uuid[i]);
 467         }
 468         SAFE_FREE(folder_uuid);
 469
 470         return ret;
 471
 472 ERROR:
 473
 474         /* free all data */
 475         for (i = 0; i < idx; i++) {
 476                 SAFE_FREE((*folder_list)[i]);
 477                 SAFE_FREE(folder_uuid[i]);
 478         }
 479         SAFE_FREE(*folder_list);
 480         SAFE_FREE(*modified_time_list);
 481         SAFE_FREE(*item_num_list);
 482         SAFE_FREE(folder_uuid);
 483
 484         *count = 0;
 485
 486         return ret;
 487 }
 488
 489 int _media_svc_get_folder_info_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, time_t *modified_time)
 490 {
 491         int ret = MS_MEDIA_ERR_NONE;
 492         sqlite3_stmt *sql_stmt = NULL;
 493
 494         char *sql = sqlite3_mprintf("SELECT folder_uuid, modified_time FROM %s WHERE (storage_uuid = '%q' AND path = '%q');", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
 495
 496         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 497
 498         if (ret != MS_MEDIA_ERR_NONE) {
 499                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 500                         media_svc_debug("there is no folder.");
 501                 } else {
 502                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
 503                 }
 504                 return ret;
 505         }
 506
 507         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
 508         *modified_time = (int)sqlite3_column_int(sql_stmt, 1);
 509
 510         SQLITE3_FINALIZE(sql_stmt);
 511
 512         return ret;
 513 }
 514
 515 int _media_svc_get_and_append_folder_id_by_folder_path(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, bool stack_query, uid_t uid)
 516 {
 517         char *path_name = NULL;
 518         int ret = MS_MEDIA_ERR_NONE;
 519         char *sql = NULL;
 520
 521         path_name = strdup(path);
 522         if (path_name == NULL) {
 523                 media_svc_error("out of memory");
 524                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
 525         }
 526
 527         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path_name, folder_id, uid);
 528         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 529                 bool is_root = FALSE;
 530                 bool is_parent_root = FALSE;
 531
 532                 ret = __media_svc_is_root_path(path_name, &is_root, uid);
 533                 ret = __media_svc_parent_is_ext_root_path(path_name, &is_parent_root);
 534
 535                 char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
 536                 memset(parent_folder_uuid, 0x00, sizeof(parent_folder_uuid));
 537
 538                 if ((is_root == FALSE) && (is_parent_root == FALSE)) {
 539                         /*get parent folder id*/
 540                         char *parent_path_name = g_path_get_dirname(path_name);
 541
 542                         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, parent_path_name, parent_folder_uuid, uid);
 543                         if (ret != MS_MEDIA_ERR_NONE) {
 544                                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 545                                 /*if No-Root directory scanning start before doing storage scanning, parent_folder_uuid can be NULL.
 546                                 You can remove above logic if use below logic always. but I keep above code for the performance issue.
 547                                 Most case (except No-Root directory scanning start before doing storage scanning) get parent_folder_uuid well*/
 548                                 media_svc_error("[No-Error] There is no proper parent_folder_uuid. so try to make it");
 549                                 ret = _media_svc_get_and_append_folder(handle, storage_id, path, storage_type, folder_id, uid);
 550                                 } else {
 551                                         media_svc_error("error when _media_svc_get_parent_folder_id_by_foldername. err = [%d]", ret);
 552                                 }
 553
 554                                 SAFE_FREE(path_name);
 555                                 SAFE_FREE(parent_path_name);
 556
 557                                 return ret;
 558                         }
 559                 }
 560
 561                 char *folder_uuid = _media_info_generate_uuid();
 562                 if (folder_uuid == NULL) {
 563                         media_svc_error("Invalid UUID");
 564                         SAFE_FREE(path_name);
 565                         return MS_MEDIA_ERR_INTERNAL;
 566                 }
 567
 568                 ret = __media_svc_append_folder(storage_id, storage_type, folder_uuid, path_name, parent_folder_uuid, stack_query, uid);
 569
 570                 _strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE+1);
 571
 572         } else {
 573                 sql = sqlite3_mprintf("UPDATE '%s' SET validity=1 WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 574
 575                 if (!stack_query) {
 576                         ret = _media_svc_sql_query(sql, uid);
 577                         sqlite3_free(sql);
 578                 } else {
 579                         _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 580                 }
 581         }
 582
 583         SAFE_FREE(path_name);
 584
 585         return ret;
 586 }
 587
 588 int _media_svc_delete_invalid_folder(const char *storage_id, int storage_type, uid_t uid)
 589 {
 590         int ret = MS_MEDIA_ERR_NONE;
 591         char *sql = NULL;
 592
 593         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d validity = 0;", MEDIA_SVC_DB_TABLE_FOLDER, storage_type, storage_id);
 594         ret = _media_svc_sql_query(sql, uid);
 595
 596         sqlite3_free(sql);
 597
 598         return ret;
 599 }
 600
 601 int _media_svc_set_folder_validity(sqlite3 *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid)
 602 {
 603         int ret = MS_MEDIA_ERR_NONE;
 604         char *sql = NULL;
 605         char start_path_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
 606
 607         if (is_recursive) {
 608                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, start_path, start_path_id, uid);
 609                 media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_folder_id_by_foldername fail");
 610                 media_svc_retvm_if(!STRING_VALID(start_path_id), MS_MEDIA_ERR_INVALID_PARAMETER, "start_path_id is NULL");
 611
 612                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND (path LIKE '%q/%%' OR folder_uuid ='%q')",
 613                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path, start_path_id);
 614         } else {
 615                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND path = '%q';",
 616                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path);
 617         }
 618
 619         ret = _media_svc_sql_query(sql, uid);
 620
 621         sqlite3_free(sql);
 622
 623         return ret;
 624 }
 625
 626 int _media_svc_delete_folder_by_storage_id(const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 627 {
 628         int ret = MS_MEDIA_ERR_NONE;
 629         char *sql = NULL;
 630
 631         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d;", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, storage_type);
 632         ret = _media_svc_sql_query(sql, uid);
 633
 634         sqlite3_free(sql);
 635
 636         return ret;
 637 }
 638
 639 GList **_media_svc_get_folder_list_ptr(void)
 640 {
 641         return &g_media_svc_insert_folder_query_list;
 642 }
 643
 644 int _media_svc_get_folder_scan_status(sqlite3 *handle, const char *storage_id, const char *path, int *scan_status)
 645 {
 646         int ret = MS_MEDIA_ERR_NONE;
 647         sqlite3_stmt *sql_stmt = NULL;
 648         char *sql = NULL;
 649
 650         if (!STRING_VALID(path)) {
 651                 media_svc_error("Not found valid path");
 652                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 653         }
 654
 655         sql = sqlite3_mprintf("SELECT scan_status FROM '%s' WHERE path = '%q' AND storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 656
 657         ret = _media_svc_sql_prepare_to_step_simple(handle, sql, &sql_stmt);
 658
 659         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 660
 661         while (sqlite3_step(sql_stmt) == SQLITE_ROW) {
 662                 *scan_status = sqlite3_column_int(sql_stmt, 0);
 663         }
 664
 665         SQLITE3_FINALIZE(sql_stmt);
 666
 667         return ret;
 668 }
 669
 670 int _media_svc_set_folder_scan_status(const char *storage_id, const char *path, int scan_status, uid_t uid)
 671 {
 672         int ret = MS_MEDIA_ERR_NONE;
 673         char *sql = NULL;
 674
 675         if (path) {
 676                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE path = '%q' AND storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, scan_status, path, storage_id);
 677         } else {
 678                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, scan_status, storage_id);
 679         }
 680
 681         ret = _media_svc_sql_query(sql, uid);
 682         sqlite3_free(sql);
 683
 684         return ret;
 685 }
 686
 687 int _media_svc_get_folder_modified_time_by_path(sqlite3 *handle, const char *path, const char *storage_id, time_t *modified_time)
 688 {
 689         int ret = MS_MEDIA_ERR_NONE;
 690         sqlite3_stmt *sql_stmt = NULL;
 691
 692         char *sql = sqlite3_mprintf("SELECT modified_time FROM '%s' WHERE path = '%q' AND storage_uuid = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 693
 694         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 695
 696         if (ret != MS_MEDIA_ERR_NONE) {
 697                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 698                         media_svc_debug("there is no folder.");
 699                 } else {
 700                         media_svc_error("error when _media_svc_get_folder_modified_time_by_path. err = [%d]", ret);
 701                 }
 702                 return ret;
 703         }
 704
 705         *modified_time = (int)sqlite3_column_int(sql_stmt, 0);
 706
 707         SQLITE3_FINALIZE(sql_stmt);
 708
 709         return ret;
 710 }
 711
 712 int _media_svc_get_null_scan_folder_list(sqlite3 *handle, const char *storage_id, const char *path, char ***folder_list, int *count)
 713 {
 714         int ret = MS_MEDIA_ERR_NONE;
 715         int idx = 0;
 716         int cnt = 0;
 717         char *sql = NULL;
 718         char folder_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
 719         sqlite3_stmt *sql_stmt = NULL;
 720
 721         if (path == NULL) {
 722                 sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE storage_uuid = '%q' AND scan_status!=%d", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, FOLDER_SCAN_DONE);
 723                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 724
 725                 if (ret != MS_MEDIA_ERR_NONE) {
 726                         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 727                                 media_svc_debug("there is no folder.");
 728                         } else {
 729                                 media_svc_error("error when get folder_id by path. err = [%d]", ret);
 730                         }
 731
 732                         *folder_list = NULL;
 733                         *count = 0;
 734
 735                         return ret;
 736                 }
 737
 738                 cnt = sqlite3_column_int(sql_stmt, 0);
 739                 SQLITE3_FINALIZE(sql_stmt);
 740                 if (cnt > 0) {
 741                         sql = sqlite3_mprintf("SELECT path FROM '%s' WHERE storage_uuid = '%q' AND scan_status!=%d", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, FOLDER_SCAN_DONE);
 742                 } else {
 743                         *folder_list = NULL;
 744                         *count = 0;
 745
 746                         return MS_MEDIA_ERR_INTERNAL;
 747                 }
 748
 749                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 750
 751                 if (ret != MS_MEDIA_ERR_NONE) {
 752                         media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 753
 754                         *folder_list = NULL;
 755                         *count = 0;
 756
 757                         return ret;
 758                 }
 759         } else {
 760                 sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 761                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 762
 763                 if (ret != MS_MEDIA_ERR_NONE) {
 764                         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 765                                 media_svc_debug("there is no folder.");
 766                         } else {
 767                                 media_svc_error("error when get folder_id by path [%s]. err = [%d]", path, ret);
 768                         }
 769                         return ret;
 770                 }
 771
 772                 _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
 773
 774                 SQLITE3_FINALIZE(sql_stmt);
 775
 776                 sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path LIKE '%q%%' AND parent_folder_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, folder_id);
 777
 778                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 779
 780                 if (ret != MS_MEDIA_ERR_NONE) {
 781                         media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
 782                         return ret;
 783                 }
 784
 785                 cnt = sqlite3_column_int(sql_stmt, 0);
 786                 SQLITE3_FINALIZE(sql_stmt);
 787                 if (cnt > 0) {
 788                         sql = sqlite3_mprintf("SELECT path FROM '%s' WHERE path LIKE '%q%%' AND parent_folder_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, folder_id);
 789                 } else {
 790                         *folder_list = NULL;
 791                         *count = 0;
 792
 793                         return MS_MEDIA_ERR_NONE;
 794                 }
 795
 796                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 797
 798                 if (ret != MS_MEDIA_ERR_NONE) {
 799                         media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 800
 801                         *folder_list = NULL;
 802                         *count = 0;
 803
 804                         return ret;
 805                 }
 806         }
 807
 808         *folder_list = malloc(sizeof(char *) * cnt);
 809
 810         while (1) {
 811                 (*folder_list)[idx] = strdup((char *)sqlite3_column_text(sql_stmt, 0));
 812
 813                 if (sqlite3_step(sql_stmt) != SQLITE_ROW)
 814                         break;
 815                 idx++;
 816         }
 817
 818         if (cnt == idx + 1) {
 819                 *count = cnt;
 820                 media_svc_debug("OK");
 821         } else {
 822                 /* free all data */
 823                 int i = 0;
 824                 for (i  = 0; i < idx; i++) {
 825                         SAFE_FREE((*folder_list)[i]);
 826                 }
 827                 SAFE_FREE(*folder_list);
 828                 *count = 0;
 829                 ret = MS_MEDIA_ERR_INTERNAL;
 830         }
 831
 832         SQLITE3_FINALIZE(sql_stmt);
 833
 834         return ret;
 835 }
 836
 837 int _media_svc_delete_invalid_folder_by_path(sqlite3 *handle, const char *storage_id, const char *folder_path, uid_t uid, int *delete_count)
 838 {
 839         int ret = MS_MEDIA_ERR_NONE;
 840         char *sql = NULL;
 841         int del_count = 0;
 842         sqlite3_stmt *sql_stmt = NULL;
 843
 844         if (folder_path == NULL)
 845                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 846
 847         /*check the number of the deleted folder*/
 848         sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE (storage_uuid = '%q' AND validity = 0 AND PATH LIKE '%q/%%');", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_path);
 849
 850         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 851         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 852
 853         del_count = sqlite3_column_int(sql_stmt, 0);
 854
 855         SQLITE3_FINALIZE(sql_stmt);
 856         sql = NULL;
 857
 858         /*delete invalid folder*/
 859         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE (storage_uuid = '%q' AND validity = 0 AND PATH LIKE '%q%%');", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_path);
 860         ret = _media_svc_sql_query(sql, uid);
 861
 862         sqlite3_free(sql);
 863
 864         *delete_count = del_count;
 865
 866         return ret;
 867 }
 868
 869 int _media_svc_count_folder_with_path(sqlite3 *handle, const char *storage_id, const char *path, int *count)
 870 {
 871         int ret = MS_MEDIA_ERR_NONE;
 872         sqlite3_stmt *sql_stmt = NULL;
 873
 874         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE (storage_uuid='%q' AND path='%q')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 875
 876         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 877
 878         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 879
 880         *count = sqlite3_column_int(sql_stmt, 0);
 881
 882         SQLITE3_FINALIZE(sql_stmt);
 883
 884         return MS_MEDIA_ERR_NONE;
 885 }
 886
 887 int _media_svc_count_subfolder_with_path(sqlite3 *handle, const char *storage_id, const char *path, int *count)
 888 {
 889         int ret = MS_MEDIA_ERR_NONE;
 890         sqlite3_stmt *sql_stmt = NULL;
 891
 892         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE (storage_uuid='%q' AND path LIKE'%q/%%')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 893
 894         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 895
 896         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 897
 898         *count = sqlite3_column_int(sql_stmt, 0);
 899
 900         SQLITE3_FINALIZE(sql_stmt);
 901
 902         return MS_MEDIA_ERR_NONE;
 903 }
 904
 905 int _media_svc_get_folder_uuid(sqlite3 *handle, const char *storage_id, const char *path, char *folder_id)
 906 {
 907         int ret = MS_MEDIA_ERR_NONE;
 908         sqlite3_stmt *sql_stmt = NULL;
 909         char *sql = NULL;
 910
 911         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE (storage_uuid='%q' AND path='%q')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 912
 913         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 914
 915         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 916
 917         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
 918
 919         SQLITE3_FINALIZE(sql_stmt);
 920
 921         if (!STRING_VALID(folder_id)) {
 922                 media_svc_error("Not found valid storage id [%s]", path);
 923                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 924         }
 925
 926         return ret;
 927 }
 928