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