src/media_folder.c

   1  /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <media_info_private.h>
  19 #include <media_util_private.h>
  20 #ifdef _USE_TVPD_MODE
  21 #include <media_content_type_product.h>
  22 #endif
  23
  24 static char *g_src_path = NULL;
  25
  26 int media_folder_get_folder_count_from_db(filter_h filter, int *folder_count)
  27 {
  28         int ret = MEDIA_CONTENT_ERROR_NONE;
  29
  30         if (!folder_count) {
  31                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  32                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  33         }
  34 #ifdef _USE_TVPD_MODE
  35         g_mutex_lock(_content_get_db_mutex());
  36 #endif
  37
  38         ret = _media_db_get_group_count(filter, MEDIA_GROUP_FOLDER, folder_count);
  39
  40 #ifdef _USE_TVPD_MODE
  41         g_mutex_unlock(_content_get_db_mutex());
  42 #endif
  43
  44
  45         return ret;
  46 }
  47
  48 int media_folder_foreach_folder_from_db(filter_h filter, media_folder_cb callback, void *user_data)
  49 {
  50         int ret = MEDIA_CONTENT_ERROR_NONE;
  51
  52         if (callback == NULL) {
  53                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  54                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  55         }
  56
  57 #ifdef _USE_TVPD_MODE
  58         g_mutex_lock(_content_get_db_mutex());
  59 #endif
  60
  61         ret = _media_db_get_folder(filter, callback, user_data);
  62
  63 #ifdef _USE_TVPD_MODE
  64         g_mutex_unlock(_content_get_db_mutex());
  65 #endif
  66
  67         return ret;
  68 }
  69
  70 int media_folder_get_media_count_from_db(const char *folder_id, filter_h filter, int *media_count)
  71 {
  72         int ret = MEDIA_CONTENT_ERROR_NONE;
  73
  74         if (STRING_VALID(folder_id) && media_count) {
  75 #ifdef _USE_TVPD_MODE
  76                 g_mutex_lock(_content_get_db_mutex());
  77 #endif
  78
  79                 ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
  80
  81 #ifdef _USE_TVPD_MODE
  82                 g_mutex_unlock(_content_get_db_mutex());
  83 #endif
  84
  85         } else {
  86                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  87                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  88         }
  89
  90         return ret;
  91 }
  92
  93 int media_folder_foreach_media_from_db(const char *folder_id, filter_h filter, media_info_cb callback, void *user_data)
  94 {
  95         int ret = MEDIA_CONTENT_ERROR_NONE;
  96
  97         if ((callback != NULL) && STRING_VALID(folder_id)) {
  98 #ifdef _USE_TVPD_MODE
  99                 g_mutex_lock(_content_get_db_mutex());
 100 #endif
 101
 102                 ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
 103
 104 #ifdef _USE_TVPD_MODE
 105                 g_mutex_unlock(_content_get_db_mutex());
 106 #endif
 107
 108         } else {
 109                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 110                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 111         }
 112
 113         return ret;
 114 }
 115
 116 #ifdef _USE_SENIOR_MODE
 117 int media_folder_foreach_media_from_db_by_union_select(const char* folder_id, filter_h filter1, filter_h filter2, media_info_cb callback, void* user_data)
 118 {
 119         int ret = MEDIA_CONTENT_ERROR_NONE;
 120
 121         if ((callback != NULL) && STRING_VALID(folder_id)) {
 122                 ret = _media_db_get_group_item_by_union_select(folder_id, filter1, filter2, callback, user_data);
 123         } else {
 124                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 125                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 126         }
 127
 128         return ret;
 129 }
 130 #endif
 131
 132 int media_folder_destroy(media_folder_h folder)
 133 {
 134         int ret = MEDIA_CONTENT_ERROR_NONE;
 135         media_folder_s *_folder = (media_folder_s*)folder;
 136         if (_folder) {
 137                 SAFE_FREE(_folder->path);
 138                 SAFE_FREE(_folder->name);
 139                 SAFE_FREE(_folder->folder_id);
 140                 SAFE_FREE(_folder->storage_uuid);
 141                 SAFE_FREE(_folder);
 142                 ret = MEDIA_CONTENT_ERROR_NONE;
 143         } else {
 144                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 145                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 146         }
 147
 148         return ret;
 149 }
 150 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 151 {
 152         int ret = MEDIA_CONTENT_ERROR_NONE;
 153         media_folder_s *_src = (media_folder_s*)src;
 154
 155         if (_src != NULL) {
 156                 media_folder_s *_dst = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 157                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 158
 159                 if (STRING_VALID(_src->folder_id)) {
 160                         _dst->folder_id = strdup(_src->folder_id);
 161                         if (_dst->folder_id == NULL) {
 162                                 SAFE_FREE(_dst);
 163                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 164                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 165                         }
 166                 }
 167
 168                 if (STRING_VALID(_src->name)) {
 169                         _dst->name = strdup(_src->name);
 170                         if (_dst->name == NULL) {
 171                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 172                                 media_folder_destroy((media_folder_h)_dst);
 173                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 174                         }
 175                 }
 176
 177                 if (STRING_VALID(_src->path)) {
 178                         _dst->path = strdup(_src->path);
 179                         if (_dst->path == NULL) {
 180                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 181                                 media_folder_destroy((media_folder_h)_dst);
 182                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 183                         }
 184                 }
 185
 186                 if (STRING_VALID(_src->storage_uuid)) {
 187                         _dst->storage_uuid = strdup(_src->storage_uuid);
 188                         if (_dst->storage_uuid == NULL) {
 189                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 190                                 media_folder_destroy((media_folder_h)_dst);
 191                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 192                         }
 193                 }
 194
 195                 _dst->storage_type = _src->storage_type;
 196                 _dst->modified_time = _src->modified_time;
 197                 _dst->folder_order = _src->folder_order;
 198
 199                 *dst = (media_folder_h)_dst;
 200
 201                 ret = MEDIA_CONTENT_ERROR_NONE;
 202         } else {
 203                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 204                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 205         }
 206
 207         return ret;
 208 }
 209
 210 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 211 {
 212         int ret = MEDIA_CONTENT_ERROR_NONE;
 213         media_folder_s *_folder = (media_folder_s*)folder;
 214
 215         if (_folder) {
 216                 if (STRING_VALID(_folder->folder_id)) {
 217                         *folder_id = strdup(_folder->folder_id);
 218                         media_content_retvm_if(*folder_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 219                 } else {
 220                         *folder_id = NULL;
 221                 }
 222                 ret = MEDIA_CONTENT_ERROR_NONE;
 223         } else {
 224                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 225                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 226         }
 227
 228         return ret;
 229 }
 230
 231 int media_folder_get_parent_folder_id(media_folder_h folder, char **parent_folder_id)
 232 {
 233         int ret = MEDIA_CONTENT_ERROR_NONE;
 234         media_content_warn("DEPRECATION WARNING: media_folder_get_parent_folder_id() is deprecated and will be removed from next release.");
 235         media_folder_s *_folder = (media_folder_s*)folder;
 236         sqlite3_stmt *stmt = NULL;
 237         char tmp_path[MAX_PATH_LEN] = {0, };
 238         char *parent_path = NULL;
 239         char select_query[MAX_QUERY_SIZE] = {0, };
 240
 241         /* Usage is low. So, DB access when this function is called */
 242         if (_folder) {
 243                 memset(tmp_path, 0x00, sizeof(tmp_path));
 244                 memset(select_query, 0x00, sizeof(select_query));
 245
 246                 _media_content_replace_path(_folder->path, tmp_path);
 247
 248                 parent_path = g_path_get_dirname(tmp_path);
 249                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_ID_BY_PATH, parent_path);
 250                 SAFE_FREE(parent_path);
 251
 252                 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 253                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 254
 255                 if (sqlite3_step(stmt) == SQLITE_ROW)
 256                         *parent_folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 257                 else
 258                         *parent_folder_id = NULL;
 259
 260                 SQLITE3_FINALIZE(stmt);
 261
 262                 ret = MEDIA_CONTENT_ERROR_NONE;
 263         } else {
 264                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 265                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 266         }
 267
 268         return ret;
 269 }
 270
 271 int media_folder_get_path(media_folder_h folder, char **path)
 272 {
 273         int ret = MEDIA_CONTENT_ERROR_NONE;
 274         media_folder_s *_folder = (media_folder_s*)folder;
 275
 276         if (_folder) {
 277                 if (STRING_VALID(_folder->path)) {
 278                         *path = strdup(_folder->path);
 279                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 280                 } else {
 281                         *path = NULL;
 282                 }
 283                 ret = MEDIA_CONTENT_ERROR_NONE;
 284
 285         } else {
 286                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 287                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 288         }
 289
 290         return ret;
 291
 292 }
 293
 294 int media_folder_get_name(media_folder_h folder, char **name)
 295 {
 296         int ret = MEDIA_CONTENT_ERROR_NONE;
 297         media_folder_s *_folder = (media_folder_s*)folder;
 298
 299         if (_folder) {
 300                 if (STRING_VALID(_folder->name)) {
 301                         *name = strdup(_folder->name);
 302                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 303                 } else {
 304                         *name = NULL;
 305                 }
 306                 ret = MEDIA_CONTENT_ERROR_NONE;
 307
 308         } else {
 309                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 310                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 311         }
 312
 313         return ret;
 314 }
 315
 316 int media_folder_get_modified_time(media_folder_h folder, time_t* time)
 317 {
 318         int ret = MEDIA_CONTENT_ERROR_NONE;
 319         media_content_warn("DEPRECATION WARNING: media_folder_get_modified_time() is deprecated and will be removed from next release.");
 320         media_folder_s *_folder = (media_folder_s*)folder;
 321
 322         if (_folder) {
 323                 *time = _folder->modified_time;
 324                 ret = MEDIA_CONTENT_ERROR_NONE;
 325         } else {
 326                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 327                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 328         }
 329
 330         return ret;
 331 }
 332
 333 int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 334 {
 335         int ret = MEDIA_CONTENT_ERROR_NONE;
 336         media_content_warn("DEPRECATION WARNING: media_folder_get_storage_type() is deprecated and will be removed from next release. Use storage_get_type_dev() instead.");
 337         media_folder_s *_folder = (media_folder_s*)folder;
 338
 339         if (_folder) {
 340                 *storage_type = _folder->storage_type;
 341                 ret = MEDIA_CONTENT_ERROR_NONE;
 342         } else {
 343                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 344                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 345         }
 346
 347         return ret;
 348 }
 349
 350 int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
 351 {
 352         int ret = MEDIA_CONTENT_ERROR_NONE;
 353         media_content_warn("DEPRECATION WARNING: media_folder_get_storage_id() is deprecated and will be removed from next release.");
 354         media_folder_s *_folder = (media_folder_s*)folder;
 355
 356         if (_folder) {
 357                 if (STRING_VALID(_folder->storage_uuid)) {
 358                         *storage_id = strdup(_folder->storage_uuid);
 359                         media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 360                 } else {
 361                         *storage_id = NULL;
 362                 }
 363                 ret = MEDIA_CONTENT_ERROR_NONE;
 364
 365         } else {
 366                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 367                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 368         }
 369
 370         return ret;
 371 }
 372
 373 int media_folder_get_order(media_folder_h folder, int *order)
 374 {
 375         int ret = MEDIA_CONTENT_ERROR_NONE;
 376         media_content_warn("DEPRECATION WARNING: media_folder_get_order() is deprecated and will be removed from next release.");
 377         media_folder_s *_folder = (media_folder_s*)folder;
 378
 379         if (_folder) {
 380                 *order = _folder->folder_order;
 381                 ret = MEDIA_CONTENT_ERROR_NONE;
 382         } else {
 383                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 384                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 385         }
 386
 387         return ret;
 388 }
 389
 390
 391 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 392 {
 393         int ret = MEDIA_CONTENT_ERROR_NONE;
 394         sqlite3_stmt *stmt = NULL;
 395         char select_query[DEFAULT_QUERY_SIZE];
 396         char *tmp_path = NULL;
 397         char repl_path[MAX_PATH_LEN] = {0, };
 398         media_folder_s *_folder = NULL;
 399
 400         if (!STRING_VALID(folder_id)) {
 401                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 402                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 403         }
 404
 405         memset(select_query, 0x00, sizeof(select_query));
 406         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 407
 408         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 409         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 410
 411         if (sqlite3_step(stmt) == SQLITE_ROW) {
 412                 _folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 413                 if (_folder == NULL) {
 414                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 415                         SQLITE3_FINALIZE(stmt);
 416                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 417                 }
 418
 419                 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 420
 421                 tmp_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 422                 _media_content_rollback_path(tmp_path, repl_path);
 423                 _folder->path = g_strdup(repl_path);
 424                 SAFE_FREE(tmp_path);
 425
 426                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 427                 _folder->modified_time = (int)sqlite3_column_int(stmt, 3);
 428                 _folder->storage_type = (int)sqlite3_column_int(stmt, 5);
 429                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 6));
 430                 _folder->folder_order = (int)sqlite3_column_int(stmt, 7);
 431
 432                 *folder = (media_folder_h)_folder;
 433         }
 434
 435         SQLITE3_FINALIZE(stmt);
 436
 437         return ret;
 438 }
 439
 440 int media_folder_update_to_db(media_folder_h folder)
 441 {
 442         int ret = MEDIA_CONTENT_ERROR_NONE;
 443         media_content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 444         media_folder_s *_folder = (media_folder_s*)folder;
 445         char *sql = NULL;
 446         char repl_path[MAX_PATH_LEN] = {0, };
 447
 448         if ((_folder == NULL) || (_folder->folder_id == NULL)) {
 449                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 450                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 451         }
 452
 453         /* Update folder order */
 454         sql = sqlite3_mprintf(UPDATE_FOLDER_ORDER, _folder->folder_order, _folder->folder_id);
 455
 456         ret = _content_query_sql(sql);
 457         SQLITE3_SAFE_FREE(sql);
 458
 459         if (STRING_VALID(_folder->folder_id) && g_src_path) {
 460                 ret = _media_content_replace_path(_folder->path, repl_path);
 461                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 462                         SAFE_FREE(g_src_path);
 463                         return ret;
 464                 }
 465                 ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, repl_path, _content_get_uid());
 466                 SAFE_FREE(g_src_path);
 467
 468                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 469         }
 470
 471         return ret;
 472 }
 473
 474 int media_folder_set_name(media_folder_h folder, const char *name)
 475 {
 476         int ret = MEDIA_CONTENT_ERROR_NONE;
 477         media_content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 478         media_folder_s *_folder = (media_folder_s*)folder;
 479
 480         if (_folder != NULL && STRING_VALID(name) && name[0] != '.') {
 481                 if (STRING_VALID(_folder->path) && STRING_VALID(_folder->name)) {
 482                         char *folder_path = NULL;
 483                         char new_folder_path[MAX_PATH_LEN] = {0,};
 484                         char repl_path[MAX_PATH_LEN] = {0, };
 485
 486                         memset(repl_path, 0, sizeof(repl_path));
 487                         ret = _media_content_replace_path(_folder->path, repl_path);
 488                         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 489
 490                         folder_path = g_path_get_dirname(repl_path);
 491                         media_content_sec_debug("Existed Folder Path : %s", repl_path);
 492                         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 493                         media_content_sec_debug("New Path : %s", new_folder_path);
 494
 495                         SAFE_FREE(g_src_path);
 496                         g_src_path = strdup(repl_path);
 497
 498                         SAFE_FREE(_folder->path);
 499                         SAFE_FREE(_folder->name);
 500                         SAFE_FREE(folder_path);
 501                         memset(repl_path, 0, sizeof(repl_path));
 502                         ret = _media_content_rollback_path(new_folder_path, repl_path);
 503                         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 504
 505                         _folder->path = strdup(repl_path);
 506                         media_content_retvm_if(_folder->path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 507                         _folder->name = strdup(name);
 508                         media_content_retvm_if(_folder->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 509                 } else {
 510                         media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 511                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 512                 }
 513         } else {
 514                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 515                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 516         }
 517
 518         return ret;
 519 }
 520
 521 int media_folder_set_order(media_folder_h folder, int order)
 522 {
 523         int ret = MEDIA_CONTENT_ERROR_NONE;
 524         media_content_warn("DEPRECATION WARNING: media_folder_set_order() is deprecated and will be removed from next release.");
 525         media_folder_s *_folder = (media_folder_s*)folder;
 526
 527         if (_folder != NULL && order >= 0) {
 528                 _folder->folder_order = order;
 529         } else {
 530                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 531                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 532         }
 533
 534         return ret;
 535 }
 536 #ifdef _USE_TVPD_MODE
 537 int media_folder_insert_to_db(const char *path)
 538 {
 539         char repl_path[MAX_PATH_LEN] = {0, };
 540         int ret = MEDIA_CONTENT_ERROR_NONE;
 541         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 542         bool ignore_dir = FALSE;
 543
 544         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 545         memset(repl_path, 0, sizeof(repl_path));
 546         ret = _media_content_replace_path(path, repl_path);
 547         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 548
 549         ret = _media_util_check_ignore_dir(repl_path, &ignore_dir);
 550         media_content_retvm_if(ignore_dir, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 551
 552         ret = _media_content_check_dir(repl_path);
 553         media_content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 554         media_content_retvm_if(ret == MEDIA_CONTENT_ERROR_INVALID_PARAMETER, ret, "invalid path[%s]", path);
 555
 556         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 557         if (ret != MS_MEDIA_ERR_NONE) {
 558                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 559                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 560         }
 561
 562         ret = media_svc_check_folder_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
 563         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 564                 media_content_sec_debug("media_svc_check_folder_exist_by_path : no record : %s", repl_path);
 565                 media_svc_storage_type_e storage_type = 0;
 566
 567                 ret = media_svc_get_storage_type(repl_path, &storage_type, _content_get_uid());
 568                 if (ret != MS_MEDIA_ERR_NONE) {
 569                         media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
 570                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 571                 }
 572
 573                 ret = media_svc_insert_folder(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
 574                 if (ret != MS_MEDIA_ERR_NONE) {
 575                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 576                                 media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 577                                 ret = MEDIA_CONTENT_ERROR_NONE;
 578                         } else {
 579                                 media_content_sec_error("media_svc_insert_folder failed : %d (%s)", ret, repl_path);
 580                         }
 581
 582                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 583                 }
 584
 585                 ret = media_svc_set_folder_scan_status(storage_id, repl_path, MEDIA_DIR_SCAN_DONE, _content_get_uid());
 586                 if (ret != MS_MEDIA_ERR_NONE) {
 587                         media_content_sec_error("ms_set_folder_scan_status failed : %d", ret);
 588                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 589                 }
 590         } else if (ret != MS_MEDIA_ERR_NONE) {
 591                 media_content_sec_error("media_svc_check_folder_exist_by_path failed : %d (%s)", ret, repl_path);
 592                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 593         }
 594
 595         return ret;
 596 }
 597
 598 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 599 {
 600         int ret = MEDIA_CONTENT_ERROR_NONE;
 601         int status = MEDIA_DIR_SCAN_NONE;
 602
 603         if (STRING_VALID(storage_uuid) && STRING_VALID(path)) {
 604                 ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 605                 if (ret != MS_MEDIA_ERR_NONE) {
 606                         media_content_error("media_svc_get_folder_scan_status failed");
 607                         ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 608                 } else {
 609                         *scan_status = status;
 610                 }
 611         } else {
 612                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 613                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 614         }
 615
 616         return ret;
 617 }
 618 #endif