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
  57                 start_len = strlen(MEDIA_ROOT_PATH_SDCARD);
  58                 path_len = strlen(folder_path);
  59
  60                 for (i = start_len; i < path_len; i++) {
  61                         if (folder_path[i] == '/')
  62                                 return MS_MEDIA_ERR_NONE;
  63                 }
  64
  65                 media_svc_debug("ROOT PATH [%s]", folder_path);
  66                 *is_root = TRUE;
  67         } else if ((STRING_VALID(MEDIA_ROOT_PATH_CLOUD) && strcmp(folder_path, MEDIA_ROOT_PATH_CLOUD) == 0) ||
  68                 (STRING_VALID(MEDIA_ROOT_PATH_DISC) && strcmp(folder_path, MEDIA_ROOT_PATH_DISC) == 0)) {
  69                 media_svc_debug("ROOT PATH [%s]", folder_path);
  70                 *is_root = TRUE;
  71         }
  72
  73         return MS_MEDIA_ERR_NONE;
  74 }
  75
  76 static int __media_svc_parent_is_ext_root_path(const char *folder_path, bool *is_root)
  77 {
  78         char *parent_folder_path = NULL;
  79
  80         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
  81
  82         *is_root = FALSE;
  83
  84         parent_folder_path = g_path_get_dirname(folder_path);
  85
  86         if (!STRING_VALID(parent_folder_path)) {
  87                 media_svc_error("error : g_path_get_dirname falied");
  88                 SAFE_FREE(parent_folder_path);
  89                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
  90         }
  91
  92         if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (strcmp(parent_folder_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
  93                 media_svc_debug("parent folder is ROOT PATH [%s]", parent_folder_path);
  94                 *is_root = TRUE;
  95         }
  96
  97         SAFE_FREE(parent_folder_path);
  98
  99         return MS_MEDIA_ERR_NONE;
 100 }
 101
 102 int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, uid_t uid)
 103 {
 104         int ret = MS_MEDIA_ERR_NONE;
 105         sqlite3_stmt *sql_stmt = NULL;
 106         char *sql = NULL;
 107         char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
 108         char *temp_parent_uuid = NULL;
 109         char *parent_folder_path = NULL;
 110
 111         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);
 112
 113         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 114
 115         if (ret != MS_MEDIA_ERR_NONE) {
 116                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 117                         media_svc_debug("there is no folder.");
 118                 else
 119                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
 120
 121                 return ret;
 122         }
 123
 124         memset(parent_folder_uuid, 0, sizeof(parent_folder_uuid));
 125
 126         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
 127         if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1)))       /*root path can be null*/
 128                 _strncpy_safe(parent_folder_uuid, (const char *)sqlite3_column_text(sql_stmt, 1), MEDIA_SVC_UUID_SIZE+1);
 129
 130         SQLITE3_FINALIZE(sql_stmt);
 131
 132         /*root path can be null*/
 133         if (!STRING_VALID(parent_folder_uuid)) {
 134                 bool is_root = FALSE;
 135
 136                 ret = __media_svc_is_root_path(folder_name, &is_root, uid);
 137                 if (is_root)
 138                         return MS_MEDIA_ERR_NONE;
 139
 140                 ret = __media_svc_parent_is_ext_root_path(folder_name, &is_root);
 141                 if (is_root)
 142                         return MS_MEDIA_ERR_NONE;
 143         }
 144
 145         /* Notice : Below code is the code only for inserting parent folder uuid when upgrade the media db version 3 to 4 */
 146         /* Check parent folder uuid */
 147         if (!STRING_VALID(parent_folder_uuid)) {
 148                 /* update parent_uuid */
 149                 media_svc_error("[No-Error] there is no parent folder uuid. PLEASE CHECK IT");
 150
 151                 parent_folder_path = g_path_get_dirname(folder_name);
 152                 if (!STRING_VALID(parent_folder_path)) {
 153                         media_svc_error("error : g_path_get_dirname falied.");
 154                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
 155                 }
 156
 157                 if (STRING_VALID(storage_id))
 158                         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);
 159                 else
 160                         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_path);
 161
 162                 SAFE_FREE(parent_folder_path);
 163
 164                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 165                 if (ret == MS_MEDIA_ERR_NONE) {
 166                         temp_parent_uuid = (char *)sqlite3_column_text(sql_stmt, 0);
 167                         if (temp_parent_uuid != NULL)
 168                                 _strncpy_safe(parent_folder_uuid, temp_parent_uuid, MEDIA_SVC_UUID_SIZE+1);
 169
 170                         SQLITE3_FINALIZE(sql_stmt);
 171                 }
 172
 173                 if (STRING_VALID(parent_folder_uuid)) {
 174                         if (STRING_VALID(storage_id))
 175                                 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);
 176                         else
 177                                 sql = sqlite3_mprintf("UPDATE %q SET parent_folder_uuid = '%q' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_uuid, folder_name);
 178                         ret = _media_svc_sql_query(sql, uid);
 179                         sqlite3_free(sql);
 180                 } else {
 181                         media_svc_error("error when get parent folder uuid");
 182                 }
 183         }
 184
 185         return ret;
 186 }
 187
 188 static int __media_svc_append_folder(const char *storage_id, media_svc_storage_type_e storage_type,
 189                         const char *folder_id, const char *folder_path, const char *parent_folder_uuid, bool stack_query, uid_t uid)
 190 {
 191         int ret = MS_MEDIA_ERR_NONE;
 192         char *folder_name = NULL;
 193         int folder_modified_date = 0;
 194
 195         folder_name = g_path_get_basename(folder_path);
 196         folder_modified_date = _media_svc_get_file_time(folder_path);
 197
 198         /*Update Pinyin If Support Pinyin*/
 199         char *folder_name_pinyin = NULL;
 200         if (_media_svc_check_pinyin_support())
 201                 _media_svc_get_pinyin_str(folder_name, &folder_name_pinyin);
 202         /* Sometime SQLITE3 returns NO_RECORD, so need to consider conflict case.. */
 203         media_svc_debug("UNIQUE:path[%s], storage_uuid[%s]", folder_path, storage_id);
 204         char *sql = sqlite3_mprintf("INSERT OR IGNORE INTO %s (folder_uuid, path, name, storage_uuid, storage_type, modified_time, name_pinyin, parent_folder_uuid) \
 205                                                         values (%Q, %Q, %Q, %Q, '%d', '%d', %Q, %Q); ",
 206                                                         MEDIA_SVC_DB_TABLE_FOLDER, folder_id, folder_path, folder_name, storage_id, storage_type, folder_modified_date, folder_name_pinyin, parent_folder_uuid);
 207
 208         if (!stack_query) {
 209                 ret = _media_svc_sql_query(sql, uid);
 210                 sqlite3_free(sql);
 211         } else {
 212                 _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 213         }
 214
 215         SAFE_FREE(folder_name);
 216         SAFE_FREE(folder_name_pinyin);
 217
 218         return ret;
 219 }
 220
 221 int _media_svc_update_folder_modified_time_by_folder_uuid(const char *folder_uuid, const char *folder_path, bool stack_query, uid_t uid)
 222 {
 223         int ret = MS_MEDIA_ERR_NONE;
 224         int modified_time = 0;
 225
 226         modified_time = _media_svc_get_file_time(folder_path);
 227
 228         char *sql = sqlite3_mprintf("UPDATE %s SET modified_time=%d WHERE folder_uuid=%Q;", MEDIA_SVC_DB_TABLE_FOLDER, modified_time, folder_uuid);
 229
 230         if (!stack_query) {
 231                 ret = _media_svc_sql_query(sql, uid);
 232                 sqlite3_free(sql);
 233         } else {
 234                 _media_svc_sql_query_add(&g_media_svc_move_item_query_list, &sql);
 235         }
 236
 237         return ret;
 238 }
 239
 240 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)
 241 {
 242         int ret = MS_MEDIA_ERR_NONE;
 243         unsigned int next_pos = 0;
 244         char *next = NULL;
 245         char *dir_path = NULL;
 246         const char *token = "/";
 247         char *folder_uuid = NULL;
 248         char parent_folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 249         bool folder_search_end = FALSE;
 250         char *internal_path = NULL;
 251
 252         memset(parent_folder_uuid, 0, sizeof(parent_folder_uuid));
 253         internal_path = _media_svc_get_path(uid);
 254
 255         if (STRING_VALID(internal_path) && (strncmp(path, internal_path, strlen(internal_path)) == 0))
 256                 next_pos = strlen(internal_path);
 257         else if (STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && strncmp(path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0)
 258                 next_pos = strlen(MEDIA_ROOT_PATH_SDCARD);
 259         else if (STRING_VALID(MEDIA_ROOT_PATH_CLOUD) && (strncmp(path, MEDIA_ROOT_PATH_CLOUD, strlen(MEDIA_ROOT_PATH_CLOUD)) == 0))
 260                 next_pos = strlen(MEDIA_ROOT_PATH_CLOUD);
 261         else if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && strncmp(path, MEDIA_ROOT_PATH_EXTERNAL, strlen(MEDIA_ROOT_PATH_EXTERNAL)) == 0)
 262                 next_pos = strlen(MEDIA_ROOT_PATH_EXTERNAL);
 263         else if (STRING_VALID(MEDIA_ROOT_PATH_DISC) && strncmp(path, MEDIA_ROOT_PATH_DISC, strlen(MEDIA_ROOT_PATH_DISC)) == 0)
 264                 next_pos = strlen(MEDIA_ROOT_PATH_DISC);
 265         else {
 266                 media_svc_error("Invalid Path");
 267                 SAFE_FREE(internal_path);
 268                 return MS_MEDIA_ERR_INTERNAL;
 269         }
 270
 271         SAFE_FREE(internal_path);
 272
 273         while (!folder_search_end) {
 274                 next = strstr(path + next_pos, token);
 275                 if (next != NULL) {
 276                         next_pos = (next - path);
 277                         dir_path = strndup(path, next_pos);
 278                         next_pos++;
 279                 } else {
 280                         dir_path = strndup(path, strlen(path));
 281                         folder_search_end = TRUE;
 282                         media_svc_error("[No-Error] End Path [%s]", dir_path);
 283                 }
 284
 285                 if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (strcmp(dir_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
 286                         /*To avoid insert MEDIA_ROOT_PATH_EXTERNAL path*/
 287                         continue;
 288                 }
 289
 290                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, dir_path, parent_folder_uuid, uid);
 291                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 292                         folder_uuid = _media_info_generate_uuid();
 293                         if (folder_uuid == NULL) {
 294                                 media_svc_error("Invalid UUID");
 295                                 SAFE_FREE(dir_path);
 296                                 return MS_MEDIA_ERR_INTERNAL;
 297                         }
 298
 299                         ret = __media_svc_append_folder(storage_id, storage_type, folder_uuid, dir_path, parent_folder_uuid, FALSE, uid);
 300                         if (ret != MS_MEDIA_ERR_NONE)
 301                                 media_svc_error("__media_svc_append_folder is failed");
 302
 303                         media_svc_error("[No-Error] New Appended folder path [%s], folder_uuid [%s], parent_folder_uuid [%s]", dir_path, folder_uuid, parent_folder_uuid);
 304                         _strncpy_safe(parent_folder_uuid, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
 305                 } else {
 306                         media_svc_error("EXIST dir path : %s\n", dir_path);
 307                 }
 308
 309                 SAFE_FREE(dir_path);
 310         }
 311
 312         if (STRING_VALID(folder_uuid)) {
 313                 _strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
 314         } else {
 315                 media_svc_error("Fail to get folder_uuid");
 316                 return MS_MEDIA_ERR_INTERNAL;
 317         }
 318
 319         return MS_MEDIA_ERR_NONE;
 320 }
 321
 322 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)
 323 {
 324         int ret = MS_MEDIA_ERR_NONE;
 325
 326         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path, folder_id, uid);
 327
 328         if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 329                 ret = __media_svc_get_and_append_parent_folder(handle, storage_id, path, storage_type, folder_id, uid);
 330
 331         return ret;
 332 }
 333
 334 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)
 335 {
 336         char *dir_path = NULL;
 337         int ret = MS_MEDIA_ERR_NONE;
 338
 339         dir_path = g_path_get_dirname(path);
 340
 341         ret = _media_svc_get_and_append_folder(handle, storage_id, dir_path, storage_type, folder_id, uid);
 342
 343         SAFE_FREE(dir_path);
 344
 345         return ret;
 346 }
 347
 348 int _media_svc_update_folder_table(const char *storage_id, uid_t uid)
 349 {
 350         int ret = MS_MEDIA_ERR_NONE;
 351         char *sql = NULL;
 352
 353         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'));",
 354                 MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, storage_id);
 355
 356         ret = _media_svc_sql_query(sql, uid);
 357         sqlite3_free(sql);
 358
 359         return ret;
 360 }
 361
 362 static int __media_svc_count_all_folders(sqlite3 *handle, char *start_path, int *count)
 363 {
 364         int ret = MS_MEDIA_ERR_NONE;
 365         sqlite3_stmt *sql_stmt = NULL;
 366         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 367
 368         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 369         if (ret != MS_MEDIA_ERR_NONE) {
 370                 media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
 371                 return ret;
 372         }
 373
 374         *count = sqlite3_column_int(sql_stmt, 0);
 375
 376         SQLITE3_FINALIZE(sql_stmt);
 377
 378         return MS_MEDIA_ERR_NONE;
 379 }
 380
 381 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)
 382 {
 383         int ret = MS_MEDIA_ERR_NONE;
 384         int idx = 0;
 385         sqlite3_stmt *sql_stmt = NULL;
 386         char *sql = NULL;
 387         int cnt = 0;
 388         char **folder_uuid = NULL;
 389         int i = 0;
 390
 391         ret = __media_svc_count_all_folders(handle, start_path, &cnt);
 392         if (ret != MS_MEDIA_ERR_NONE) {
 393                 media_svc_error("error when __media_svc_count_all_folders. err = [%d]", ret);
 394                 return ret;
 395         }
 396
 397         if (cnt > 0) {
 398                 sql = sqlite3_mprintf("SELECT path, modified_time, folder_uuid FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 399         } else {
 400                 *folder_list = NULL;
 401                 *modified_time_list = NULL;
 402                 *item_num_list = NULL;
 403                 return MS_MEDIA_ERR_NONE;
 404         }
 405
 406         *folder_list = malloc(sizeof(char *) * cnt);
 407         *modified_time_list = malloc(sizeof(int) * cnt);
 408         *item_num_list = malloc(sizeof(int) * cnt);
 409         folder_uuid = malloc(sizeof(char *) * cnt);
 410
 411         if ((*folder_list == NULL) || (*modified_time_list == NULL) || (*item_num_list == NULL) || (folder_uuid == NULL)) {
 412                 media_svc_error("Out of memory");
 413                 goto ERROR;
 414         }
 415         memset(folder_uuid, 0x0, sizeof(char *) * cnt);
 416         memset(*folder_list, 0x0, sizeof(char *) * cnt);
 417
 418         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 419         if (ret != MS_MEDIA_ERR_NONE) {
 420                 media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 421                 goto ERROR;
 422         }
 423
 424         media_svc_debug("QEURY OK");
 425
 426         while (idx < cnt) {
 427                 (*folder_list)[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 0));
 428                 (*modified_time_list)[idx] = (int)sqlite3_column_int(sql_stmt, 1);
 429
 430                 /* get the folder's id */
 431                 folder_uuid[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 2));
 432
 433                 idx++;
 434
 435                 if (sqlite3_step(sql_stmt) != SQLITE_ROW)
 436                         break;
 437         }
 438         SQLITE3_FINALIZE(sql_stmt);
 439
 440         /*get the numbder of item in the folder by using folder's id */
 441         for (i = 0; i < idx; i++) {
 442                 if (STRING_VALID(folder_uuid[i])) {
 443                         sql = sqlite3_mprintf("SELECT COUNT(*) FROM %s WHERE (folder_uuid='%q' AND validity = 1)", MEDIA_SVC_DB_TABLE_MEDIA, folder_uuid[i]);
 444                         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 445                         if (ret != MS_MEDIA_ERR_NONE) {
 446                                 media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 447                                 goto ERROR;
 448                         }
 449
 450                         (*item_num_list)[i] = (int)sqlite3_column_int(sql_stmt, 0);
 451
 452                         SQLITE3_FINALIZE(sql_stmt);
 453                 } else {
 454                         media_svc_error("Invalid Folder Id");
 455                 }
 456         }
 457
 458         if (cnt == idx) {
 459                 *count = cnt;
 460                 media_svc_debug("Get Folder is OK");
 461         } else {
 462                 media_svc_error("Fail to get folder");
 463                 ret = MS_MEDIA_ERR_INTERNAL;
 464                 goto ERROR;
 465         }
 466
 467         /* free all data */
 468         for (i = 0; i < idx; i++)
 469                 SAFE_FREE(folder_uuid[i]);
 470
 471         SAFE_FREE(folder_uuid);
 472
 473         return ret;
 474
 475 ERROR:
 476
 477         /* free all data */
 478         for (i = 0; i < idx; i++) {
 479                 SAFE_FREE((*folder_list)[i]);
 480                 SAFE_FREE(folder_uuid[i]);
 481         }
 482         SAFE_FREE(*folder_list);
 483         SAFE_FREE(*modified_time_list);
 484         SAFE_FREE(*item_num_list);
 485         SAFE_FREE(folder_uuid);
 486
 487         *count = 0;
 488
 489         return ret;
 490 }
 491
 492 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)
 493 {
 494         int ret = MS_MEDIA_ERR_NONE;
 495         sqlite3_stmt *sql_stmt = NULL;
 496
 497         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);
 498
 499         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 500
 501         if (ret != MS_MEDIA_ERR_NONE) {
 502                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 503                         media_svc_debug("there is no folder.");
 504                 else
 505                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
 506
 507                 return ret;
 508         }
 509
 510         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
 511         *modified_time = (int)sqlite3_column_int(sql_stmt, 1);
 512
 513         SQLITE3_FINALIZE(sql_stmt);
 514
 515         return ret;
 516 }
 517
 518 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)
 519 {
 520         char *path_name = NULL;
 521         int ret = MS_MEDIA_ERR_NONE;
 522         char *sql = NULL;
 523
 524         path_name = strdup(path);
 525         if (path_name == NULL) {
 526                 media_svc_error("out of memory");
 527                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
 528         }
 529
 530         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path_name, folder_id, uid);
 531         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 532                 bool is_root = FALSE;
 533                 bool is_parent_root = FALSE;
 534
 535                 ret = __media_svc_is_root_path(path_name, &is_root, uid);
 536                 ret = __media_svc_parent_is_ext_root_path(path_name, &is_parent_root);
 537
 538                 char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
 539                 memset(parent_folder_uuid, 0x00, sizeof(parent_folder_uuid));
 540
 541                 if ((is_root == FALSE) && (is_parent_root == FALSE)) {
 542                         /*get parent folder id*/
 543                         char *parent_path_name = g_path_get_dirname(path_name);
 544
 545                         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, parent_path_name, parent_folder_uuid, uid);
 546                         if (ret != MS_MEDIA_ERR_NONE) {
 547                                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 548                                 /*if No-Root directory scanning start before doing storage scanning, parent_folder_uuid can be NULL.
 549                                 You can remove above logic if use below logic always. but I keep above code for the performance issue.
 550                                 Most case (except No-Root directory scanning start before doing storage scanning) get parent_folder_uuid well*/
 551                                 media_svc_error("[No-Error] There is no proper parent_folder_uuid. so try to make it");
 552                                 ret = _media_svc_get_and_append_folder(handle, storage_id, path, storage_type, folder_id, uid);
 553                                 } else {
 554                                         media_svc_error("error when _media_svc_get_parent_folder_id_by_foldername. err = [%d]", ret);
 555                                 }
 556
 557                                 SAFE_FREE(path_name);
 558                                 SAFE_FREE(parent_path_name);
 559
 560                                 return ret;
 561                         }
 562                 }
 563
 564                 char *folder_uuid = _media_info_generate_uuid();
 565                 if (folder_uuid == NULL) {
 566                         media_svc_error("Invalid UUID");
 567                         SAFE_FREE(path_name);
 568                         return MS_MEDIA_ERR_INTERNAL;
 569                 }
 570
 571                 ret = __media_svc_append_folder(storage_id, storage_type, folder_uuid, path_name, parent_folder_uuid, stack_query, uid);
 572
 573                 _strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE+1);
 574
 575         } else {
 576                 sql = sqlite3_mprintf("UPDATE '%s' SET validity=1 WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 577
 578                 if (!stack_query) {
 579                         ret = _media_svc_sql_query(sql, uid);
 580                         sqlite3_free(sql);
 581                 } else {
 582                         _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 583                 }
 584         }
 585
 586         SAFE_FREE(path_name);
 587
 588         return ret;
 589 }
 590
 591 int _media_svc_delete_invalid_folder(const char *storage_id, int storage_type, uid_t uid)
 592 {
 593         int ret = MS_MEDIA_ERR_NONE;
 594         char *sql = NULL;
 595
 596         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d AND validity = 0;", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, storage_type);
 597         ret = _media_svc_sql_query(sql, uid);
 598
 599         sqlite3_free(sql);
 600
 601         return ret;
 602 }
 603
 604 int _media_svc_set_folder_validity(sqlite3 *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid)
 605 {
 606         int ret = MS_MEDIA_ERR_NONE;
 607         char *sql = NULL;
 608         char start_path_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
 609
 610         if (is_recursive) {
 611                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, start_path, start_path_id, uid);
 612                 media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_folder_id_by_foldername fail");
 613                 media_svc_retvm_if(!STRING_VALID(start_path_id), MS_MEDIA_ERR_INVALID_PARAMETER, "start_path_id is NULL");
 614
 615                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND (path LIKE '%q/%%' OR folder_uuid ='%q')",
 616                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path, start_path_id);
 617         } else {
 618                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND path = '%q';",
 619                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path);
 620         }
 621
 622         ret = _media_svc_sql_query(sql, uid);
 623
 624         sqlite3_free(sql);
 625
 626         return ret;
 627 }
 628
 629 int _media_svc_delete_folder_by_storage_id(const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 630 {
 631         int ret = MS_MEDIA_ERR_NONE;
 632         char *sql = NULL;
 633
 634         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d;", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, storage_type);
 635         ret = _media_svc_sql_query(sql, uid);
 636
 637         sqlite3_free(sql);
 638
 639         return ret;
 640 }
 641
 642 GList **_media_svc_get_folder_list_ptr(void)
 643 {
 644         return &g_media_svc_insert_folder_query_list;
 645 }
 646
 647 int _media_svc_get_folder_scan_status(sqlite3 *handle, const char *storage_id, const char *path, int *scan_status)
 648 {
 649         int ret = MS_MEDIA_ERR_NONE;
 650         sqlite3_stmt *sql_stmt = NULL;
 651         char *sql = NULL;
 652
 653         if (!STRING_VALID(path)) {
 654                 media_svc_error("Not found valid path");
 655                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 656         }
 657
 658         sql = sqlite3_mprintf("SELECT scan_status FROM '%s' WHERE path = '%q' AND storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 659
 660         ret = _media_svc_sql_prepare_to_step_simple(handle, sql, &sql_stmt);
 661
 662         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 663
 664         while (sqlite3_step(sql_stmt) == SQLITE_ROW)
 665                 *scan_status = sqlite3_column_int(sql_stmt, 0);
 666
 667         SQLITE3_FINALIZE(sql_stmt);
 668
 669         return ret;
 670 }
 671
 672 int _media_svc_set_folder_scan_status(const char *storage_id, const char *path, int scan_status, uid_t uid)
 673 {
 674         int ret = MS_MEDIA_ERR_NONE;
 675         char *sql = NULL;
 676
 677         if (path)
 678                 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);
 679         else
 680                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, scan_status, storage_id);
 681
 682         ret = _media_svc_sql_query(sql, uid);
 683         sqlite3_free(sql);
 684
 685         return ret;
 686 }
 687
 688 int _media_svc_get_folder_modified_time_by_path(sqlite3 *handle, const char *path, const char *storage_id, time_t *modified_time)
 689 {
 690         int ret = MS_MEDIA_ERR_NONE;
 691         sqlite3_stmt *sql_stmt = NULL;
 692
 693         char *sql = sqlite3_mprintf("SELECT modified_time FROM '%s' WHERE path = '%q' AND storage_uuid = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 694
 695         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 696
 697         if (ret != MS_MEDIA_ERR_NONE) {
 698                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 699                         media_svc_debug("there is no folder.");
 700                 else
 701                         media_svc_error("error when _media_svc_get_folder_modified_time_by_path. err = [%d]", ret);
 702
 703                 return ret;
 704         }
 705
 706         *modified_time = (int)sqlite3_column_int(sql_stmt, 0);
 707
 708         SQLITE3_FINALIZE(sql_stmt);
 709
 710         return ret;
 711 }
 712
 713 int _media_svc_get_null_scan_folder_list(sqlite3 *handle, const char *storage_id, const char *path, char ***folder_list, int *count)
 714 {
 715         int ret = MS_MEDIA_ERR_NONE;
 716         int idx = 0;
 717         int cnt = 0;
 718         char *sql = NULL;
 719         char folder_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
 720         sqlite3_stmt *sql_stmt = NULL;
 721
 722         if (path == NULL) {
 723                 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);
 724                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 725
 726                 if (ret != MS_MEDIA_ERR_NONE) {
 727                         if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 728                                 media_svc_debug("there is no folder.");
 729                         else
 730                                 media_svc_error("error when get folder_id by path. err = [%d]", ret);
 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