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         media_folder_s *_folder = NULL;
 397
 398         if (!STRING_VALID(folder_id)) {
 399                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 400                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 401         }
 402
 403         memset(select_query, 0x00, sizeof(select_query));
 404         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 405
 406         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 407         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 408
 409         if (sqlite3_step(stmt) == SQLITE_ROW) {
 410                 _folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 411                 if (_folder == NULL) {
 412                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 413                         SQLITE3_FINALIZE(stmt);
 414                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 415                 }
 416
 417                 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 418                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 419                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 420                 _folder->modified_time = (int)sqlite3_column_int(stmt, 3);
 421                 _folder->storage_type = (int)sqlite3_column_int(stmt, 5);
 422                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 6));
 423                 _folder->folder_order = (int)sqlite3_column_int(stmt, 7);
 424
 425                 *folder = (media_folder_h)_folder;
 426         }
 427
 428         SQLITE3_FINALIZE(stmt);
 429
 430         return ret;
 431 }
 432
 433 int media_folder_update_to_db(media_folder_h folder)
 434 {
 435         int ret = MEDIA_CONTENT_ERROR_NONE;
 436         media_content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 437         media_folder_s *_folder = (media_folder_s*)folder;
 438         char *sql = NULL;
 439         char repl_path[MAX_PATH_LEN] = {0, };
 440
 441         if ((_folder == NULL) || (_folder->folder_id == NULL)) {
 442                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 443                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 444         }
 445
 446         /* Update folder order */
 447         sql = sqlite3_mprintf(UPDATE_FOLDER_ORDER, _folder->folder_order, _folder->folder_id);
 448
 449         ret = _content_query_sql(sql);
 450         SQLITE3_SAFE_FREE(sql);
 451
 452         if (STRING_VALID(_folder->folder_id) && g_src_path) {
 453                 ret = _media_content_replace_path(_folder->path, repl_path);
 454                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 455                         SAFE_FREE(g_src_path);
 456                         return ret;
 457                 }
 458                 ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, repl_path, _content_get_uid());
 459                 SAFE_FREE(g_src_path);
 460
 461                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 462         }
 463
 464         return ret;
 465 }
 466
 467 int media_folder_set_name(media_folder_h folder, const char *name)
 468 {
 469         int ret = MEDIA_CONTENT_ERROR_NONE;
 470         media_content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 471         media_folder_s *_folder = (media_folder_s*)folder;
 472
 473         if (_folder != NULL && STRING_VALID(name) && name[0] != '.') {
 474                 if (STRING_VALID(_folder->path) && STRING_VALID(_folder->name)) {
 475                         char *folder_path = NULL;
 476                         char new_folder_path[MAX_PATH_LEN] = {0,};
 477                         char repl_path[MAX_PATH_LEN] = {0, };
 478
 479                         memset(repl_path, 0, sizeof(repl_path));
 480                         ret = _media_content_replace_path(_folder->path, repl_path);
 481                         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 482
 483                         folder_path = g_path_get_dirname(repl_path);
 484                         media_content_sec_debug("Existed Folder Path : %s", repl_path);
 485                         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 486                         media_content_sec_debug("New Path : %s", new_folder_path);
 487
 488                         SAFE_FREE(g_src_path);
 489                         g_src_path = strdup(repl_path);
 490
 491                         SAFE_FREE(_folder->path);
 492                         SAFE_FREE(_folder->name);
 493                         SAFE_FREE(folder_path);
 494
 495                         _folder->path = strdup(new_folder_path);
 496                         media_content_retvm_if(_folder->path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 497                         _folder->name = strdup(name);
 498                         media_content_retvm_if(_folder->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 499                 } else {
 500                         media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 501                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 502                 }
 503         } else {
 504                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 505                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 506         }
 507
 508         return ret;
 509 }
 510
 511 int media_folder_set_order(media_folder_h folder, int order)
 512 {
 513         int ret = MEDIA_CONTENT_ERROR_NONE;
 514         media_content_warn("DEPRECATION WARNING: media_folder_set_order() is deprecated and will be removed from next release.");
 515         media_folder_s *_folder = (media_folder_s*)folder;
 516
 517         if (_folder != NULL && order >= 0) {
 518                 _folder->folder_order = order;
 519         } else {
 520                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 521                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 522         }
 523
 524         return ret;
 525 }
 526 #ifdef _USE_TVPD_MODE
 527 int media_folder_insert_to_db(const char *path)
 528 {
 529         char repl_path[MAX_PATH_LEN] = {0, };
 530         int ret = MEDIA_CONTENT_ERROR_NONE;
 531         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 532         bool ignore_dir = FALSE;
 533
 534         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 535         memset(repl_path, 0, sizeof(repl_path));
 536         ret = _media_content_replace_path(path, repl_path);
 537         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 538
 539         ret = _media_util_check_ignore_dir(repl_path, &ignore_dir);
 540         media_content_retvm_if(ignore_dir, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 541
 542         ret = _media_content_check_dir(repl_path);
 543         media_content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 544         media_content_retvm_if(ret == MEDIA_CONTENT_ERROR_INVALID_PARAMETER, ret, "invalid path[%s]", path);
 545
 546         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 547         if (ret != MS_MEDIA_ERR_NONE) {
 548                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 549                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 550         }
 551
 552         ret = media_svc_check_folder_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
 553         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 554                 media_content_sec_debug("media_svc_check_folder_exist_by_path : no record : %s", repl_path);
 555                 media_svc_storage_type_e storage_type = 0;
 556
 557                 ret = media_svc_get_storage_type(repl_path, &storage_type, _content_get_uid());
 558                 if (ret != MS_MEDIA_ERR_NONE) {
 559                         media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
 560                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 561                 }
 562
 563                 ret = media_svc_insert_folder(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
 564                 if (ret != MS_MEDIA_ERR_NONE) {
 565                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 566                                 media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 567                                 ret = MEDIA_CONTENT_ERROR_NONE;
 568                         } else {
 569                                 media_content_sec_error("media_svc_insert_folder failed : %d (%s)", ret, repl_path);
 570                         }
 571
 572                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 573                 }
 574
 575                 ret = media_svc_set_folder_scan_status(storage_id, repl_path, MEDIA_DIR_SCAN_DONE, _content_get_uid());
 576                 if (ret != MS_MEDIA_ERR_NONE) {
 577                         media_content_sec_error("ms_set_folder_scan_status failed : %d", ret);
 578                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 579                 }
 580         } else if (ret != MS_MEDIA_ERR_NONE) {
 581                 media_content_sec_error("media_svc_check_folder_exist_by_path failed : %d (%s)", ret, repl_path);
 582                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 583         }
 584
 585         return ret;
 586 }
 587
 588 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 589 {
 590         int ret = MEDIA_CONTENT_ERROR_NONE;
 591         int status = MEDIA_DIR_SCAN_NONE;
 592
 593         if (STRING_VALID(storage_uuid) && STRING_VALID(path)) {
 594                 ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 595                 if (ret != MS_MEDIA_ERR_NONE) {
 596                         media_content_error("media_svc_get_folder_scan_status failed");
 597                         ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 598                 } else {
 599                         *scan_status = status;
 600                 }
 601         } else {
 602                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 603                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 604         }
 605
 606         return ret;
 607 }
 608 #endif